1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * linux/fs/jbd2/journal.c
4  *
5  * Written by Stephen C. Tweedie <sct@redhat.com>, 1998
6  *
7  * Copyright 1998 Red Hat corp --- All Rights Reserved
8  *
9  * Generic filesystem journal-writing code; part of the ext2fs
10  * journaling system.
11  *
12  * This file manages journals: areas of disk reserved for logging
13  * transactional updates.  This includes the kernel journaling thread
14  * which is responsible for scheduling updates to the log.
15  *
16  * We do not actually manage the physical storage of the journal in this
17  * file: that is left to a per-journal policy function, which allows us
18  * to store the journal within a filesystem-specified area for ext2
19  * journaling (ext2 can use a reserved inode for storing the log).
20  */
21 
22 #include <linux/module.h>
23 #include <linux/time.h>
24 #include <linux/fs.h>
25 #include <linux/jbd2.h>
26 #include <linux/errno.h>
27 #include <linux/slab.h>
28 #include <linux/init.h>
29 #include <linux/mm.h>
30 #include <linux/freezer.h>
31 #include <linux/pagemap.h>
32 #include <linux/kthread.h>
33 #include <linux/poison.h>
34 #include <linux/proc_fs.h>
35 #include <linux/seq_file.h>
36 #include <linux/math64.h>
37 #include <linux/hash.h>
38 #include <linux/log2.h>
39 #include <linux/vmalloc.h>
40 #include <linux/backing-dev.h>
41 #include <linux/bitops.h>
42 #include <linux/ratelimit.h>
43 #include <linux/sched/mm.h>
44 
45 #define CREATE_TRACE_POINTS
46 #include <trace/events/jbd2.h>
47 
48 #include <linux/uaccess.h>
49 #include <asm/page.h>
50 
51 #ifdef CONFIG_JBD2_DEBUG
52 static ushort jbd2_journal_enable_debug __read_mostly;
53 
54 module_param_named(jbd2_debug, jbd2_journal_enable_debug, ushort, 0644);
55 MODULE_PARM_DESC(jbd2_debug, "Debugging level for jbd2");
56 #endif
57 
58 EXPORT_SYMBOL(jbd2_journal_extend);
59 EXPORT_SYMBOL(jbd2_journal_stop);
60 EXPORT_SYMBOL(jbd2_journal_lock_updates);
61 EXPORT_SYMBOL(jbd2_journal_unlock_updates);
62 EXPORT_SYMBOL(jbd2_journal_get_write_access);
63 EXPORT_SYMBOL(jbd2_journal_get_create_access);
64 EXPORT_SYMBOL(jbd2_journal_get_undo_access);
65 EXPORT_SYMBOL(jbd2_journal_set_triggers);
66 EXPORT_SYMBOL(jbd2_journal_dirty_metadata);
67 EXPORT_SYMBOL(jbd2_journal_forget);
68 EXPORT_SYMBOL(jbd2_journal_flush);
69 EXPORT_SYMBOL(jbd2_journal_revoke);
70 
71 EXPORT_SYMBOL(jbd2_journal_init_dev);
72 EXPORT_SYMBOL(jbd2_journal_init_inode);
73 EXPORT_SYMBOL(jbd2_journal_check_used_features);
74 EXPORT_SYMBOL(jbd2_journal_check_available_features);
75 EXPORT_SYMBOL(jbd2_journal_set_features);
76 EXPORT_SYMBOL(jbd2_journal_load);
77 EXPORT_SYMBOL(jbd2_journal_destroy);
78 EXPORT_SYMBOL(jbd2_journal_abort);
79 EXPORT_SYMBOL(jbd2_journal_errno);
80 EXPORT_SYMBOL(jbd2_journal_ack_err);
81 EXPORT_SYMBOL(jbd2_journal_clear_err);
82 EXPORT_SYMBOL(jbd2_log_wait_commit);
83 EXPORT_SYMBOL(jbd2_journal_start_commit);
84 EXPORT_SYMBOL(jbd2_journal_force_commit_nested);
85 EXPORT_SYMBOL(jbd2_journal_wipe);
86 EXPORT_SYMBOL(jbd2_journal_blocks_per_page);
87 EXPORT_SYMBOL(jbd2_journal_invalidate_folio);
88 EXPORT_SYMBOL(jbd2_journal_try_to_free_buffers);
89 EXPORT_SYMBOL(jbd2_journal_force_commit);
90 EXPORT_SYMBOL(jbd2_journal_inode_ranged_write);
91 EXPORT_SYMBOL(jbd2_journal_inode_ranged_wait);
92 EXPORT_SYMBOL(jbd2_journal_submit_inode_data_buffers);
93 EXPORT_SYMBOL(jbd2_journal_finish_inode_data_buffers);
94 EXPORT_SYMBOL(jbd2_journal_init_jbd_inode);
95 EXPORT_SYMBOL(jbd2_journal_release_jbd_inode);
96 EXPORT_SYMBOL(jbd2_journal_begin_ordered_truncate);
97 EXPORT_SYMBOL(jbd2_inode_cache);
98 
99 static int jbd2_journal_create_slab(size_t slab_size);
100 
101 #ifdef CONFIG_JBD2_DEBUG
__jbd2_debug(int level,const char * file,const char * func,unsigned int line,const char * fmt,...)102 void __jbd2_debug(int level, const char *file, const char *func,
103 		  unsigned int line, const char *fmt, ...)
104 {
105 	struct va_format vaf;
106 	va_list args;
107 
108 	if (level > jbd2_journal_enable_debug)
109 		return;
110 	va_start(args, fmt);
111 	vaf.fmt = fmt;
112 	vaf.va = &args;
113 	printk(KERN_DEBUG "%s: (%s, %u): %pV", file, func, line, &vaf);
114 	va_end(args);
115 }
116 #endif
117 
118 /* Checksumming functions */
jbd2_verify_csum_type(journal_t * j,journal_superblock_t * sb)119 static int jbd2_verify_csum_type(journal_t *j, journal_superblock_t *sb)
120 {
121 	if (!jbd2_journal_has_csum_v2or3_feature(j))
122 		return 1;
123 
124 	return sb->s_checksum_type == JBD2_CRC32C_CHKSUM;
125 }
126 
jbd2_superblock_csum(journal_t * j,journal_superblock_t * sb)127 static __be32 jbd2_superblock_csum(journal_t *j, journal_superblock_t *sb)
128 {
129 	__u32 csum;
130 	__be32 old_csum;
131 
132 	old_csum = sb->s_checksum;
133 	sb->s_checksum = 0;
134 	csum = jbd2_chksum(j, ~0, (char *)sb, sizeof(journal_superblock_t));
135 	sb->s_checksum = old_csum;
136 
137 	return cpu_to_be32(csum);
138 }
139 
140 /*
141  * Helper function used to manage commit timeouts
142  */
143 
commit_timeout(struct timer_list * t)144 static void commit_timeout(struct timer_list *t)
145 {
146 	journal_t *journal = from_timer(journal, t, j_commit_timer);
147 
148 	wake_up_process(journal->j_task);
149 }
150 
151 /*
152  * kjournald2: The main thread function used to manage a logging device
153  * journal.
154  *
155  * This kernel thread is responsible for two things:
156  *
157  * 1) COMMIT:  Every so often we need to commit the current state of the
158  *    filesystem to disk.  The journal thread is responsible for writing
159  *    all of the metadata buffers to disk. If a fast commit is ongoing
160  *    journal thread waits until it's done and then continues from
161  *    there on.
162  *
163  * 2) CHECKPOINT: We cannot reuse a used section of the log file until all
164  *    of the data in that part of the log has been rewritten elsewhere on
165  *    the disk.  Flushing these old buffers to reclaim space in the log is
166  *    known as checkpointing, and this thread is responsible for that job.
167  */
168 
kjournald2(void * arg)169 static int kjournald2(void *arg)
170 {
171 	journal_t *journal = arg;
172 	transaction_t *transaction;
173 
174 	/*
175 	 * Set up an interval timer which can be used to trigger a commit wakeup
176 	 * after the commit interval expires
177 	 */
178 	timer_setup(&journal->j_commit_timer, commit_timeout, 0);
179 
180 	set_freezable();
181 
182 	/* Record that the journal thread is running */
183 	journal->j_task = current;
184 	wake_up(&journal->j_wait_done_commit);
185 
186 	/*
187 	 * Make sure that no allocations from this kernel thread will ever
188 	 * recurse to the fs layer because we are responsible for the
189 	 * transaction commit and any fs involvement might get stuck waiting for
190 	 * the trasn. commit.
191 	 */
192 	memalloc_nofs_save();
193 
194 	/*
195 	 * And now, wait forever for commit wakeup events.
196 	 */
197 	write_lock(&journal->j_state_lock);
198 
199 loop:
200 	if (journal->j_flags & JBD2_UNMOUNT)
201 		goto end_loop;
202 
203 	jbd2_debug(1, "commit_sequence=%u, commit_request=%u\n",
204 		journal->j_commit_sequence, journal->j_commit_request);
205 
206 	if (journal->j_commit_sequence != journal->j_commit_request) {
207 		jbd2_debug(1, "OK, requests differ\n");
208 		write_unlock(&journal->j_state_lock);
209 		del_timer_sync(&journal->j_commit_timer);
210 		jbd2_journal_commit_transaction(journal);
211 		write_lock(&journal->j_state_lock);
212 		goto loop;
213 	}
214 
215 	wake_up(&journal->j_wait_done_commit);
216 	if (freezing(current)) {
217 		/*
218 		 * The simpler the better. Flushing journal isn't a
219 		 * good idea, because that depends on threads that may
220 		 * be already stopped.
221 		 */
222 		jbd2_debug(1, "Now suspending kjournald2\n");
223 		write_unlock(&journal->j_state_lock);
224 		try_to_freeze();
225 		write_lock(&journal->j_state_lock);
226 	} else {
227 		/*
228 		 * We assume on resume that commits are already there,
229 		 * so we don't sleep
230 		 */
231 		DEFINE_WAIT(wait);
232 		int should_sleep = 1;
233 
234 		prepare_to_wait(&journal->j_wait_commit, &wait,
235 				TASK_INTERRUPTIBLE);
236 		if (journal->j_commit_sequence != journal->j_commit_request)
237 			should_sleep = 0;
238 		transaction = journal->j_running_transaction;
239 		if (transaction && time_after_eq(jiffies,
240 						transaction->t_expires))
241 			should_sleep = 0;
242 		if (journal->j_flags & JBD2_UNMOUNT)
243 			should_sleep = 0;
244 		if (should_sleep) {
245 			write_unlock(&journal->j_state_lock);
246 			schedule();
247 			write_lock(&journal->j_state_lock);
248 		}
249 		finish_wait(&journal->j_wait_commit, &wait);
250 	}
251 
252 	jbd2_debug(1, "kjournald2 wakes\n");
253 
254 	/*
255 	 * Were we woken up by a commit wakeup event?
256 	 */
257 	transaction = journal->j_running_transaction;
258 	if (transaction && time_after_eq(jiffies, transaction->t_expires)) {
259 		journal->j_commit_request = transaction->t_tid;
260 		jbd2_debug(1, "woke because of timeout\n");
261 	}
262 	goto loop;
263 
264 end_loop:
265 	del_timer_sync(&journal->j_commit_timer);
266 	journal->j_task = NULL;
267 	wake_up(&journal->j_wait_done_commit);
268 	jbd2_debug(1, "Journal thread exiting.\n");
269 	write_unlock(&journal->j_state_lock);
270 	return 0;
271 }
272 
jbd2_journal_start_thread(journal_t * journal)273 static int jbd2_journal_start_thread(journal_t *journal)
274 {
275 	struct task_struct *t;
276 
277 	t = kthread_run(kjournald2, journal, "jbd2/%s",
278 			journal->j_devname);
279 	if (IS_ERR(t))
280 		return PTR_ERR(t);
281 
282 	wait_event(journal->j_wait_done_commit, journal->j_task != NULL);
283 	return 0;
284 }
285 
journal_kill_thread(journal_t * journal)286 static void journal_kill_thread(journal_t *journal)
287 {
288 	write_lock(&journal->j_state_lock);
289 	journal->j_flags |= JBD2_UNMOUNT;
290 
291 	while (journal->j_task) {
292 		write_unlock(&journal->j_state_lock);
293 		wake_up(&journal->j_wait_commit);
294 		wait_event(journal->j_wait_done_commit, journal->j_task == NULL);
295 		write_lock(&journal->j_state_lock);
296 	}
297 	write_unlock(&journal->j_state_lock);
298 }
299 
300 /*
301  * jbd2_journal_write_metadata_buffer: write a metadata buffer to the journal.
302  *
303  * Writes a metadata buffer to a given disk block.  The actual IO is not
304  * performed but a new buffer_head is constructed which labels the data
305  * to be written with the correct destination disk block.
306  *
307  * Any magic-number escaping which needs to be done will cause a
308  * copy-out here.  If the buffer happens to start with the
309  * JBD2_MAGIC_NUMBER, then we can't write it to the log directly: the
310  * magic number is only written to the log for descripter blocks.  In
311  * this case, we copy the data and replace the first word with 0, and we
312  * return a result code which indicates that this buffer needs to be
313  * marked as an escaped buffer in the corresponding log descriptor
314  * block.  The missing word can then be restored when the block is read
315  * during recovery.
316  *
317  * If the source buffer has already been modified by a new transaction
318  * since we took the last commit snapshot, we use the frozen copy of
319  * that data for IO. If we end up using the existing buffer_head's data
320  * for the write, then we have to make sure nobody modifies it while the
321  * IO is in progress. do_get_write_access() handles this.
322  *
323  * The function returns a pointer to the buffer_head to be used for IO.
324  *
325  *
326  * Return value:
327  *  <0: Error
328  * >=0: Finished OK
329  *
330  * On success:
331  * Bit 0 set == escape performed on the data
332  * Bit 1 set == buffer copy-out performed (kfree the data after IO)
333  */
334 
jbd2_journal_write_metadata_buffer(transaction_t * transaction,struct journal_head * jh_in,struct buffer_head ** bh_out,sector_t blocknr)335 int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
336 				  struct journal_head  *jh_in,
337 				  struct buffer_head **bh_out,
338 				  sector_t blocknr)
339 {
340 	int need_copy_out = 0;
341 	int done_copy_out = 0;
342 	int do_escape = 0;
343 	char *mapped_data;
344 	struct buffer_head *new_bh;
345 	struct page *new_page;
346 	unsigned int new_offset;
347 	struct buffer_head *bh_in = jh2bh(jh_in);
348 	journal_t *journal = transaction->t_journal;
349 
350 	/*
351 	 * The buffer really shouldn't be locked: only the current committing
352 	 * transaction is allowed to write it, so nobody else is allowed
353 	 * to do any IO.
354 	 *
355 	 * akpm: except if we're journalling data, and write() output is
356 	 * also part of a shared mapping, and another thread has
357 	 * decided to launch a writepage() against this buffer.
358 	 */
359 	J_ASSERT_BH(bh_in, buffer_jbddirty(bh_in));
360 
361 	new_bh = alloc_buffer_head(GFP_NOFS|__GFP_NOFAIL);
362 
363 	/* keep subsequent assertions sane */
364 	atomic_set(&new_bh->b_count, 1);
365 
366 	spin_lock(&jh_in->b_state_lock);
367 repeat:
368 	/*
369 	 * If a new transaction has already done a buffer copy-out, then
370 	 * we use that version of the data for the commit.
371 	 */
372 	if (jh_in->b_frozen_data) {
373 		done_copy_out = 1;
374 		new_page = virt_to_page(jh_in->b_frozen_data);
375 		new_offset = offset_in_page(jh_in->b_frozen_data);
376 	} else {
377 		new_page = jh2bh(jh_in)->b_page;
378 		new_offset = offset_in_page(jh2bh(jh_in)->b_data);
379 	}
380 
381 	mapped_data = kmap_atomic(new_page);
382 	/*
383 	 * Fire data frozen trigger if data already wasn't frozen.  Do this
384 	 * before checking for escaping, as the trigger may modify the magic
385 	 * offset.  If a copy-out happens afterwards, it will have the correct
386 	 * data in the buffer.
387 	 */
388 	if (!done_copy_out)
389 		jbd2_buffer_frozen_trigger(jh_in, mapped_data + new_offset,
390 					   jh_in->b_triggers);
391 
392 	/*
393 	 * Check for escaping
394 	 */
395 	if (*((__be32 *)(mapped_data + new_offset)) ==
396 				cpu_to_be32(JBD2_MAGIC_NUMBER)) {
397 		need_copy_out = 1;
398 		do_escape = 1;
399 	}
400 	kunmap_atomic(mapped_data);
401 
402 	/*
403 	 * Do we need to do a data copy?
404 	 */
405 	if (need_copy_out && !done_copy_out) {
406 		char *tmp;
407 
408 		spin_unlock(&jh_in->b_state_lock);
409 		tmp = jbd2_alloc(bh_in->b_size, GFP_NOFS);
410 		if (!tmp) {
411 			brelse(new_bh);
412 			return -ENOMEM;
413 		}
414 		spin_lock(&jh_in->b_state_lock);
415 		if (jh_in->b_frozen_data) {
416 			jbd2_free(tmp, bh_in->b_size);
417 			goto repeat;
418 		}
419 
420 		jh_in->b_frozen_data = tmp;
421 		mapped_data = kmap_atomic(new_page);
422 		memcpy(tmp, mapped_data + new_offset, bh_in->b_size);
423 		kunmap_atomic(mapped_data);
424 
425 		new_page = virt_to_page(tmp);
426 		new_offset = offset_in_page(tmp);
427 		done_copy_out = 1;
428 
429 		/*
430 		 * This isn't strictly necessary, as we're using frozen
431 		 * data for the escaping, but it keeps consistency with
432 		 * b_frozen_data usage.
433 		 */
434 		jh_in->b_frozen_triggers = jh_in->b_triggers;
435 	}
436 
437 	/*
438 	 * Did we need to do an escaping?  Now we've done all the
439 	 * copying, we can finally do so.
440 	 */
441 	if (do_escape) {
442 		mapped_data = kmap_atomic(new_page);
443 		*((unsigned int *)(mapped_data + new_offset)) = 0;
444 		kunmap_atomic(mapped_data);
445 	}
446 
447 	set_bh_page(new_bh, new_page, new_offset);
448 	new_bh->b_size = bh_in->b_size;
449 	new_bh->b_bdev = journal->j_dev;
450 	new_bh->b_blocknr = blocknr;
451 	new_bh->b_private = bh_in;
452 	set_buffer_mapped(new_bh);
453 	set_buffer_dirty(new_bh);
454 
455 	*bh_out = new_bh;
456 
457 	/*
458 	 * The to-be-written buffer needs to get moved to the io queue,
459 	 * and the original buffer whose contents we are shadowing or
460 	 * copying is moved to the transaction's shadow queue.
461 	 */
462 	JBUFFER_TRACE(jh_in, "file as BJ_Shadow");
463 	spin_lock(&journal->j_list_lock);
464 	__jbd2_journal_file_buffer(jh_in, transaction, BJ_Shadow);
465 	spin_unlock(&journal->j_list_lock);
466 	set_buffer_shadow(bh_in);
467 	spin_unlock(&jh_in->b_state_lock);
468 
469 	return do_escape | (done_copy_out << 1);
470 }
471 
472 /*
473  * Allocation code for the journal file.  Manage the space left in the
474  * journal, so that we can begin checkpointing when appropriate.
475  */
476 
477 /*
478  * Called with j_state_lock locked for writing.
479  * Returns true if a transaction commit was started.
480  */
__jbd2_log_start_commit(journal_t * journal,tid_t target)481 static int __jbd2_log_start_commit(journal_t *journal, tid_t target)
482 {
483 	/* Return if the txn has already requested to be committed */
484 	if (journal->j_commit_request == target)
485 		return 0;
486 
487 	/*
488 	 * The only transaction we can possibly wait upon is the
489 	 * currently running transaction (if it exists).  Otherwise,
490 	 * the target tid must be an old one.
491 	 */
492 	if (journal->j_running_transaction &&
493 	    journal->j_running_transaction->t_tid == target) {
494 		/*
495 		 * We want a new commit: OK, mark the request and wakeup the
496 		 * commit thread.  We do _not_ do the commit ourselves.
497 		 */
498 
499 		journal->j_commit_request = target;
500 		jbd2_debug(1, "JBD2: requesting commit %u/%u\n",
501 			  journal->j_commit_request,
502 			  journal->j_commit_sequence);
503 		journal->j_running_transaction->t_requested = jiffies;
504 		wake_up(&journal->j_wait_commit);
505 		return 1;
506 	} else if (!tid_geq(journal->j_commit_request, target))
507 		/* This should never happen, but if it does, preserve
508 		   the evidence before kjournald goes into a loop and
509 		   increments j_commit_sequence beyond all recognition. */
510 		WARN_ONCE(1, "JBD2: bad log_start_commit: %u %u %u %u\n",
511 			  journal->j_commit_request,
512 			  journal->j_commit_sequence,
513 			  target, journal->j_running_transaction ?
514 			  journal->j_running_transaction->t_tid : 0);
515 	return 0;
516 }
517 
jbd2_log_start_commit(journal_t * journal,tid_t tid)518 int jbd2_log_start_commit(journal_t *journal, tid_t tid)
519 {
520 	int ret;
521 
522 	write_lock(&journal->j_state_lock);
523 	ret = __jbd2_log_start_commit(journal, tid);
524 	write_unlock(&journal->j_state_lock);
525 	return ret;
526 }
527 
528 /*
529  * Force and wait any uncommitted transactions.  We can only force the running
530  * transaction if we don't have an active handle, otherwise, we will deadlock.
531  * Returns: <0 in case of error,
532  *           0 if nothing to commit,
533  *           1 if transaction was successfully committed.
534  */
__jbd2_journal_force_commit(journal_t * journal)535 static int __jbd2_journal_force_commit(journal_t *journal)
536 {
537 	transaction_t *transaction = NULL;
538 	tid_t tid;
539 	int need_to_start = 0, ret = 0;
540 
541 	read_lock(&journal->j_state_lock);
542 	if (journal->j_running_transaction && !current->journal_info) {
543 		transaction = journal->j_running_transaction;
544 		if (!tid_geq(journal->j_commit_request, transaction->t_tid))
545 			need_to_start = 1;
546 	} else if (journal->j_committing_transaction)
547 		transaction = journal->j_committing_transaction;
548 
549 	if (!transaction) {
550 		/* Nothing to commit */
551 		read_unlock(&journal->j_state_lock);
552 		return 0;
553 	}
554 	tid = transaction->t_tid;
555 	read_unlock(&journal->j_state_lock);
556 	if (need_to_start)
557 		jbd2_log_start_commit(journal, tid);
558 	ret = jbd2_log_wait_commit(journal, tid);
559 	if (!ret)
560 		ret = 1;
561 
562 	return ret;
563 }
564 
565 /**
566  * jbd2_journal_force_commit_nested - Force and wait upon a commit if the
567  * calling process is not within transaction.
568  *
569  * @journal: journal to force
570  * Returns true if progress was made.
571  *
572  * This is used for forcing out undo-protected data which contains
573  * bitmaps, when the fs is running out of space.
574  */
jbd2_journal_force_commit_nested(journal_t * journal)575 int jbd2_journal_force_commit_nested(journal_t *journal)
576 {
577 	int ret;
578 
579 	ret = __jbd2_journal_force_commit(journal);
580 	return ret > 0;
581 }
582 
583 /**
584  * jbd2_journal_force_commit() - force any uncommitted transactions
585  * @journal: journal to force
586  *
587  * Caller want unconditional commit. We can only force the running transaction
588  * if we don't have an active handle, otherwise, we will deadlock.
589  */
jbd2_journal_force_commit(journal_t * journal)590 int jbd2_journal_force_commit(journal_t *journal)
591 {
592 	int ret;
593 
594 	J_ASSERT(!current->journal_info);
595 	ret = __jbd2_journal_force_commit(journal);
596 	if (ret > 0)
597 		ret = 0;
598 	return ret;
599 }
600 
601 /*
602  * Start a commit of the current running transaction (if any).  Returns true
603  * if a transaction is going to be committed (or is currently already
604  * committing), and fills its tid in at *ptid
605  */
jbd2_journal_start_commit(journal_t * journal,tid_t * ptid)606 int jbd2_journal_start_commit(journal_t *journal, tid_t *ptid)
607 {
608 	int ret = 0;
609 
610 	write_lock(&journal->j_state_lock);
611 	if (journal->j_running_transaction) {
612 		tid_t tid = journal->j_running_transaction->t_tid;
613 
614 		__jbd2_log_start_commit(journal, tid);
615 		/* There's a running transaction and we've just made sure
616 		 * it's commit has been scheduled. */
617 		if (ptid)
618 			*ptid = tid;
619 		ret = 1;
620 	} else if (journal->j_committing_transaction) {
621 		/*
622 		 * If commit has been started, then we have to wait for
623 		 * completion of that transaction.
624 		 */
625 		if (ptid)
626 			*ptid = journal->j_committing_transaction->t_tid;
627 		ret = 1;
628 	}
629 	write_unlock(&journal->j_state_lock);
630 	return ret;
631 }
632 
633 /*
634  * Return 1 if a given transaction has not yet sent barrier request
635  * connected with a transaction commit. If 0 is returned, transaction
636  * may or may not have sent the barrier. Used to avoid sending barrier
637  * twice in common cases.
638  */
jbd2_trans_will_send_data_barrier(journal_t * journal,tid_t tid)639 int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid)
640 {
641 	int ret = 0;
642 	transaction_t *commit_trans;
643 
644 	if (!(journal->j_flags & JBD2_BARRIER))
645 		return 0;
646 	read_lock(&journal->j_state_lock);
647 	/* Transaction already committed? */
648 	if (tid_geq(journal->j_commit_sequence, tid))
649 		goto out;
650 	commit_trans = journal->j_committing_transaction;
651 	if (!commit_trans || commit_trans->t_tid != tid) {
652 		ret = 1;
653 		goto out;
654 	}
655 	/*
656 	 * Transaction is being committed and we already proceeded to
657 	 * submitting a flush to fs partition?
658 	 */
659 	if (journal->j_fs_dev != journal->j_dev) {
660 		if (!commit_trans->t_need_data_flush ||
661 		    commit_trans->t_state >= T_COMMIT_DFLUSH)
662 			goto out;
663 	} else {
664 		if (commit_trans->t_state >= T_COMMIT_JFLUSH)
665 			goto out;
666 	}
667 	ret = 1;
668 out:
669 	read_unlock(&journal->j_state_lock);
670 	return ret;
671 }
672 EXPORT_SYMBOL(jbd2_trans_will_send_data_barrier);
673 
674 /*
675  * Wait for a specified commit to complete.
676  * The caller may not hold the journal lock.
677  */
jbd2_log_wait_commit(journal_t * journal,tid_t tid)678 int jbd2_log_wait_commit(journal_t *journal, tid_t tid)
679 {
680 	int err = 0;
681 
682 	read_lock(&journal->j_state_lock);
683 #ifdef CONFIG_PROVE_LOCKING
684 	/*
685 	 * Some callers make sure transaction is already committing and in that
686 	 * case we cannot block on open handles anymore. So don't warn in that
687 	 * case.
688 	 */
689 	if (tid_gt(tid, journal->j_commit_sequence) &&
690 	    (!journal->j_committing_transaction ||
691 	     journal->j_committing_transaction->t_tid != tid)) {
692 		read_unlock(&journal->j_state_lock);
693 		jbd2_might_wait_for_commit(journal);
694 		read_lock(&journal->j_state_lock);
695 	}
696 #endif
697 #ifdef CONFIG_JBD2_DEBUG
698 	if (!tid_geq(journal->j_commit_request, tid)) {
699 		printk(KERN_ERR
700 		       "%s: error: j_commit_request=%u, tid=%u\n",
701 		       __func__, journal->j_commit_request, tid);
702 	}
703 #endif
704 	while (tid_gt(tid, journal->j_commit_sequence)) {
705 		jbd2_debug(1, "JBD2: want %u, j_commit_sequence=%u\n",
706 				  tid, journal->j_commit_sequence);
707 		read_unlock(&journal->j_state_lock);
708 		wake_up(&journal->j_wait_commit);
709 		wait_event(journal->j_wait_done_commit,
710 				!tid_gt(tid, journal->j_commit_sequence));
711 		read_lock(&journal->j_state_lock);
712 	}
713 	read_unlock(&journal->j_state_lock);
714 
715 	if (unlikely(is_journal_aborted(journal)))
716 		err = -EIO;
717 	return err;
718 }
719 
720 /*
721  * Start a fast commit. If there's an ongoing fast or full commit wait for
722  * it to complete. Returns 0 if a new fast commit was started. Returns -EALREADY
723  * if a fast commit is not needed, either because there's an already a commit
724  * going on or this tid has already been committed. Returns -EINVAL if no jbd2
725  * commit has yet been performed.
726  */
jbd2_fc_begin_commit(journal_t * journal,tid_t tid)727 int jbd2_fc_begin_commit(journal_t *journal, tid_t tid)
728 {
729 	if (unlikely(is_journal_aborted(journal)))
730 		return -EIO;
731 	/*
732 	 * Fast commits only allowed if at least one full commit has
733 	 * been processed.
734 	 */
735 	if (!journal->j_stats.ts_tid)
736 		return -EINVAL;
737 
738 	write_lock(&journal->j_state_lock);
739 	if (tid <= journal->j_commit_sequence) {
740 		write_unlock(&journal->j_state_lock);
741 		return -EALREADY;
742 	}
743 
744 	if (journal->j_flags & JBD2_FULL_COMMIT_ONGOING ||
745 	    (journal->j_flags & JBD2_FAST_COMMIT_ONGOING)) {
746 		DEFINE_WAIT(wait);
747 
748 		prepare_to_wait(&journal->j_fc_wait, &wait,
749 				TASK_UNINTERRUPTIBLE);
750 		write_unlock(&journal->j_state_lock);
751 		schedule();
752 		finish_wait(&journal->j_fc_wait, &wait);
753 		return -EALREADY;
754 	}
755 	journal->j_flags |= JBD2_FAST_COMMIT_ONGOING;
756 	write_unlock(&journal->j_state_lock);
757 	jbd2_journal_lock_updates(journal);
758 
759 	return 0;
760 }
761 EXPORT_SYMBOL(jbd2_fc_begin_commit);
762 
763 /*
764  * Stop a fast commit. If fallback is set, this function starts commit of
765  * TID tid before any other fast commit can start.
766  */
__jbd2_fc_end_commit(journal_t * journal,tid_t tid,bool fallback)767 static int __jbd2_fc_end_commit(journal_t *journal, tid_t tid, bool fallback)
768 {
769 	jbd2_journal_unlock_updates(journal);
770 	if (journal->j_fc_cleanup_callback)
771 		journal->j_fc_cleanup_callback(journal, 0, tid);
772 	write_lock(&journal->j_state_lock);
773 	journal->j_flags &= ~JBD2_FAST_COMMIT_ONGOING;
774 	if (fallback)
775 		journal->j_flags |= JBD2_FULL_COMMIT_ONGOING;
776 	write_unlock(&journal->j_state_lock);
777 	wake_up(&journal->j_fc_wait);
778 	if (fallback)
779 		return jbd2_complete_transaction(journal, tid);
780 	return 0;
781 }
782 
jbd2_fc_end_commit(journal_t * journal)783 int jbd2_fc_end_commit(journal_t *journal)
784 {
785 	return __jbd2_fc_end_commit(journal, 0, false);
786 }
787 EXPORT_SYMBOL(jbd2_fc_end_commit);
788 
jbd2_fc_end_commit_fallback(journal_t * journal)789 int jbd2_fc_end_commit_fallback(journal_t *journal)
790 {
791 	tid_t tid;
792 
793 	read_lock(&journal->j_state_lock);
794 	tid = journal->j_running_transaction ?
795 		journal->j_running_transaction->t_tid : 0;
796 	read_unlock(&journal->j_state_lock);
797 	return __jbd2_fc_end_commit(journal, tid, true);
798 }
799 EXPORT_SYMBOL(jbd2_fc_end_commit_fallback);
800 
801 /* Return 1 when transaction with given tid has already committed. */
jbd2_transaction_committed(journal_t * journal,tid_t tid)802 int jbd2_transaction_committed(journal_t *journal, tid_t tid)
803 {
804 	int ret = 1;
805 
806 	read_lock(&journal->j_state_lock);
807 	if (journal->j_running_transaction &&
808 	    journal->j_running_transaction->t_tid == tid)
809 		ret = 0;
810 	if (journal->j_committing_transaction &&
811 	    journal->j_committing_transaction->t_tid == tid)
812 		ret = 0;
813 	read_unlock(&journal->j_state_lock);
814 	return ret;
815 }
816 EXPORT_SYMBOL(jbd2_transaction_committed);
817 
818 /*
819  * When this function returns the transaction corresponding to tid
820  * will be completed.  If the transaction has currently running, start
821  * committing that transaction before waiting for it to complete.  If
822  * the transaction id is stale, it is by definition already completed,
823  * so just return SUCCESS.
824  */
jbd2_complete_transaction(journal_t * journal,tid_t tid)825 int jbd2_complete_transaction(journal_t *journal, tid_t tid)
826 {
827 	int	need_to_wait = 1;
828 
829 	read_lock(&journal->j_state_lock);
830 	if (journal->j_running_transaction &&
831 	    journal->j_running_transaction->t_tid == tid) {
832 		if (journal->j_commit_request != tid) {
833 			/* transaction not yet started, so request it */
834 			read_unlock(&journal->j_state_lock);
835 			jbd2_log_start_commit(journal, tid);
836 			goto wait_commit;
837 		}
838 	} else if (!(journal->j_committing_transaction &&
839 		     journal->j_committing_transaction->t_tid == tid))
840 		need_to_wait = 0;
841 	read_unlock(&journal->j_state_lock);
842 	if (!need_to_wait)
843 		return 0;
844 wait_commit:
845 	return jbd2_log_wait_commit(journal, tid);
846 }
847 EXPORT_SYMBOL(jbd2_complete_transaction);
848 
849 /*
850  * Log buffer allocation routines:
851  */
852 
jbd2_journal_next_log_block(journal_t * journal,unsigned long long * retp)853 int jbd2_journal_next_log_block(journal_t *journal, unsigned long long *retp)
854 {
855 	unsigned long blocknr;
856 
857 	write_lock(&journal->j_state_lock);
858 	J_ASSERT(journal->j_free > 1);
859 
860 	blocknr = journal->j_head;
861 	journal->j_head++;
862 	journal->j_free--;
863 	if (journal->j_head == journal->j_last)
864 		journal->j_head = journal->j_first;
865 	write_unlock(&journal->j_state_lock);
866 	return jbd2_journal_bmap(journal, blocknr, retp);
867 }
868 
869 /* Map one fast commit buffer for use by the file system */
jbd2_fc_get_buf(journal_t * journal,struct buffer_head ** bh_out)870 int jbd2_fc_get_buf(journal_t *journal, struct buffer_head **bh_out)
871 {
872 	unsigned long long pblock;
873 	unsigned long blocknr;
874 	int ret = 0;
875 	struct buffer_head *bh;
876 	int fc_off;
877 
878 	*bh_out = NULL;
879 
880 	if (journal->j_fc_off + journal->j_fc_first < journal->j_fc_last) {
881 		fc_off = journal->j_fc_off;
882 		blocknr = journal->j_fc_first + fc_off;
883 		journal->j_fc_off++;
884 	} else {
885 		ret = -EINVAL;
886 	}
887 
888 	if (ret)
889 		return ret;
890 
891 	ret = jbd2_journal_bmap(journal, blocknr, &pblock);
892 	if (ret)
893 		return ret;
894 
895 	bh = __getblk(journal->j_dev, pblock, journal->j_blocksize);
896 	if (!bh)
897 		return -ENOMEM;
898 
899 
900 	journal->j_fc_wbuf[fc_off] = bh;
901 
902 	*bh_out = bh;
903 
904 	return 0;
905 }
906 EXPORT_SYMBOL(jbd2_fc_get_buf);
907 
908 /*
909  * Wait on fast commit buffers that were allocated by jbd2_fc_get_buf
910  * for completion.
911  */
jbd2_fc_wait_bufs(journal_t * journal,int num_blks)912 int jbd2_fc_wait_bufs(journal_t *journal, int num_blks)
913 {
914 	struct buffer_head *bh;
915 	int i, j_fc_off;
916 
917 	j_fc_off = journal->j_fc_off;
918 
919 	/*
920 	 * Wait in reverse order to minimize chances of us being woken up before
921 	 * all IOs have completed
922 	 */
923 	for (i = j_fc_off - 1; i >= j_fc_off - num_blks; i--) {
924 		bh = journal->j_fc_wbuf[i];
925 		wait_on_buffer(bh);
926 		/*
927 		 * Update j_fc_off so jbd2_fc_release_bufs can release remain
928 		 * buffer head.
929 		 */
930 		if (unlikely(!buffer_uptodate(bh))) {
931 			journal->j_fc_off = i + 1;
932 			return -EIO;
933 		}
934 		put_bh(bh);
935 		journal->j_fc_wbuf[i] = NULL;
936 	}
937 
938 	return 0;
939 }
940 EXPORT_SYMBOL(jbd2_fc_wait_bufs);
941 
jbd2_fc_release_bufs(journal_t * journal)942 int jbd2_fc_release_bufs(journal_t *journal)
943 {
944 	struct buffer_head *bh;
945 	int i, j_fc_off;
946 
947 	j_fc_off = journal->j_fc_off;
948 
949 	for (i = j_fc_off - 1; i >= 0; i--) {
950 		bh = journal->j_fc_wbuf[i];
951 		if (!bh)
952 			break;
953 		put_bh(bh);
954 		journal->j_fc_wbuf[i] = NULL;
955 	}
956 
957 	return 0;
958 }
959 EXPORT_SYMBOL(jbd2_fc_release_bufs);
960 
961 /*
962  * Conversion of logical to physical block numbers for the journal
963  *
964  * On external journals the journal blocks are identity-mapped, so
965  * this is a no-op.  If needed, we can use j_blk_offset - everything is
966  * ready.
967  */
jbd2_journal_bmap(journal_t * journal,unsigned long blocknr,unsigned long long * retp)968 int jbd2_journal_bmap(journal_t *journal, unsigned long blocknr,
969 		 unsigned long long *retp)
970 {
971 	int err = 0;
972 	unsigned long long ret;
973 	sector_t block = 0;
974 
975 	if (journal->j_inode) {
976 		block = blocknr;
977 		ret = bmap(journal->j_inode, &block);
978 
979 		if (ret || !block) {
980 			printk(KERN_ALERT "%s: journal block not found "
981 					"at offset %lu on %s\n",
982 			       __func__, blocknr, journal->j_devname);
983 			err = -EIO;
984 			jbd2_journal_abort(journal, err);
985 		} else {
986 			*retp = block;
987 		}
988 
989 	} else {
990 		*retp = blocknr; /* +journal->j_blk_offset */
991 	}
992 	return err;
993 }
994 
995 /*
996  * We play buffer_head aliasing tricks to write data/metadata blocks to
997  * the journal without copying their contents, but for journal
998  * descriptor blocks we do need to generate bona fide buffers.
999  *
1000  * After the caller of jbd2_journal_get_descriptor_buffer() has finished modifying
1001  * the buffer's contents they really should run flush_dcache_page(bh->b_page).
1002  * But we don't bother doing that, so there will be coherency problems with
1003  * mmaps of blockdevs which hold live JBD-controlled filesystems.
1004  */
1005 struct buffer_head *
jbd2_journal_get_descriptor_buffer(transaction_t * transaction,int type)1006 jbd2_journal_get_descriptor_buffer(transaction_t *transaction, int type)
1007 {
1008 	journal_t *journal = transaction->t_journal;
1009 	struct buffer_head *bh;
1010 	unsigned long long blocknr;
1011 	journal_header_t *header;
1012 	int err;
1013 
1014 	err = jbd2_journal_next_log_block(journal, &blocknr);
1015 
1016 	if (err)
1017 		return NULL;
1018 
1019 	bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
1020 	if (!bh)
1021 		return NULL;
1022 	atomic_dec(&transaction->t_outstanding_credits);
1023 	lock_buffer(bh);
1024 	memset(bh->b_data, 0, journal->j_blocksize);
1025 	header = (journal_header_t *)bh->b_data;
1026 	header->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER);
1027 	header->h_blocktype = cpu_to_be32(type);
1028 	header->h_sequence = cpu_to_be32(transaction->t_tid);
1029 	set_buffer_uptodate(bh);
1030 	unlock_buffer(bh);
1031 	BUFFER_TRACE(bh, "return this buffer");
1032 	return bh;
1033 }
1034 
jbd2_descriptor_block_csum_set(journal_t * j,struct buffer_head * bh)1035 void jbd2_descriptor_block_csum_set(journal_t *j, struct buffer_head *bh)
1036 {
1037 	struct jbd2_journal_block_tail *tail;
1038 	__u32 csum;
1039 
1040 	if (!jbd2_journal_has_csum_v2or3(j))
1041 		return;
1042 
1043 	tail = (struct jbd2_journal_block_tail *)(bh->b_data + j->j_blocksize -
1044 			sizeof(struct jbd2_journal_block_tail));
1045 	tail->t_checksum = 0;
1046 	csum = jbd2_chksum(j, j->j_csum_seed, bh->b_data, j->j_blocksize);
1047 	tail->t_checksum = cpu_to_be32(csum);
1048 }
1049 
1050 /*
1051  * Return tid of the oldest transaction in the journal and block in the journal
1052  * where the transaction starts.
1053  *
1054  * If the journal is now empty, return which will be the next transaction ID
1055  * we will write and where will that transaction start.
1056  *
1057  * The return value is 0 if journal tail cannot be pushed any further, 1 if
1058  * it can.
1059  */
jbd2_journal_get_log_tail(journal_t * journal,tid_t * tid,unsigned long * block)1060 int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
1061 			      unsigned long *block)
1062 {
1063 	transaction_t *transaction;
1064 	int ret;
1065 
1066 	read_lock(&journal->j_state_lock);
1067 	spin_lock(&journal->j_list_lock);
1068 	transaction = journal->j_checkpoint_transactions;
1069 	if (transaction) {
1070 		*tid = transaction->t_tid;
1071 		*block = transaction->t_log_start;
1072 	} else if ((transaction = journal->j_committing_transaction) != NULL) {
1073 		*tid = transaction->t_tid;
1074 		*block = transaction->t_log_start;
1075 	} else if ((transaction = journal->j_running_transaction) != NULL) {
1076 		*tid = transaction->t_tid;
1077 		*block = journal->j_head;
1078 	} else {
1079 		*tid = journal->j_transaction_sequence;
1080 		*block = journal->j_head;
1081 	}
1082 	ret = tid_gt(*tid, journal->j_tail_sequence);
1083 	spin_unlock(&journal->j_list_lock);
1084 	read_unlock(&journal->j_state_lock);
1085 
1086 	return ret;
1087 }
1088 
1089 /*
1090  * Update information in journal structure and in on disk journal superblock
1091  * about log tail. This function does not check whether information passed in
1092  * really pushes log tail further. It's responsibility of the caller to make
1093  * sure provided log tail information is valid (e.g. by holding
1094  * j_checkpoint_mutex all the time between computing log tail and calling this
1095  * function as is the case with jbd2_cleanup_journal_tail()).
1096  *
1097  * Requires j_checkpoint_mutex
1098  */
__jbd2_update_log_tail(journal_t * journal,tid_t tid,unsigned long block)1099 int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block)
1100 {
1101 	unsigned long freed;
1102 	int ret;
1103 
1104 	BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
1105 
1106 	/*
1107 	 * We cannot afford for write to remain in drive's caches since as
1108 	 * soon as we update j_tail, next transaction can start reusing journal
1109 	 * space and if we lose sb update during power failure we'd replay
1110 	 * old transaction with possibly newly overwritten data.
1111 	 */
1112 	ret = jbd2_journal_update_sb_log_tail(journal, tid, block,
1113 					      REQ_SYNC | REQ_FUA);
1114 	if (ret)
1115 		goto out;
1116 
1117 	write_lock(&journal->j_state_lock);
1118 	freed = block - journal->j_tail;
1119 	if (block < journal->j_tail)
1120 		freed += journal->j_last - journal->j_first;
1121 
1122 	trace_jbd2_update_log_tail(journal, tid, block, freed);
1123 	jbd2_debug(1,
1124 		  "Cleaning journal tail from %u to %u (offset %lu), "
1125 		  "freeing %lu\n",
1126 		  journal->j_tail_sequence, tid, block, freed);
1127 
1128 	journal->j_free += freed;
1129 	journal->j_tail_sequence = tid;
1130 	journal->j_tail = block;
1131 	write_unlock(&journal->j_state_lock);
1132 
1133 out:
1134 	return ret;
1135 }
1136 
1137 /*
1138  * This is a variation of __jbd2_update_log_tail which checks for validity of
1139  * provided log tail and locks j_checkpoint_mutex. So it is safe against races
1140  * with other threads updating log tail.
1141  */
jbd2_update_log_tail(journal_t * journal,tid_t tid,unsigned long block)1142 void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block)
1143 {
1144 	mutex_lock_io(&journal->j_checkpoint_mutex);
1145 	if (tid_gt(tid, journal->j_tail_sequence))
1146 		__jbd2_update_log_tail(journal, tid, block);
1147 	mutex_unlock(&journal->j_checkpoint_mutex);
1148 }
1149 
1150 struct jbd2_stats_proc_session {
1151 	journal_t *journal;
1152 	struct transaction_stats_s *stats;
1153 	int start;
1154 	int max;
1155 };
1156 
jbd2_seq_info_start(struct seq_file * seq,loff_t * pos)1157 static void *jbd2_seq_info_start(struct seq_file *seq, loff_t *pos)
1158 {
1159 	return *pos ? NULL : SEQ_START_TOKEN;
1160 }
1161 
jbd2_seq_info_next(struct seq_file * seq,void * v,loff_t * pos)1162 static void *jbd2_seq_info_next(struct seq_file *seq, void *v, loff_t *pos)
1163 {
1164 	(*pos)++;
1165 	return NULL;
1166 }
1167 
jbd2_seq_info_show(struct seq_file * seq,void * v)1168 static int jbd2_seq_info_show(struct seq_file *seq, void *v)
1169 {
1170 	struct jbd2_stats_proc_session *s = seq->private;
1171 
1172 	if (v != SEQ_START_TOKEN)
1173 		return 0;
1174 	seq_printf(seq, "%lu transactions (%lu requested), "
1175 		   "each up to %u blocks\n",
1176 		   s->stats->ts_tid, s->stats->ts_requested,
1177 		   s->journal->j_max_transaction_buffers);
1178 	if (s->stats->ts_tid == 0)
1179 		return 0;
1180 	seq_printf(seq, "average: \n  %ums waiting for transaction\n",
1181 	    jiffies_to_msecs(s->stats->run.rs_wait / s->stats->ts_tid));
1182 	seq_printf(seq, "  %ums request delay\n",
1183 	    (s->stats->ts_requested == 0) ? 0 :
1184 	    jiffies_to_msecs(s->stats->run.rs_request_delay /
1185 			     s->stats->ts_requested));
1186 	seq_printf(seq, "  %ums running transaction\n",
1187 	    jiffies_to_msecs(s->stats->run.rs_running / s->stats->ts_tid));
1188 	seq_printf(seq, "  %ums transaction was being locked\n",
1189 	    jiffies_to_msecs(s->stats->run.rs_locked / s->stats->ts_tid));
1190 	seq_printf(seq, "  %ums flushing data (in ordered mode)\n",
1191 	    jiffies_to_msecs(s->stats->run.rs_flushing / s->stats->ts_tid));
1192 	seq_printf(seq, "  %ums logging transaction\n",
1193 	    jiffies_to_msecs(s->stats->run.rs_logging / s->stats->ts_tid));
1194 	seq_printf(seq, "  %lluus average transaction commit time\n",
1195 		   div_u64(s->journal->j_average_commit_time, 1000));
1196 	seq_printf(seq, "  %lu handles per transaction\n",
1197 	    s->stats->run.rs_handle_count / s->stats->ts_tid);
1198 	seq_printf(seq, "  %lu blocks per transaction\n",
1199 	    s->stats->run.rs_blocks / s->stats->ts_tid);
1200 	seq_printf(seq, "  %lu logged blocks per transaction\n",
1201 	    s->stats->run.rs_blocks_logged / s->stats->ts_tid);
1202 	return 0;
1203 }
1204 
jbd2_seq_info_stop(struct seq_file * seq,void * v)1205 static void jbd2_seq_info_stop(struct seq_file *seq, void *v)
1206 {
1207 }
1208 
1209 static const struct seq_operations jbd2_seq_info_ops = {
1210 	.start  = jbd2_seq_info_start,
1211 	.next   = jbd2_seq_info_next,
1212 	.stop   = jbd2_seq_info_stop,
1213 	.show   = jbd2_seq_info_show,
1214 };
1215 
jbd2_seq_info_open(struct inode * inode,struct file * file)1216 static int jbd2_seq_info_open(struct inode *inode, struct file *file)
1217 {
1218 	journal_t *journal = pde_data(inode);
1219 	struct jbd2_stats_proc_session *s;
1220 	int rc, size;
1221 
1222 	s = kmalloc(sizeof(*s), GFP_KERNEL);
1223 	if (s == NULL)
1224 		return -ENOMEM;
1225 	size = sizeof(struct transaction_stats_s);
1226 	s->stats = kmalloc(size, GFP_KERNEL);
1227 	if (s->stats == NULL) {
1228 		kfree(s);
1229 		return -ENOMEM;
1230 	}
1231 	spin_lock(&journal->j_history_lock);
1232 	memcpy(s->stats, &journal->j_stats, size);
1233 	s->journal = journal;
1234 	spin_unlock(&journal->j_history_lock);
1235 
1236 	rc = seq_open(file, &jbd2_seq_info_ops);
1237 	if (rc == 0) {
1238 		struct seq_file *m = file->private_data;
1239 		m->private = s;
1240 	} else {
1241 		kfree(s->stats);
1242 		kfree(s);
1243 	}
1244 	return rc;
1245 
1246 }
1247 
jbd2_seq_info_release(struct inode * inode,struct file * file)1248 static int jbd2_seq_info_release(struct inode *inode, struct file *file)
1249 {
1250 	struct seq_file *seq = file->private_data;
1251 	struct jbd2_stats_proc_session *s = seq->private;
1252 	kfree(s->stats);
1253 	kfree(s);
1254 	return seq_release(inode, file);
1255 }
1256 
1257 static const struct proc_ops jbd2_info_proc_ops = {
1258 	.proc_open	= jbd2_seq_info_open,
1259 	.proc_read	= seq_read,
1260 	.proc_lseek	= seq_lseek,
1261 	.proc_release	= jbd2_seq_info_release,
1262 };
1263 
1264 static struct proc_dir_entry *proc_jbd2_stats;
1265 
jbd2_stats_proc_init(journal_t * journal)1266 static void jbd2_stats_proc_init(journal_t *journal)
1267 {
1268 	journal->j_proc_entry = proc_mkdir(journal->j_devname, proc_jbd2_stats);
1269 	if (journal->j_proc_entry) {
1270 		proc_create_data("info", S_IRUGO, journal->j_proc_entry,
1271 				 &jbd2_info_proc_ops, journal);
1272 	}
1273 }
1274 
jbd2_stats_proc_exit(journal_t * journal)1275 static void jbd2_stats_proc_exit(journal_t *journal)
1276 {
1277 	remove_proc_entry("info", journal->j_proc_entry);
1278 	remove_proc_entry(journal->j_devname, proc_jbd2_stats);
1279 }
1280 
1281 /* Minimum size of descriptor tag */
jbd2_min_tag_size(void)1282 static int jbd2_min_tag_size(void)
1283 {
1284 	/*
1285 	 * Tag with 32-bit block numbers does not use last four bytes of the
1286 	 * structure
1287 	 */
1288 	return sizeof(journal_block_tag_t) - 4;
1289 }
1290 
1291 /**
1292  * jbd2_journal_shrink_scan()
1293  * @shrink: shrinker to work on
1294  * @sc: reclaim request to process
1295  *
1296  * Scan the checkpointed buffer on the checkpoint list and release the
1297  * journal_head.
1298  */
jbd2_journal_shrink_scan(struct shrinker * shrink,struct shrink_control * sc)1299 static unsigned long jbd2_journal_shrink_scan(struct shrinker *shrink,
1300 					      struct shrink_control *sc)
1301 {
1302 	journal_t *journal = container_of(shrink, journal_t, j_shrinker);
1303 	unsigned long nr_to_scan = sc->nr_to_scan;
1304 	unsigned long nr_shrunk;
1305 	unsigned long count;
1306 
1307 	count = percpu_counter_read_positive(&journal->j_checkpoint_jh_count);
1308 	trace_jbd2_shrink_scan_enter(journal, sc->nr_to_scan, count);
1309 
1310 	nr_shrunk = jbd2_journal_shrink_checkpoint_list(journal, &nr_to_scan);
1311 
1312 	count = percpu_counter_read_positive(&journal->j_checkpoint_jh_count);
1313 	trace_jbd2_shrink_scan_exit(journal, nr_to_scan, nr_shrunk, count);
1314 
1315 	return nr_shrunk;
1316 }
1317 
1318 /**
1319  * jbd2_journal_shrink_count()
1320  * @shrink: shrinker to work on
1321  * @sc: reclaim request to process
1322  *
1323  * Count the number of checkpoint buffers on the checkpoint list.
1324  */
jbd2_journal_shrink_count(struct shrinker * shrink,struct shrink_control * sc)1325 static unsigned long jbd2_journal_shrink_count(struct shrinker *shrink,
1326 					       struct shrink_control *sc)
1327 {
1328 	journal_t *journal = container_of(shrink, journal_t, j_shrinker);
1329 	unsigned long count;
1330 
1331 	count = percpu_counter_read_positive(&journal->j_checkpoint_jh_count);
1332 	trace_jbd2_shrink_count(journal, sc->nr_to_scan, count);
1333 
1334 	return count;
1335 }
1336 
1337 /*
1338  * Management for journal control blocks: functions to create and
1339  * destroy journal_t structures, and to initialise and read existing
1340  * journal blocks from disk.  */
1341 
1342 /* First: create and setup a journal_t object in memory.  We initialise
1343  * very few fields yet: that has to wait until we have created the
1344  * journal structures from from scratch, or loaded them from disk. */
1345 
journal_init_common(struct block_device * bdev,struct block_device * fs_dev,unsigned long long start,int len,int blocksize)1346 static journal_t *journal_init_common(struct block_device *bdev,
1347 			struct block_device *fs_dev,
1348 			unsigned long long start, int len, int blocksize)
1349 {
1350 	static struct lock_class_key jbd2_trans_commit_key;
1351 	journal_t *journal;
1352 	int err;
1353 	struct buffer_head *bh;
1354 	int n;
1355 
1356 	journal = kzalloc(sizeof(*journal), GFP_KERNEL);
1357 	if (!journal)
1358 		return NULL;
1359 
1360 	init_waitqueue_head(&journal->j_wait_transaction_locked);
1361 	init_waitqueue_head(&journal->j_wait_done_commit);
1362 	init_waitqueue_head(&journal->j_wait_commit);
1363 	init_waitqueue_head(&journal->j_wait_updates);
1364 	init_waitqueue_head(&journal->j_wait_reserved);
1365 	init_waitqueue_head(&journal->j_fc_wait);
1366 	mutex_init(&journal->j_abort_mutex);
1367 	mutex_init(&journal->j_barrier);
1368 	mutex_init(&journal->j_checkpoint_mutex);
1369 	spin_lock_init(&journal->j_revoke_lock);
1370 	spin_lock_init(&journal->j_list_lock);
1371 	rwlock_init(&journal->j_state_lock);
1372 
1373 	journal->j_commit_interval = (HZ * JBD2_DEFAULT_MAX_COMMIT_AGE);
1374 	journal->j_min_batch_time = 0;
1375 	journal->j_max_batch_time = 15000; /* 15ms */
1376 	atomic_set(&journal->j_reserved_credits, 0);
1377 
1378 	/* The journal is marked for error until we succeed with recovery! */
1379 	journal->j_flags = JBD2_ABORT;
1380 
1381 	/* Set up a default-sized revoke table for the new mount. */
1382 	err = jbd2_journal_init_revoke(journal, JOURNAL_REVOKE_DEFAULT_HASH);
1383 	if (err)
1384 		goto err_cleanup;
1385 
1386 	spin_lock_init(&journal->j_history_lock);
1387 
1388 	lockdep_init_map(&journal->j_trans_commit_map, "jbd2_handle",
1389 			 &jbd2_trans_commit_key, 0);
1390 
1391 	/* journal descriptor can store up to n blocks -bzzz */
1392 	journal->j_blocksize = blocksize;
1393 	journal->j_dev = bdev;
1394 	journal->j_fs_dev = fs_dev;
1395 	journal->j_blk_offset = start;
1396 	journal->j_total_len = len;
1397 	/* We need enough buffers to write out full descriptor block. */
1398 	n = journal->j_blocksize / jbd2_min_tag_size();
1399 	journal->j_wbufsize = n;
1400 	journal->j_fc_wbuf = NULL;
1401 	journal->j_wbuf = kmalloc_array(n, sizeof(struct buffer_head *),
1402 					GFP_KERNEL);
1403 	if (!journal->j_wbuf)
1404 		goto err_cleanup;
1405 
1406 	bh = getblk_unmovable(journal->j_dev, start, journal->j_blocksize);
1407 	if (!bh) {
1408 		pr_err("%s: Cannot get buffer for journal superblock\n",
1409 			__func__);
1410 		goto err_cleanup;
1411 	}
1412 	journal->j_sb_buffer = bh;
1413 	journal->j_superblock = (journal_superblock_t *)bh->b_data;
1414 
1415 	journal->j_shrink_transaction = NULL;
1416 	journal->j_shrinker.scan_objects = jbd2_journal_shrink_scan;
1417 	journal->j_shrinker.count_objects = jbd2_journal_shrink_count;
1418 	journal->j_shrinker.seeks = DEFAULT_SEEKS;
1419 	journal->j_shrinker.batch = journal->j_max_transaction_buffers;
1420 
1421 	if (percpu_counter_init(&journal->j_checkpoint_jh_count, 0, GFP_KERNEL))
1422 		goto err_cleanup;
1423 
1424 	if (register_shrinker(&journal->j_shrinker, "jbd2-journal:(%u:%u)",
1425 			      MAJOR(bdev->bd_dev), MINOR(bdev->bd_dev))) {
1426 		percpu_counter_destroy(&journal->j_checkpoint_jh_count);
1427 		goto err_cleanup;
1428 	}
1429 	return journal;
1430 
1431 err_cleanup:
1432 	brelse(journal->j_sb_buffer);
1433 	kfree(journal->j_wbuf);
1434 	jbd2_journal_destroy_revoke(journal);
1435 	kfree(journal);
1436 	return NULL;
1437 }
1438 
1439 /* jbd2_journal_init_dev and jbd2_journal_init_inode:
1440  *
1441  * Create a journal structure assigned some fixed set of disk blocks to
1442  * the journal.  We don't actually touch those disk blocks yet, but we
1443  * need to set up all of the mapping information to tell the journaling
1444  * system where the journal blocks are.
1445  *
1446  */
1447 
1448 /**
1449  *  journal_t * jbd2_journal_init_dev() - creates and initialises a journal structure
1450  *  @bdev: Block device on which to create the journal
1451  *  @fs_dev: Device which hold journalled filesystem for this journal.
1452  *  @start: Block nr Start of journal.
1453  *  @len:  Length of the journal in blocks.
1454  *  @blocksize: blocksize of journalling device
1455  *
1456  *  Returns: a newly created journal_t *
1457  *
1458  *  jbd2_journal_init_dev creates a journal which maps a fixed contiguous
1459  *  range of blocks on an arbitrary block device.
1460  *
1461  */
jbd2_journal_init_dev(struct block_device * bdev,struct block_device * fs_dev,unsigned long long start,int len,int blocksize)1462 journal_t *jbd2_journal_init_dev(struct block_device *bdev,
1463 			struct block_device *fs_dev,
1464 			unsigned long long start, int len, int blocksize)
1465 {
1466 	journal_t *journal;
1467 
1468 	journal = journal_init_common(bdev, fs_dev, start, len, blocksize);
1469 	if (!journal)
1470 		return NULL;
1471 
1472 	snprintf(journal->j_devname, sizeof(journal->j_devname),
1473 		 "%pg", journal->j_dev);
1474 	strreplace(journal->j_devname, '/', '!');
1475 	jbd2_stats_proc_init(journal);
1476 
1477 	return journal;
1478 }
1479 
1480 /**
1481  *  journal_t * jbd2_journal_init_inode () - creates a journal which maps to a inode.
1482  *  @inode: An inode to create the journal in
1483  *
1484  * jbd2_journal_init_inode creates a journal which maps an on-disk inode as
1485  * the journal.  The inode must exist already, must support bmap() and
1486  * must have all data blocks preallocated.
1487  */
jbd2_journal_init_inode(struct inode * inode)1488 journal_t *jbd2_journal_init_inode(struct inode *inode)
1489 {
1490 	journal_t *journal;
1491 	sector_t blocknr;
1492 	char *p;
1493 	int err = 0;
1494 
1495 	blocknr = 0;
1496 	err = bmap(inode, &blocknr);
1497 
1498 	if (err || !blocknr) {
1499 		pr_err("%s: Cannot locate journal superblock\n",
1500 			__func__);
1501 		return NULL;
1502 	}
1503 
1504 	jbd2_debug(1, "JBD2: inode %s/%ld, size %lld, bits %d, blksize %ld\n",
1505 		  inode->i_sb->s_id, inode->i_ino, (long long) inode->i_size,
1506 		  inode->i_sb->s_blocksize_bits, inode->i_sb->s_blocksize);
1507 
1508 	journal = journal_init_common(inode->i_sb->s_bdev, inode->i_sb->s_bdev,
1509 			blocknr, inode->i_size >> inode->i_sb->s_blocksize_bits,
1510 			inode->i_sb->s_blocksize);
1511 	if (!journal)
1512 		return NULL;
1513 
1514 	journal->j_inode = inode;
1515 	snprintf(journal->j_devname, sizeof(journal->j_devname),
1516 		 "%pg", journal->j_dev);
1517 	p = strreplace(journal->j_devname, '/', '!');
1518 	sprintf(p, "-%lu", journal->j_inode->i_ino);
1519 	jbd2_stats_proc_init(journal);
1520 
1521 	return journal;
1522 }
1523 
1524 /*
1525  * If the journal init or create aborts, we need to mark the journal
1526  * superblock as being NULL to prevent the journal destroy from writing
1527  * back a bogus superblock.
1528  */
journal_fail_superblock(journal_t * journal)1529 static void journal_fail_superblock(journal_t *journal)
1530 {
1531 	struct buffer_head *bh = journal->j_sb_buffer;
1532 	brelse(bh);
1533 	journal->j_sb_buffer = NULL;
1534 }
1535 
1536 /*
1537  * Given a journal_t structure, initialise the various fields for
1538  * startup of a new journaling session.  We use this both when creating
1539  * a journal, and after recovering an old journal to reset it for
1540  * subsequent use.
1541  */
1542 
journal_reset(journal_t * journal)1543 static int journal_reset(journal_t *journal)
1544 {
1545 	journal_superblock_t *sb = journal->j_superblock;
1546 	unsigned long long first, last;
1547 
1548 	first = be32_to_cpu(sb->s_first);
1549 	last = be32_to_cpu(sb->s_maxlen);
1550 	if (first + JBD2_MIN_JOURNAL_BLOCKS > last + 1) {
1551 		printk(KERN_ERR "JBD2: Journal too short (blocks %llu-%llu).\n",
1552 		       first, last);
1553 		journal_fail_superblock(journal);
1554 		return -EINVAL;
1555 	}
1556 
1557 	journal->j_first = first;
1558 	journal->j_last = last;
1559 
1560 	journal->j_head = journal->j_first;
1561 	journal->j_tail = journal->j_first;
1562 	journal->j_free = journal->j_last - journal->j_first;
1563 
1564 	journal->j_tail_sequence = journal->j_transaction_sequence;
1565 	journal->j_commit_sequence = journal->j_transaction_sequence - 1;
1566 	journal->j_commit_request = journal->j_commit_sequence;
1567 
1568 	journal->j_max_transaction_buffers = jbd2_journal_get_max_txn_bufs(journal);
1569 
1570 	/*
1571 	 * Now that journal recovery is done, turn fast commits off here. This
1572 	 * way, if fast commit was enabled before the crash but if now FS has
1573 	 * disabled it, we don't enable fast commits.
1574 	 */
1575 	jbd2_clear_feature_fast_commit(journal);
1576 
1577 	/*
1578 	 * As a special case, if the on-disk copy is already marked as needing
1579 	 * no recovery (s_start == 0), then we can safely defer the superblock
1580 	 * update until the next commit by setting JBD2_FLUSHED.  This avoids
1581 	 * attempting a write to a potential-readonly device.
1582 	 */
1583 	if (sb->s_start == 0) {
1584 		jbd2_debug(1, "JBD2: Skipping superblock update on recovered sb "
1585 			"(start %ld, seq %u, errno %d)\n",
1586 			journal->j_tail, journal->j_tail_sequence,
1587 			journal->j_errno);
1588 		journal->j_flags |= JBD2_FLUSHED;
1589 	} else {
1590 		/* Lock here to make assertions happy... */
1591 		mutex_lock_io(&journal->j_checkpoint_mutex);
1592 		/*
1593 		 * Update log tail information. We use REQ_FUA since new
1594 		 * transaction will start reusing journal space and so we
1595 		 * must make sure information about current log tail is on
1596 		 * disk before that.
1597 		 */
1598 		jbd2_journal_update_sb_log_tail(journal,
1599 						journal->j_tail_sequence,
1600 						journal->j_tail,
1601 						REQ_SYNC | REQ_FUA);
1602 		mutex_unlock(&journal->j_checkpoint_mutex);
1603 	}
1604 	return jbd2_journal_start_thread(journal);
1605 }
1606 
1607 /*
1608  * This function expects that the caller will have locked the journal
1609  * buffer head, and will return with it unlocked
1610  */
jbd2_write_superblock(journal_t * journal,blk_opf_t write_flags)1611 static int jbd2_write_superblock(journal_t *journal, blk_opf_t write_flags)
1612 {
1613 	struct buffer_head *bh = journal->j_sb_buffer;
1614 	journal_superblock_t *sb = journal->j_superblock;
1615 	int ret = 0;
1616 
1617 	/* Buffer got discarded which means block device got invalidated */
1618 	if (!buffer_mapped(bh)) {
1619 		unlock_buffer(bh);
1620 		return -EIO;
1621 	}
1622 
1623 	trace_jbd2_write_superblock(journal, write_flags);
1624 	if (!(journal->j_flags & JBD2_BARRIER))
1625 		write_flags &= ~(REQ_FUA | REQ_PREFLUSH);
1626 	if (buffer_write_io_error(bh)) {
1627 		/*
1628 		 * Oh, dear.  A previous attempt to write the journal
1629 		 * superblock failed.  This could happen because the
1630 		 * USB device was yanked out.  Or it could happen to
1631 		 * be a transient write error and maybe the block will
1632 		 * be remapped.  Nothing we can do but to retry the
1633 		 * write and hope for the best.
1634 		 */
1635 		printk(KERN_ERR "JBD2: previous I/O error detected "
1636 		       "for journal superblock update for %s.\n",
1637 		       journal->j_devname);
1638 		clear_buffer_write_io_error(bh);
1639 		set_buffer_uptodate(bh);
1640 	}
1641 	if (jbd2_journal_has_csum_v2or3(journal))
1642 		sb->s_checksum = jbd2_superblock_csum(journal, sb);
1643 	get_bh(bh);
1644 	bh->b_end_io = end_buffer_write_sync;
1645 	submit_bh(REQ_OP_WRITE | write_flags, bh);
1646 	wait_on_buffer(bh);
1647 	if (buffer_write_io_error(bh)) {
1648 		clear_buffer_write_io_error(bh);
1649 		set_buffer_uptodate(bh);
1650 		ret = -EIO;
1651 	}
1652 	if (ret) {
1653 		printk(KERN_ERR "JBD2: I/O error when updating journal superblock for %s.\n",
1654 				journal->j_devname);
1655 		if (!is_journal_aborted(journal))
1656 			jbd2_journal_abort(journal, ret);
1657 	}
1658 
1659 	return ret;
1660 }
1661 
1662 /**
1663  * jbd2_journal_update_sb_log_tail() - Update log tail in journal sb on disk.
1664  * @journal: The journal to update.
1665  * @tail_tid: TID of the new transaction at the tail of the log
1666  * @tail_block: The first block of the transaction at the tail of the log
1667  * @write_flags: Flags for the journal sb write operation
1668  *
1669  * Update a journal's superblock information about log tail and write it to
1670  * disk, waiting for the IO to complete.
1671  */
jbd2_journal_update_sb_log_tail(journal_t * journal,tid_t tail_tid,unsigned long tail_block,blk_opf_t write_flags)1672 int jbd2_journal_update_sb_log_tail(journal_t *journal, tid_t tail_tid,
1673 				    unsigned long tail_block,
1674 				    blk_opf_t write_flags)
1675 {
1676 	journal_superblock_t *sb = journal->j_superblock;
1677 	int ret;
1678 
1679 	if (is_journal_aborted(journal))
1680 		return -EIO;
1681 	if (test_bit(JBD2_CHECKPOINT_IO_ERROR, &journal->j_atomic_flags)) {
1682 		jbd2_journal_abort(journal, -EIO);
1683 		return -EIO;
1684 	}
1685 
1686 	BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
1687 	jbd2_debug(1, "JBD2: updating superblock (start %lu, seq %u)\n",
1688 		  tail_block, tail_tid);
1689 
1690 	lock_buffer(journal->j_sb_buffer);
1691 	sb->s_sequence = cpu_to_be32(tail_tid);
1692 	sb->s_start    = cpu_to_be32(tail_block);
1693 
1694 	ret = jbd2_write_superblock(journal, write_flags);
1695 	if (ret)
1696 		goto out;
1697 
1698 	/* Log is no longer empty */
1699 	write_lock(&journal->j_state_lock);
1700 	WARN_ON(!sb->s_sequence);
1701 	journal->j_flags &= ~JBD2_FLUSHED;
1702 	write_unlock(&journal->j_state_lock);
1703 
1704 out:
1705 	return ret;
1706 }
1707 
1708 /**
1709  * jbd2_mark_journal_empty() - Mark on disk journal as empty.
1710  * @journal: The journal to update.
1711  * @write_flags: Flags for the journal sb write operation
1712  *
1713  * Update a journal's dynamic superblock fields to show that journal is empty.
1714  * Write updated superblock to disk waiting for IO to complete.
1715  */
jbd2_mark_journal_empty(journal_t * journal,blk_opf_t write_flags)1716 static void jbd2_mark_journal_empty(journal_t *journal, blk_opf_t write_flags)
1717 {
1718 	journal_superblock_t *sb = journal->j_superblock;
1719 	bool had_fast_commit = false;
1720 
1721 	BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
1722 	lock_buffer(journal->j_sb_buffer);
1723 	if (sb->s_start == 0) {		/* Is it already empty? */
1724 		unlock_buffer(journal->j_sb_buffer);
1725 		return;
1726 	}
1727 
1728 	jbd2_debug(1, "JBD2: Marking journal as empty (seq %u)\n",
1729 		  journal->j_tail_sequence);
1730 
1731 	sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);
1732 	sb->s_start    = cpu_to_be32(0);
1733 	if (jbd2_has_feature_fast_commit(journal)) {
1734 		/*
1735 		 * When journal is clean, no need to commit fast commit flag and
1736 		 * make file system incompatible with older kernels.
1737 		 */
1738 		jbd2_clear_feature_fast_commit(journal);
1739 		had_fast_commit = true;
1740 	}
1741 
1742 	jbd2_write_superblock(journal, write_flags);
1743 
1744 	if (had_fast_commit)
1745 		jbd2_set_feature_fast_commit(journal);
1746 
1747 	/* Log is no longer empty */
1748 	write_lock(&journal->j_state_lock);
1749 	journal->j_flags |= JBD2_FLUSHED;
1750 	write_unlock(&journal->j_state_lock);
1751 }
1752 
1753 /**
1754  * __jbd2_journal_erase() - Discard or zeroout journal blocks (excluding superblock)
1755  * @journal: The journal to erase.
1756  * @flags: A discard/zeroout request is sent for each physically contigous
1757  *	region of the journal. Either JBD2_JOURNAL_FLUSH_DISCARD or
1758  *	JBD2_JOURNAL_FLUSH_ZEROOUT must be set to determine which operation
1759  *	to perform.
1760  *
1761  * Note: JBD2_JOURNAL_FLUSH_ZEROOUT attempts to use hardware offload. Zeroes
1762  * will be explicitly written if no hardware offload is available, see
1763  * blkdev_issue_zeroout for more details.
1764  */
__jbd2_journal_erase(journal_t * journal,unsigned int flags)1765 static int __jbd2_journal_erase(journal_t *journal, unsigned int flags)
1766 {
1767 	int err = 0;
1768 	unsigned long block, log_offset; /* logical */
1769 	unsigned long long phys_block, block_start, block_stop; /* physical */
1770 	loff_t byte_start, byte_stop, byte_count;
1771 
1772 	/* flags must be set to either discard or zeroout */
1773 	if ((flags & ~JBD2_JOURNAL_FLUSH_VALID) || !flags ||
1774 			((flags & JBD2_JOURNAL_FLUSH_DISCARD) &&
1775 			(flags & JBD2_JOURNAL_FLUSH_ZEROOUT)))
1776 		return -EINVAL;
1777 
1778 	if ((flags & JBD2_JOURNAL_FLUSH_DISCARD) &&
1779 	    !bdev_max_discard_sectors(journal->j_dev))
1780 		return -EOPNOTSUPP;
1781 
1782 	/*
1783 	 * lookup block mapping and issue discard/zeroout for each
1784 	 * contiguous region
1785 	 */
1786 	log_offset = be32_to_cpu(journal->j_superblock->s_first);
1787 	block_start =  ~0ULL;
1788 	for (block = log_offset; block < journal->j_total_len; block++) {
1789 		err = jbd2_journal_bmap(journal, block, &phys_block);
1790 		if (err) {
1791 			pr_err("JBD2: bad block at offset %lu", block);
1792 			return err;
1793 		}
1794 
1795 		if (block_start == ~0ULL) {
1796 			block_start = phys_block;
1797 			block_stop = block_start - 1;
1798 		}
1799 
1800 		/*
1801 		 * last block not contiguous with current block,
1802 		 * process last contiguous region and return to this block on
1803 		 * next loop
1804 		 */
1805 		if (phys_block != block_stop + 1) {
1806 			block--;
1807 		} else {
1808 			block_stop++;
1809 			/*
1810 			 * if this isn't the last block of journal,
1811 			 * no need to process now because next block may also
1812 			 * be part of this contiguous region
1813 			 */
1814 			if (block != journal->j_total_len - 1)
1815 				continue;
1816 		}
1817 
1818 		/*
1819 		 * end of contiguous region or this is last block of journal,
1820 		 * take care of the region
1821 		 */
1822 		byte_start = block_start * journal->j_blocksize;
1823 		byte_stop = block_stop * journal->j_blocksize;
1824 		byte_count = (block_stop - block_start + 1) *
1825 				journal->j_blocksize;
1826 
1827 		truncate_inode_pages_range(journal->j_dev->bd_inode->i_mapping,
1828 				byte_start, byte_stop);
1829 
1830 		if (flags & JBD2_JOURNAL_FLUSH_DISCARD) {
1831 			err = blkdev_issue_discard(journal->j_dev,
1832 					byte_start >> SECTOR_SHIFT,
1833 					byte_count >> SECTOR_SHIFT,
1834 					GFP_NOFS);
1835 		} else if (flags & JBD2_JOURNAL_FLUSH_ZEROOUT) {
1836 			err = blkdev_issue_zeroout(journal->j_dev,
1837 					byte_start >> SECTOR_SHIFT,
1838 					byte_count >> SECTOR_SHIFT,
1839 					GFP_NOFS, 0);
1840 		}
1841 
1842 		if (unlikely(err != 0)) {
1843 			pr_err("JBD2: (error %d) unable to wipe journal at physical blocks %llu - %llu",
1844 					err, block_start, block_stop);
1845 			return err;
1846 		}
1847 
1848 		/* reset start and stop after processing a region */
1849 		block_start = ~0ULL;
1850 	}
1851 
1852 	return blkdev_issue_flush(journal->j_dev);
1853 }
1854 
1855 /**
1856  * jbd2_journal_update_sb_errno() - Update error in the journal.
1857  * @journal: The journal to update.
1858  *
1859  * Update a journal's errno.  Write updated superblock to disk waiting for IO
1860  * to complete.
1861  */
jbd2_journal_update_sb_errno(journal_t * journal)1862 void jbd2_journal_update_sb_errno(journal_t *journal)
1863 {
1864 	journal_superblock_t *sb = journal->j_superblock;
1865 	int errcode;
1866 
1867 	lock_buffer(journal->j_sb_buffer);
1868 	errcode = journal->j_errno;
1869 	if (errcode == -ESHUTDOWN)
1870 		errcode = 0;
1871 	jbd2_debug(1, "JBD2: updating superblock error (errno %d)\n", errcode);
1872 	sb->s_errno    = cpu_to_be32(errcode);
1873 
1874 	jbd2_write_superblock(journal, REQ_SYNC | REQ_FUA);
1875 }
1876 EXPORT_SYMBOL(jbd2_journal_update_sb_errno);
1877 
journal_revoke_records_per_block(journal_t * journal)1878 static int journal_revoke_records_per_block(journal_t *journal)
1879 {
1880 	int record_size;
1881 	int space = journal->j_blocksize - sizeof(jbd2_journal_revoke_header_t);
1882 
1883 	if (jbd2_has_feature_64bit(journal))
1884 		record_size = 8;
1885 	else
1886 		record_size = 4;
1887 
1888 	if (jbd2_journal_has_csum_v2or3(journal))
1889 		space -= sizeof(struct jbd2_journal_block_tail);
1890 	return space / record_size;
1891 }
1892 
1893 /*
1894  * Read the superblock for a given journal, performing initial
1895  * validation of the format.
1896  */
journal_get_superblock(journal_t * journal)1897 static int journal_get_superblock(journal_t *journal)
1898 {
1899 	struct buffer_head *bh;
1900 	journal_superblock_t *sb;
1901 	int err;
1902 
1903 	bh = journal->j_sb_buffer;
1904 
1905 	J_ASSERT(bh != NULL);
1906 	err = bh_read(bh, 0);
1907 	if (err < 0) {
1908 		printk(KERN_ERR
1909 			"JBD2: IO error reading journal superblock\n");
1910 		goto out;
1911 	}
1912 
1913 	if (buffer_verified(bh))
1914 		return 0;
1915 
1916 	sb = journal->j_superblock;
1917 
1918 	err = -EINVAL;
1919 
1920 	if (sb->s_header.h_magic != cpu_to_be32(JBD2_MAGIC_NUMBER) ||
1921 	    sb->s_blocksize != cpu_to_be32(journal->j_blocksize)) {
1922 		printk(KERN_WARNING "JBD2: no valid journal superblock found\n");
1923 		goto out;
1924 	}
1925 
1926 	switch(be32_to_cpu(sb->s_header.h_blocktype)) {
1927 	case JBD2_SUPERBLOCK_V1:
1928 		journal->j_format_version = 1;
1929 		break;
1930 	case JBD2_SUPERBLOCK_V2:
1931 		journal->j_format_version = 2;
1932 		break;
1933 	default:
1934 		printk(KERN_WARNING "JBD2: unrecognised superblock format ID\n");
1935 		goto out;
1936 	}
1937 
1938 	if (be32_to_cpu(sb->s_maxlen) < journal->j_total_len)
1939 		journal->j_total_len = be32_to_cpu(sb->s_maxlen);
1940 	else if (be32_to_cpu(sb->s_maxlen) > journal->j_total_len) {
1941 		printk(KERN_WARNING "JBD2: journal file too short\n");
1942 		goto out;
1943 	}
1944 
1945 	if (be32_to_cpu(sb->s_first) == 0 ||
1946 	    be32_to_cpu(sb->s_first) >= journal->j_total_len) {
1947 		printk(KERN_WARNING
1948 			"JBD2: Invalid start block of journal: %u\n",
1949 			be32_to_cpu(sb->s_first));
1950 		goto out;
1951 	}
1952 
1953 	if (jbd2_has_feature_csum2(journal) &&
1954 	    jbd2_has_feature_csum3(journal)) {
1955 		/* Can't have checksum v2 and v3 at the same time! */
1956 		printk(KERN_ERR "JBD2: Can't enable checksumming v2 and v3 "
1957 		       "at the same time!\n");
1958 		goto out;
1959 	}
1960 
1961 	if (jbd2_journal_has_csum_v2or3_feature(journal) &&
1962 	    jbd2_has_feature_checksum(journal)) {
1963 		/* Can't have checksum v1 and v2 on at the same time! */
1964 		printk(KERN_ERR "JBD2: Can't enable checksumming v1 and v2/3 "
1965 		       "at the same time!\n");
1966 		goto out;
1967 	}
1968 
1969 	if (!jbd2_verify_csum_type(journal, sb)) {
1970 		printk(KERN_ERR "JBD2: Unknown checksum type\n");
1971 		goto out;
1972 	}
1973 
1974 	/* Load the checksum driver */
1975 	if (jbd2_journal_has_csum_v2or3_feature(journal)) {
1976 		journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0);
1977 		if (IS_ERR(journal->j_chksum_driver)) {
1978 			printk(KERN_ERR "JBD2: Cannot load crc32c driver.\n");
1979 			err = PTR_ERR(journal->j_chksum_driver);
1980 			journal->j_chksum_driver = NULL;
1981 			goto out;
1982 		}
1983 	}
1984 
1985 	if (jbd2_journal_has_csum_v2or3(journal)) {
1986 		/* Check superblock checksum */
1987 		if (sb->s_checksum != jbd2_superblock_csum(journal, sb)) {
1988 			printk(KERN_ERR "JBD2: journal checksum error\n");
1989 			err = -EFSBADCRC;
1990 			goto out;
1991 		}
1992 
1993 		/* Precompute checksum seed for all metadata */
1994 		journal->j_csum_seed = jbd2_chksum(journal, ~0, sb->s_uuid,
1995 						   sizeof(sb->s_uuid));
1996 	}
1997 
1998 	journal->j_revoke_records_per_block =
1999 				journal_revoke_records_per_block(journal);
2000 	set_buffer_verified(bh);
2001 
2002 	return 0;
2003 
2004 out:
2005 	journal_fail_superblock(journal);
2006 	return err;
2007 }
2008 
2009 /*
2010  * Load the on-disk journal superblock and read the key fields into the
2011  * journal_t.
2012  */
2013 
load_superblock(journal_t * journal)2014 static int load_superblock(journal_t *journal)
2015 {
2016 	int err;
2017 	journal_superblock_t *sb;
2018 	int num_fc_blocks;
2019 
2020 	err = journal_get_superblock(journal);
2021 	if (err)
2022 		return err;
2023 
2024 	sb = journal->j_superblock;
2025 
2026 	journal->j_tail_sequence = be32_to_cpu(sb->s_sequence);
2027 	journal->j_tail = be32_to_cpu(sb->s_start);
2028 	journal->j_first = be32_to_cpu(sb->s_first);
2029 	journal->j_errno = be32_to_cpu(sb->s_errno);
2030 	journal->j_last = be32_to_cpu(sb->s_maxlen);
2031 
2032 	if (jbd2_has_feature_fast_commit(journal)) {
2033 		journal->j_fc_last = be32_to_cpu(sb->s_maxlen);
2034 		num_fc_blocks = jbd2_journal_get_num_fc_blks(sb);
2035 		if (journal->j_last - num_fc_blocks >= JBD2_MIN_JOURNAL_BLOCKS)
2036 			journal->j_last = journal->j_fc_last - num_fc_blocks;
2037 		journal->j_fc_first = journal->j_last + 1;
2038 		journal->j_fc_off = 0;
2039 	}
2040 
2041 	return 0;
2042 }
2043 
2044 
2045 /**
2046  * jbd2_journal_load() - Read journal from disk.
2047  * @journal: Journal to act on.
2048  *
2049  * Given a journal_t structure which tells us which disk blocks contain
2050  * a journal, read the journal from disk to initialise the in-memory
2051  * structures.
2052  */
jbd2_journal_load(journal_t * journal)2053 int jbd2_journal_load(journal_t *journal)
2054 {
2055 	int err;
2056 	journal_superblock_t *sb;
2057 
2058 	err = load_superblock(journal);
2059 	if (err)
2060 		return err;
2061 
2062 	sb = journal->j_superblock;
2063 	/* If this is a V2 superblock, then we have to check the
2064 	 * features flags on it. */
2065 
2066 	if (journal->j_format_version >= 2) {
2067 		if ((sb->s_feature_ro_compat &
2068 		     ~cpu_to_be32(JBD2_KNOWN_ROCOMPAT_FEATURES)) ||
2069 		    (sb->s_feature_incompat &
2070 		     ~cpu_to_be32(JBD2_KNOWN_INCOMPAT_FEATURES))) {
2071 			printk(KERN_WARNING
2072 				"JBD2: Unrecognised features on journal\n");
2073 			return -EINVAL;
2074 		}
2075 	}
2076 
2077 	/*
2078 	 * Create a slab for this blocksize
2079 	 */
2080 	err = jbd2_journal_create_slab(be32_to_cpu(sb->s_blocksize));
2081 	if (err)
2082 		return err;
2083 
2084 	/* Let the recovery code check whether it needs to recover any
2085 	 * data from the journal. */
2086 	if (jbd2_journal_recover(journal))
2087 		goto recovery_error;
2088 
2089 	if (journal->j_failed_commit) {
2090 		printk(KERN_ERR "JBD2: journal transaction %u on %s "
2091 		       "is corrupt.\n", journal->j_failed_commit,
2092 		       journal->j_devname);
2093 		return -EFSCORRUPTED;
2094 	}
2095 	/*
2096 	 * clear JBD2_ABORT flag initialized in journal_init_common
2097 	 * here to update log tail information with the newest seq.
2098 	 */
2099 	journal->j_flags &= ~JBD2_ABORT;
2100 
2101 	/* OK, we've finished with the dynamic journal bits:
2102 	 * reinitialise the dynamic contents of the superblock in memory
2103 	 * and reset them on disk. */
2104 	if (journal_reset(journal))
2105 		goto recovery_error;
2106 
2107 	journal->j_flags |= JBD2_LOADED;
2108 	return 0;
2109 
2110 recovery_error:
2111 	printk(KERN_WARNING "JBD2: recovery failed\n");
2112 	return -EIO;
2113 }
2114 
2115 /**
2116  * jbd2_journal_destroy() - Release a journal_t structure.
2117  * @journal: Journal to act on.
2118  *
2119  * Release a journal_t structure once it is no longer in use by the
2120  * journaled object.
2121  * Return <0 if we couldn't clean up the journal.
2122  */
jbd2_journal_destroy(journal_t * journal)2123 int jbd2_journal_destroy(journal_t *journal)
2124 {
2125 	int err = 0;
2126 
2127 	/* Wait for the commit thread to wake up and die. */
2128 	journal_kill_thread(journal);
2129 
2130 	/* Force a final log commit */
2131 	if (journal->j_running_transaction)
2132 		jbd2_journal_commit_transaction(journal);
2133 
2134 	/* Force any old transactions to disk */
2135 
2136 	/* Totally anal locking here... */
2137 	spin_lock(&journal->j_list_lock);
2138 	while (journal->j_checkpoint_transactions != NULL) {
2139 		spin_unlock(&journal->j_list_lock);
2140 		mutex_lock_io(&journal->j_checkpoint_mutex);
2141 		err = jbd2_log_do_checkpoint(journal);
2142 		mutex_unlock(&journal->j_checkpoint_mutex);
2143 		/*
2144 		 * If checkpointing failed, just free the buffers to avoid
2145 		 * looping forever
2146 		 */
2147 		if (err) {
2148 			jbd2_journal_destroy_checkpoint(journal);
2149 			spin_lock(&journal->j_list_lock);
2150 			break;
2151 		}
2152 		spin_lock(&journal->j_list_lock);
2153 	}
2154 
2155 	J_ASSERT(journal->j_running_transaction == NULL);
2156 	J_ASSERT(journal->j_committing_transaction == NULL);
2157 	J_ASSERT(journal->j_checkpoint_transactions == NULL);
2158 	spin_unlock(&journal->j_list_lock);
2159 
2160 	/*
2161 	 * OK, all checkpoint transactions have been checked, now check the
2162 	 * write out io error flag and abort the journal if some buffer failed
2163 	 * to write back to the original location, otherwise the filesystem
2164 	 * may become inconsistent.
2165 	 */
2166 	if (!is_journal_aborted(journal) &&
2167 	    test_bit(JBD2_CHECKPOINT_IO_ERROR, &journal->j_atomic_flags))
2168 		jbd2_journal_abort(journal, -EIO);
2169 
2170 	if (journal->j_sb_buffer) {
2171 		if (!is_journal_aborted(journal)) {
2172 			mutex_lock_io(&journal->j_checkpoint_mutex);
2173 
2174 			write_lock(&journal->j_state_lock);
2175 			journal->j_tail_sequence =
2176 				++journal->j_transaction_sequence;
2177 			write_unlock(&journal->j_state_lock);
2178 
2179 			jbd2_mark_journal_empty(journal,
2180 					REQ_SYNC | REQ_PREFLUSH | REQ_FUA);
2181 			mutex_unlock(&journal->j_checkpoint_mutex);
2182 		} else
2183 			err = -EIO;
2184 		brelse(journal->j_sb_buffer);
2185 	}
2186 
2187 	if (journal->j_shrinker.flags & SHRINKER_REGISTERED) {
2188 		percpu_counter_destroy(&journal->j_checkpoint_jh_count);
2189 		unregister_shrinker(&journal->j_shrinker);
2190 	}
2191 	if (journal->j_proc_entry)
2192 		jbd2_stats_proc_exit(journal);
2193 	iput(journal->j_inode);
2194 	if (journal->j_revoke)
2195 		jbd2_journal_destroy_revoke(journal);
2196 	if (journal->j_chksum_driver)
2197 		crypto_free_shash(journal->j_chksum_driver);
2198 	kfree(journal->j_fc_wbuf);
2199 	kfree(journal->j_wbuf);
2200 	kfree(journal);
2201 
2202 	return err;
2203 }
2204 
2205 
2206 /**
2207  * jbd2_journal_check_used_features() - Check if features specified are used.
2208  * @journal: Journal to check.
2209  * @compat: bitmask of compatible features
2210  * @ro: bitmask of features that force read-only mount
2211  * @incompat: bitmask of incompatible features
2212  *
2213  * Check whether the journal uses all of a given set of
2214  * features.  Return true (non-zero) if it does.
2215  **/
2216 
jbd2_journal_check_used_features(journal_t * journal,unsigned long compat,unsigned long ro,unsigned long incompat)2217 int jbd2_journal_check_used_features(journal_t *journal, unsigned long compat,
2218 				 unsigned long ro, unsigned long incompat)
2219 {
2220 	journal_superblock_t *sb;
2221 
2222 	if (!compat && !ro && !incompat)
2223 		return 1;
2224 	/* Load journal superblock if it is not loaded yet. */
2225 	if (journal->j_format_version == 0 &&
2226 	    journal_get_superblock(journal) != 0)
2227 		return 0;
2228 	if (journal->j_format_version == 1)
2229 		return 0;
2230 
2231 	sb = journal->j_superblock;
2232 
2233 	if (((be32_to_cpu(sb->s_feature_compat) & compat) == compat) &&
2234 	    ((be32_to_cpu(sb->s_feature_ro_compat) & ro) == ro) &&
2235 	    ((be32_to_cpu(sb->s_feature_incompat) & incompat) == incompat))
2236 		return 1;
2237 
2238 	return 0;
2239 }
2240 
2241 /**
2242  * jbd2_journal_check_available_features() - Check feature set in journalling layer
2243  * @journal: Journal to check.
2244  * @compat: bitmask of compatible features
2245  * @ro: bitmask of features that force read-only mount
2246  * @incompat: bitmask of incompatible features
2247  *
2248  * Check whether the journaling code supports the use of
2249  * all of a given set of features on this journal.  Return true
2250  * (non-zero) if it can. */
2251 
jbd2_journal_check_available_features(journal_t * journal,unsigned long compat,unsigned long ro,unsigned long incompat)2252 int jbd2_journal_check_available_features(journal_t *journal, unsigned long compat,
2253 				      unsigned long ro, unsigned long incompat)
2254 {
2255 	if (!compat && !ro && !incompat)
2256 		return 1;
2257 
2258 	/* We can support any known requested features iff the
2259 	 * superblock is in version 2.  Otherwise we fail to support any
2260 	 * extended sb features. */
2261 
2262 	if (journal->j_format_version != 2)
2263 		return 0;
2264 
2265 	if ((compat   & JBD2_KNOWN_COMPAT_FEATURES) == compat &&
2266 	    (ro       & JBD2_KNOWN_ROCOMPAT_FEATURES) == ro &&
2267 	    (incompat & JBD2_KNOWN_INCOMPAT_FEATURES) == incompat)
2268 		return 1;
2269 
2270 	return 0;
2271 }
2272 
2273 static int
jbd2_journal_initialize_fast_commit(journal_t * journal)2274 jbd2_journal_initialize_fast_commit(journal_t *journal)
2275 {
2276 	journal_superblock_t *sb = journal->j_superblock;
2277 	unsigned long long num_fc_blks;
2278 
2279 	num_fc_blks = jbd2_journal_get_num_fc_blks(sb);
2280 	if (journal->j_last - num_fc_blks < JBD2_MIN_JOURNAL_BLOCKS)
2281 		return -ENOSPC;
2282 
2283 	/* Are we called twice? */
2284 	WARN_ON(journal->j_fc_wbuf != NULL);
2285 	journal->j_fc_wbuf = kmalloc_array(num_fc_blks,
2286 				sizeof(struct buffer_head *), GFP_KERNEL);
2287 	if (!journal->j_fc_wbuf)
2288 		return -ENOMEM;
2289 
2290 	journal->j_fc_wbufsize = num_fc_blks;
2291 	journal->j_fc_last = journal->j_last;
2292 	journal->j_last = journal->j_fc_last - num_fc_blks;
2293 	journal->j_fc_first = journal->j_last + 1;
2294 	journal->j_fc_off = 0;
2295 	journal->j_free = journal->j_last - journal->j_first;
2296 	journal->j_max_transaction_buffers =
2297 		jbd2_journal_get_max_txn_bufs(journal);
2298 
2299 	return 0;
2300 }
2301 
2302 /**
2303  * jbd2_journal_set_features() - Mark a given journal feature in the superblock
2304  * @journal: Journal to act on.
2305  * @compat: bitmask of compatible features
2306  * @ro: bitmask of features that force read-only mount
2307  * @incompat: bitmask of incompatible features
2308  *
2309  * Mark a given journal feature as present on the
2310  * superblock.  Returns true if the requested features could be set.
2311  *
2312  */
2313 
jbd2_journal_set_features(journal_t * journal,unsigned long compat,unsigned long ro,unsigned long incompat)2314 int jbd2_journal_set_features(journal_t *journal, unsigned long compat,
2315 			  unsigned long ro, unsigned long incompat)
2316 {
2317 #define INCOMPAT_FEATURE_ON(f) \
2318 		((incompat & (f)) && !(sb->s_feature_incompat & cpu_to_be32(f)))
2319 #define COMPAT_FEATURE_ON(f) \
2320 		((compat & (f)) && !(sb->s_feature_compat & cpu_to_be32(f)))
2321 	journal_superblock_t *sb;
2322 
2323 	if (jbd2_journal_check_used_features(journal, compat, ro, incompat))
2324 		return 1;
2325 
2326 	if (!jbd2_journal_check_available_features(journal, compat, ro, incompat))
2327 		return 0;
2328 
2329 	/* If enabling v2 checksums, turn on v3 instead */
2330 	if (incompat & JBD2_FEATURE_INCOMPAT_CSUM_V2) {
2331 		incompat &= ~JBD2_FEATURE_INCOMPAT_CSUM_V2;
2332 		incompat |= JBD2_FEATURE_INCOMPAT_CSUM_V3;
2333 	}
2334 
2335 	/* Asking for checksumming v3 and v1?  Only give them v3. */
2336 	if (incompat & JBD2_FEATURE_INCOMPAT_CSUM_V3 &&
2337 	    compat & JBD2_FEATURE_COMPAT_CHECKSUM)
2338 		compat &= ~JBD2_FEATURE_COMPAT_CHECKSUM;
2339 
2340 	jbd2_debug(1, "Setting new features 0x%lx/0x%lx/0x%lx\n",
2341 		  compat, ro, incompat);
2342 
2343 	sb = journal->j_superblock;
2344 
2345 	if (incompat & JBD2_FEATURE_INCOMPAT_FAST_COMMIT) {
2346 		if (jbd2_journal_initialize_fast_commit(journal)) {
2347 			pr_err("JBD2: Cannot enable fast commits.\n");
2348 			return 0;
2349 		}
2350 	}
2351 
2352 	/* Load the checksum driver if necessary */
2353 	if ((journal->j_chksum_driver == NULL) &&
2354 	    INCOMPAT_FEATURE_ON(JBD2_FEATURE_INCOMPAT_CSUM_V3)) {
2355 		journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0);
2356 		if (IS_ERR(journal->j_chksum_driver)) {
2357 			printk(KERN_ERR "JBD2: Cannot load crc32c driver.\n");
2358 			journal->j_chksum_driver = NULL;
2359 			return 0;
2360 		}
2361 		/* Precompute checksum seed for all metadata */
2362 		journal->j_csum_seed = jbd2_chksum(journal, ~0, sb->s_uuid,
2363 						   sizeof(sb->s_uuid));
2364 	}
2365 
2366 	lock_buffer(journal->j_sb_buffer);
2367 
2368 	/* If enabling v3 checksums, update superblock */
2369 	if (INCOMPAT_FEATURE_ON(JBD2_FEATURE_INCOMPAT_CSUM_V3)) {
2370 		sb->s_checksum_type = JBD2_CRC32C_CHKSUM;
2371 		sb->s_feature_compat &=
2372 			~cpu_to_be32(JBD2_FEATURE_COMPAT_CHECKSUM);
2373 	}
2374 
2375 	/* If enabling v1 checksums, downgrade superblock */
2376 	if (COMPAT_FEATURE_ON(JBD2_FEATURE_COMPAT_CHECKSUM))
2377 		sb->s_feature_incompat &=
2378 			~cpu_to_be32(JBD2_FEATURE_INCOMPAT_CSUM_V2 |
2379 				     JBD2_FEATURE_INCOMPAT_CSUM_V3);
2380 
2381 	sb->s_feature_compat    |= cpu_to_be32(compat);
2382 	sb->s_feature_ro_compat |= cpu_to_be32(ro);
2383 	sb->s_feature_incompat  |= cpu_to_be32(incompat);
2384 	unlock_buffer(journal->j_sb_buffer);
2385 	journal->j_revoke_records_per_block =
2386 				journal_revoke_records_per_block(journal);
2387 
2388 	return 1;
2389 #undef COMPAT_FEATURE_ON
2390 #undef INCOMPAT_FEATURE_ON
2391 }
2392 
2393 /*
2394  * jbd2_journal_clear_features() - Clear a given journal feature in the
2395  * 				    superblock
2396  * @journal: Journal to act on.
2397  * @compat: bitmask of compatible features
2398  * @ro: bitmask of features that force read-only mount
2399  * @incompat: bitmask of incompatible features
2400  *
2401  * Clear a given journal feature as present on the
2402  * superblock.
2403  */
jbd2_journal_clear_features(journal_t * journal,unsigned long compat,unsigned long ro,unsigned long incompat)2404 void jbd2_journal_clear_features(journal_t *journal, unsigned long compat,
2405 				unsigned long ro, unsigned long incompat)
2406 {
2407 	journal_superblock_t *sb;
2408 
2409 	jbd2_debug(1, "Clear features 0x%lx/0x%lx/0x%lx\n",
2410 		  compat, ro, incompat);
2411 
2412 	sb = journal->j_superblock;
2413 
2414 	sb->s_feature_compat    &= ~cpu_to_be32(compat);
2415 	sb->s_feature_ro_compat &= ~cpu_to_be32(ro);
2416 	sb->s_feature_incompat  &= ~cpu_to_be32(incompat);
2417 	journal->j_revoke_records_per_block =
2418 				journal_revoke_records_per_block(journal);
2419 }
2420 EXPORT_SYMBOL(jbd2_journal_clear_features);
2421 
2422 /**
2423  * jbd2_journal_flush() - Flush journal
2424  * @journal: Journal to act on.
2425  * @flags: optional operation on the journal blocks after the flush (see below)
2426  *
2427  * Flush all data for a given journal to disk and empty the journal.
2428  * Filesystems can use this when remounting readonly to ensure that
2429  * recovery does not need to happen on remount. Optionally, a discard or zeroout
2430  * can be issued on the journal blocks after flushing.
2431  *
2432  * flags:
2433  *	JBD2_JOURNAL_FLUSH_DISCARD: issues discards for the journal blocks
2434  *	JBD2_JOURNAL_FLUSH_ZEROOUT: issues zeroouts for the journal blocks
2435  */
jbd2_journal_flush(journal_t * journal,unsigned int flags)2436 int jbd2_journal_flush(journal_t *journal, unsigned int flags)
2437 {
2438 	int err = 0;
2439 	transaction_t *transaction = NULL;
2440 
2441 	write_lock(&journal->j_state_lock);
2442 
2443 	/* Force everything buffered to the log... */
2444 	if (journal->j_running_transaction) {
2445 		transaction = journal->j_running_transaction;
2446 		__jbd2_log_start_commit(journal, transaction->t_tid);
2447 	} else if (journal->j_committing_transaction)
2448 		transaction = journal->j_committing_transaction;
2449 
2450 	/* Wait for the log commit to complete... */
2451 	if (transaction) {
2452 		tid_t tid = transaction->t_tid;
2453 
2454 		write_unlock(&journal->j_state_lock);
2455 		jbd2_log_wait_commit(journal, tid);
2456 	} else {
2457 		write_unlock(&journal->j_state_lock);
2458 	}
2459 
2460 	/* ...and flush everything in the log out to disk. */
2461 	spin_lock(&journal->j_list_lock);
2462 	while (!err && journal->j_checkpoint_transactions != NULL) {
2463 		spin_unlock(&journal->j_list_lock);
2464 		mutex_lock_io(&journal->j_checkpoint_mutex);
2465 		err = jbd2_log_do_checkpoint(journal);
2466 		mutex_unlock(&journal->j_checkpoint_mutex);
2467 		spin_lock(&journal->j_list_lock);
2468 	}
2469 	spin_unlock(&journal->j_list_lock);
2470 
2471 	if (is_journal_aborted(journal))
2472 		return -EIO;
2473 
2474 	mutex_lock_io(&journal->j_checkpoint_mutex);
2475 	if (!err) {
2476 		err = jbd2_cleanup_journal_tail(journal);
2477 		if (err < 0) {
2478 			mutex_unlock(&journal->j_checkpoint_mutex);
2479 			goto out;
2480 		}
2481 		err = 0;
2482 	}
2483 
2484 	/* Finally, mark the journal as really needing no recovery.
2485 	 * This sets s_start==0 in the underlying superblock, which is
2486 	 * the magic code for a fully-recovered superblock.  Any future
2487 	 * commits of data to the journal will restore the current
2488 	 * s_start value. */
2489 	jbd2_mark_journal_empty(journal, REQ_SYNC | REQ_FUA);
2490 
2491 	if (flags)
2492 		err = __jbd2_journal_erase(journal, flags);
2493 
2494 	mutex_unlock(&journal->j_checkpoint_mutex);
2495 	write_lock(&journal->j_state_lock);
2496 	J_ASSERT(!journal->j_running_transaction);
2497 	J_ASSERT(!journal->j_committing_transaction);
2498 	J_ASSERT(!journal->j_checkpoint_transactions);
2499 	J_ASSERT(journal->j_head == journal->j_tail);
2500 	J_ASSERT(journal->j_tail_sequence == journal->j_transaction_sequence);
2501 	write_unlock(&journal->j_state_lock);
2502 out:
2503 	return err;
2504 }
2505 
2506 /**
2507  * jbd2_journal_wipe() - Wipe journal contents
2508  * @journal: Journal to act on.
2509  * @write: flag (see below)
2510  *
2511  * Wipe out all of the contents of a journal, safely.  This will produce
2512  * a warning if the journal contains any valid recovery information.
2513  * Must be called between journal_init_*() and jbd2_journal_load().
2514  *
2515  * If 'write' is non-zero, then we wipe out the journal on disk; otherwise
2516  * we merely suppress recovery.
2517  */
2518 
jbd2_journal_wipe(journal_t * journal,int write)2519 int jbd2_journal_wipe(journal_t *journal, int write)
2520 {
2521 	int err = 0;
2522 
2523 	J_ASSERT (!(journal->j_flags & JBD2_LOADED));
2524 
2525 	err = load_superblock(journal);
2526 	if (err)
2527 		return err;
2528 
2529 	if (!journal->j_tail)
2530 		goto no_recovery;
2531 
2532 	printk(KERN_WARNING "JBD2: %s recovery information on journal\n",
2533 		write ? "Clearing" : "Ignoring");
2534 
2535 	err = jbd2_journal_skip_recovery(journal);
2536 	if (write) {
2537 		/* Lock to make assertions happy... */
2538 		mutex_lock_io(&journal->j_checkpoint_mutex);
2539 		jbd2_mark_journal_empty(journal, REQ_SYNC | REQ_FUA);
2540 		mutex_unlock(&journal->j_checkpoint_mutex);
2541 	}
2542 
2543  no_recovery:
2544 	return err;
2545 }
2546 
2547 /**
2548  * jbd2_journal_abort () - Shutdown the journal immediately.
2549  * @journal: the journal to shutdown.
2550  * @errno:   an error number to record in the journal indicating
2551  *           the reason for the shutdown.
2552  *
2553  * Perform a complete, immediate shutdown of the ENTIRE
2554  * journal (not of a single transaction).  This operation cannot be
2555  * undone without closing and reopening the journal.
2556  *
2557  * The jbd2_journal_abort function is intended to support higher level error
2558  * recovery mechanisms such as the ext2/ext3 remount-readonly error
2559  * mode.
2560  *
2561  * Journal abort has very specific semantics.  Any existing dirty,
2562  * unjournaled buffers in the main filesystem will still be written to
2563  * disk by bdflush, but the journaling mechanism will be suspended
2564  * immediately and no further transaction commits will be honoured.
2565  *
2566  * Any dirty, journaled buffers will be written back to disk without
2567  * hitting the journal.  Atomicity cannot be guaranteed on an aborted
2568  * filesystem, but we _do_ attempt to leave as much data as possible
2569  * behind for fsck to use for cleanup.
2570  *
2571  * Any attempt to get a new transaction handle on a journal which is in
2572  * ABORT state will just result in an -EROFS error return.  A
2573  * jbd2_journal_stop on an existing handle will return -EIO if we have
2574  * entered abort state during the update.
2575  *
2576  * Recursive transactions are not disturbed by journal abort until the
2577  * final jbd2_journal_stop, which will receive the -EIO error.
2578  *
2579  * Finally, the jbd2_journal_abort call allows the caller to supply an errno
2580  * which will be recorded (if possible) in the journal superblock.  This
2581  * allows a client to record failure conditions in the middle of a
2582  * transaction without having to complete the transaction to record the
2583  * failure to disk.  ext3_error, for example, now uses this
2584  * functionality.
2585  *
2586  */
2587 
jbd2_journal_abort(journal_t * journal,int errno)2588 void jbd2_journal_abort(journal_t *journal, int errno)
2589 {
2590 	transaction_t *transaction;
2591 
2592 	/*
2593 	 * Lock the aborting procedure until everything is done, this avoid
2594 	 * races between filesystem's error handling flow (e.g. ext4_abort()),
2595 	 * ensure panic after the error info is written into journal's
2596 	 * superblock.
2597 	 */
2598 	mutex_lock(&journal->j_abort_mutex);
2599 	/*
2600 	 * ESHUTDOWN always takes precedence because a file system check
2601 	 * caused by any other journal abort error is not required after
2602 	 * a shutdown triggered.
2603 	 */
2604 	write_lock(&journal->j_state_lock);
2605 	if (journal->j_flags & JBD2_ABORT) {
2606 		int old_errno = journal->j_errno;
2607 
2608 		write_unlock(&journal->j_state_lock);
2609 		if (old_errno != -ESHUTDOWN && errno == -ESHUTDOWN) {
2610 			journal->j_errno = errno;
2611 			jbd2_journal_update_sb_errno(journal);
2612 		}
2613 		mutex_unlock(&journal->j_abort_mutex);
2614 		return;
2615 	}
2616 
2617 	/*
2618 	 * Mark the abort as occurred and start current running transaction
2619 	 * to release all journaled buffer.
2620 	 */
2621 	pr_err("Aborting journal on device %s.\n", journal->j_devname);
2622 
2623 	journal->j_flags |= JBD2_ABORT;
2624 	journal->j_errno = errno;
2625 	transaction = journal->j_running_transaction;
2626 	if (transaction)
2627 		__jbd2_log_start_commit(journal, transaction->t_tid);
2628 	write_unlock(&journal->j_state_lock);
2629 
2630 	/*
2631 	 * Record errno to the journal super block, so that fsck and jbd2
2632 	 * layer could realise that a filesystem check is needed.
2633 	 */
2634 	jbd2_journal_update_sb_errno(journal);
2635 	mutex_unlock(&journal->j_abort_mutex);
2636 }
2637 
2638 /**
2639  * jbd2_journal_errno() - returns the journal's error state.
2640  * @journal: journal to examine.
2641  *
2642  * This is the errno number set with jbd2_journal_abort(), the last
2643  * time the journal was mounted - if the journal was stopped
2644  * without calling abort this will be 0.
2645  *
2646  * If the journal has been aborted on this mount time -EROFS will
2647  * be returned.
2648  */
jbd2_journal_errno(journal_t * journal)2649 int jbd2_journal_errno(journal_t *journal)
2650 {
2651 	int err;
2652 
2653 	read_lock(&journal->j_state_lock);
2654 	if (journal->j_flags & JBD2_ABORT)
2655 		err = -EROFS;
2656 	else
2657 		err = journal->j_errno;
2658 	read_unlock(&journal->j_state_lock);
2659 	return err;
2660 }
2661 
2662 /**
2663  * jbd2_journal_clear_err() - clears the journal's error state
2664  * @journal: journal to act on.
2665  *
2666  * An error must be cleared or acked to take a FS out of readonly
2667  * mode.
2668  */
jbd2_journal_clear_err(journal_t * journal)2669 int jbd2_journal_clear_err(journal_t *journal)
2670 {
2671 	int err = 0;
2672 
2673 	write_lock(&journal->j_state_lock);
2674 	if (journal->j_flags & JBD2_ABORT)
2675 		err = -EROFS;
2676 	else
2677 		journal->j_errno = 0;
2678 	write_unlock(&journal->j_state_lock);
2679 	return err;
2680 }
2681 
2682 /**
2683  * jbd2_journal_ack_err() - Ack journal err.
2684  * @journal: journal to act on.
2685  *
2686  * An error must be cleared or acked to take a FS out of readonly
2687  * mode.
2688  */
jbd2_journal_ack_err(journal_t * journal)2689 void jbd2_journal_ack_err(journal_t *journal)
2690 {
2691 	write_lock(&journal->j_state_lock);
2692 	if (journal->j_errno)
2693 		journal->j_flags |= JBD2_ACK_ERR;
2694 	write_unlock(&journal->j_state_lock);
2695 }
2696 
jbd2_journal_blocks_per_page(struct inode * inode)2697 int jbd2_journal_blocks_per_page(struct inode *inode)
2698 {
2699 	return 1 << (PAGE_SHIFT - inode->i_sb->s_blocksize_bits);
2700 }
2701 
2702 /*
2703  * helper functions to deal with 32 or 64bit block numbers.
2704  */
journal_tag_bytes(journal_t * journal)2705 size_t journal_tag_bytes(journal_t *journal)
2706 {
2707 	size_t sz;
2708 
2709 	if (jbd2_has_feature_csum3(journal))
2710 		return sizeof(journal_block_tag3_t);
2711 
2712 	sz = sizeof(journal_block_tag_t);
2713 
2714 	if (jbd2_has_feature_csum2(journal))
2715 		sz += sizeof(__u16);
2716 
2717 	if (jbd2_has_feature_64bit(journal))
2718 		return sz;
2719 	else
2720 		return sz - sizeof(__u32);
2721 }
2722 
2723 /*
2724  * JBD memory management
2725  *
2726  * These functions are used to allocate block-sized chunks of memory
2727  * used for making copies of buffer_head data.  Very often it will be
2728  * page-sized chunks of data, but sometimes it will be in
2729  * sub-page-size chunks.  (For example, 16k pages on Power systems
2730  * with a 4k block file system.)  For blocks smaller than a page, we
2731  * use a SLAB allocator.  There are slab caches for each block size,
2732  * which are allocated at mount time, if necessary, and we only free
2733  * (all of) the slab caches when/if the jbd2 module is unloaded.  For
2734  * this reason we don't need to a mutex to protect access to
2735  * jbd2_slab[] allocating or releasing memory; only in
2736  * jbd2_journal_create_slab().
2737  */
2738 #define JBD2_MAX_SLABS 8
2739 static struct kmem_cache *jbd2_slab[JBD2_MAX_SLABS];
2740 
2741 static const char *jbd2_slab_names[JBD2_MAX_SLABS] = {
2742 	"jbd2_1k", "jbd2_2k", "jbd2_4k", "jbd2_8k",
2743 	"jbd2_16k", "jbd2_32k", "jbd2_64k", "jbd2_128k"
2744 };
2745 
2746 
jbd2_journal_destroy_slabs(void)2747 static void jbd2_journal_destroy_slabs(void)
2748 {
2749 	int i;
2750 
2751 	for (i = 0; i < JBD2_MAX_SLABS; i++) {
2752 		kmem_cache_destroy(jbd2_slab[i]);
2753 		jbd2_slab[i] = NULL;
2754 	}
2755 }
2756 
jbd2_journal_create_slab(size_t size)2757 static int jbd2_journal_create_slab(size_t size)
2758 {
2759 	static DEFINE_MUTEX(jbd2_slab_create_mutex);
2760 	int i = order_base_2(size) - 10;
2761 	size_t slab_size;
2762 
2763 	if (size == PAGE_SIZE)
2764 		return 0;
2765 
2766 	if (i >= JBD2_MAX_SLABS)
2767 		return -EINVAL;
2768 
2769 	if (unlikely(i < 0))
2770 		i = 0;
2771 	mutex_lock(&jbd2_slab_create_mutex);
2772 	if (jbd2_slab[i]) {
2773 		mutex_unlock(&jbd2_slab_create_mutex);
2774 		return 0;	/* Already created */
2775 	}
2776 
2777 	slab_size = 1 << (i+10);
2778 	jbd2_slab[i] = kmem_cache_create(jbd2_slab_names[i], slab_size,
2779 					 slab_size, 0, NULL);
2780 	mutex_unlock(&jbd2_slab_create_mutex);
2781 	if (!jbd2_slab[i]) {
2782 		printk(KERN_EMERG "JBD2: no memory for jbd2_slab cache\n");
2783 		return -ENOMEM;
2784 	}
2785 	return 0;
2786 }
2787 
get_slab(size_t size)2788 static struct kmem_cache *get_slab(size_t size)
2789 {
2790 	int i = order_base_2(size) - 10;
2791 
2792 	BUG_ON(i >= JBD2_MAX_SLABS);
2793 	if (unlikely(i < 0))
2794 		i = 0;
2795 	BUG_ON(jbd2_slab[i] == NULL);
2796 	return jbd2_slab[i];
2797 }
2798 
jbd2_alloc(size_t size,gfp_t flags)2799 void *jbd2_alloc(size_t size, gfp_t flags)
2800 {
2801 	void *ptr;
2802 
2803 	BUG_ON(size & (size-1)); /* Must be a power of 2 */
2804 
2805 	if (size < PAGE_SIZE)
2806 		ptr = kmem_cache_alloc(get_slab(size), flags);
2807 	else
2808 		ptr = (void *)__get_free_pages(flags, get_order(size));
2809 
2810 	/* Check alignment; SLUB has gotten this wrong in the past,
2811 	 * and this can lead to user data corruption! */
2812 	BUG_ON(((unsigned long) ptr) & (size-1));
2813 
2814 	return ptr;
2815 }
2816 
jbd2_free(void * ptr,size_t size)2817 void jbd2_free(void *ptr, size_t size)
2818 {
2819 	if (size < PAGE_SIZE)
2820 		kmem_cache_free(get_slab(size), ptr);
2821 	else
2822 		free_pages((unsigned long)ptr, get_order(size));
2823 };
2824 
2825 /*
2826  * Journal_head storage management
2827  */
2828 static struct kmem_cache *jbd2_journal_head_cache;
2829 #ifdef CONFIG_JBD2_DEBUG
2830 static atomic_t nr_journal_heads = ATOMIC_INIT(0);
2831 #endif
2832 
jbd2_journal_init_journal_head_cache(void)2833 static int __init jbd2_journal_init_journal_head_cache(void)
2834 {
2835 	J_ASSERT(!jbd2_journal_head_cache);
2836 	jbd2_journal_head_cache = kmem_cache_create("jbd2_journal_head",
2837 				sizeof(struct journal_head),
2838 				0,		/* offset */
2839 				SLAB_TEMPORARY | SLAB_TYPESAFE_BY_RCU,
2840 				NULL);		/* ctor */
2841 	if (!jbd2_journal_head_cache) {
2842 		printk(KERN_EMERG "JBD2: no memory for journal_head cache\n");
2843 		return -ENOMEM;
2844 	}
2845 	return 0;
2846 }
2847 
jbd2_journal_destroy_journal_head_cache(void)2848 static void jbd2_journal_destroy_journal_head_cache(void)
2849 {
2850 	kmem_cache_destroy(jbd2_journal_head_cache);
2851 	jbd2_journal_head_cache = NULL;
2852 }
2853 
2854 /*
2855  * journal_head splicing and dicing
2856  */
journal_alloc_journal_head(void)2857 static struct journal_head *journal_alloc_journal_head(void)
2858 {
2859 	struct journal_head *ret;
2860 
2861 #ifdef CONFIG_JBD2_DEBUG
2862 	atomic_inc(&nr_journal_heads);
2863 #endif
2864 	ret = kmem_cache_zalloc(jbd2_journal_head_cache, GFP_NOFS);
2865 	if (!ret) {
2866 		jbd2_debug(1, "out of memory for journal_head\n");
2867 		pr_notice_ratelimited("ENOMEM in %s, retrying.\n", __func__);
2868 		ret = kmem_cache_zalloc(jbd2_journal_head_cache,
2869 				GFP_NOFS | __GFP_NOFAIL);
2870 	}
2871 	if (ret)
2872 		spin_lock_init(&ret->b_state_lock);
2873 	return ret;
2874 }
2875 
journal_free_journal_head(struct journal_head * jh)2876 static void journal_free_journal_head(struct journal_head *jh)
2877 {
2878 #ifdef CONFIG_JBD2_DEBUG
2879 	atomic_dec(&nr_journal_heads);
2880 	memset(jh, JBD2_POISON_FREE, sizeof(*jh));
2881 #endif
2882 	kmem_cache_free(jbd2_journal_head_cache, jh);
2883 }
2884 
2885 /*
2886  * A journal_head is attached to a buffer_head whenever JBD has an
2887  * interest in the buffer.
2888  *
2889  * Whenever a buffer has an attached journal_head, its ->b_state:BH_JBD bit
2890  * is set.  This bit is tested in core kernel code where we need to take
2891  * JBD-specific actions.  Testing the zeroness of ->b_private is not reliable
2892  * there.
2893  *
2894  * When a buffer has its BH_JBD bit set, its ->b_count is elevated by one.
2895  *
2896  * When a buffer has its BH_JBD bit set it is immune from being released by
2897  * core kernel code, mainly via ->b_count.
2898  *
2899  * A journal_head is detached from its buffer_head when the journal_head's
2900  * b_jcount reaches zero. Running transaction (b_transaction) and checkpoint
2901  * transaction (b_cp_transaction) hold their references to b_jcount.
2902  *
2903  * Various places in the kernel want to attach a journal_head to a buffer_head
2904  * _before_ attaching the journal_head to a transaction.  To protect the
2905  * journal_head in this situation, jbd2_journal_add_journal_head elevates the
2906  * journal_head's b_jcount refcount by one.  The caller must call
2907  * jbd2_journal_put_journal_head() to undo this.
2908  *
2909  * So the typical usage would be:
2910  *
2911  *	(Attach a journal_head if needed.  Increments b_jcount)
2912  *	struct journal_head *jh = jbd2_journal_add_journal_head(bh);
2913  *	...
2914  *      (Get another reference for transaction)
2915  *	jbd2_journal_grab_journal_head(bh);
2916  *	jh->b_transaction = xxx;
2917  *	(Put original reference)
2918  *	jbd2_journal_put_journal_head(jh);
2919  */
2920 
2921 /*
2922  * Give a buffer_head a journal_head.
2923  *
2924  * May sleep.
2925  */
jbd2_journal_add_journal_head(struct buffer_head * bh)2926 struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh)
2927 {
2928 	struct journal_head *jh;
2929 	struct journal_head *new_jh = NULL;
2930 
2931 repeat:
2932 	if (!buffer_jbd(bh))
2933 		new_jh = journal_alloc_journal_head();
2934 
2935 	jbd_lock_bh_journal_head(bh);
2936 	if (buffer_jbd(bh)) {
2937 		jh = bh2jh(bh);
2938 	} else {
2939 		J_ASSERT_BH(bh,
2940 			(atomic_read(&bh->b_count) > 0) ||
2941 			(bh->b_page && bh->b_page->mapping));
2942 
2943 		if (!new_jh) {
2944 			jbd_unlock_bh_journal_head(bh);
2945 			goto repeat;
2946 		}
2947 
2948 		jh = new_jh;
2949 		new_jh = NULL;		/* We consumed it */
2950 		set_buffer_jbd(bh);
2951 		bh->b_private = jh;
2952 		jh->b_bh = bh;
2953 		get_bh(bh);
2954 		BUFFER_TRACE(bh, "added journal_head");
2955 	}
2956 	jh->b_jcount++;
2957 	jbd_unlock_bh_journal_head(bh);
2958 	if (new_jh)
2959 		journal_free_journal_head(new_jh);
2960 	return bh->b_private;
2961 }
2962 
2963 /*
2964  * Grab a ref against this buffer_head's journal_head.  If it ended up not
2965  * having a journal_head, return NULL
2966  */
jbd2_journal_grab_journal_head(struct buffer_head * bh)2967 struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh)
2968 {
2969 	struct journal_head *jh = NULL;
2970 
2971 	jbd_lock_bh_journal_head(bh);
2972 	if (buffer_jbd(bh)) {
2973 		jh = bh2jh(bh);
2974 		jh->b_jcount++;
2975 	}
2976 	jbd_unlock_bh_journal_head(bh);
2977 	return jh;
2978 }
2979 EXPORT_SYMBOL(jbd2_journal_grab_journal_head);
2980 
__journal_remove_journal_head(struct buffer_head * bh)2981 static void __journal_remove_journal_head(struct buffer_head *bh)
2982 {
2983 	struct journal_head *jh = bh2jh(bh);
2984 
2985 	J_ASSERT_JH(jh, jh->b_transaction == NULL);
2986 	J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
2987 	J_ASSERT_JH(jh, jh->b_cp_transaction == NULL);
2988 	J_ASSERT_JH(jh, jh->b_jlist == BJ_None);
2989 	J_ASSERT_BH(bh, buffer_jbd(bh));
2990 	J_ASSERT_BH(bh, jh2bh(jh) == bh);
2991 	BUFFER_TRACE(bh, "remove journal_head");
2992 
2993 	/* Unlink before dropping the lock */
2994 	bh->b_private = NULL;
2995 	jh->b_bh = NULL;	/* debug, really */
2996 	clear_buffer_jbd(bh);
2997 }
2998 
journal_release_journal_head(struct journal_head * jh,size_t b_size)2999 static void journal_release_journal_head(struct journal_head *jh, size_t b_size)
3000 {
3001 	if (jh->b_frozen_data) {
3002 		printk(KERN_WARNING "%s: freeing b_frozen_data\n", __func__);
3003 		jbd2_free(jh->b_frozen_data, b_size);
3004 	}
3005 	if (jh->b_committed_data) {
3006 		printk(KERN_WARNING "%s: freeing b_committed_data\n", __func__);
3007 		jbd2_free(jh->b_committed_data, b_size);
3008 	}
3009 	journal_free_journal_head(jh);
3010 }
3011 
3012 /*
3013  * Drop a reference on the passed journal_head.  If it fell to zero then
3014  * release the journal_head from the buffer_head.
3015  */
jbd2_journal_put_journal_head(struct journal_head * jh)3016 void jbd2_journal_put_journal_head(struct journal_head *jh)
3017 {
3018 	struct buffer_head *bh = jh2bh(jh);
3019 
3020 	jbd_lock_bh_journal_head(bh);
3021 	J_ASSERT_JH(jh, jh->b_jcount > 0);
3022 	--jh->b_jcount;
3023 	if (!jh->b_jcount) {
3024 		__journal_remove_journal_head(bh);
3025 		jbd_unlock_bh_journal_head(bh);
3026 		journal_release_journal_head(jh, bh->b_size);
3027 		__brelse(bh);
3028 	} else {
3029 		jbd_unlock_bh_journal_head(bh);
3030 	}
3031 }
3032 EXPORT_SYMBOL(jbd2_journal_put_journal_head);
3033 
3034 /*
3035  * Initialize jbd inode head
3036  */
jbd2_journal_init_jbd_inode(struct jbd2_inode * jinode,struct inode * inode)3037 void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode)
3038 {
3039 	jinode->i_transaction = NULL;
3040 	jinode->i_next_transaction = NULL;
3041 	jinode->i_vfs_inode = inode;
3042 	jinode->i_flags = 0;
3043 	jinode->i_dirty_start = 0;
3044 	jinode->i_dirty_end = 0;
3045 	INIT_LIST_HEAD(&jinode->i_list);
3046 }
3047 
3048 /*
3049  * Function to be called before we start removing inode from memory (i.e.,
3050  * clear_inode() is a fine place to be called from). It removes inode from
3051  * transaction's lists.
3052  */
jbd2_journal_release_jbd_inode(journal_t * journal,struct jbd2_inode * jinode)3053 void jbd2_journal_release_jbd_inode(journal_t *journal,
3054 				    struct jbd2_inode *jinode)
3055 {
3056 	if (!journal)
3057 		return;
3058 restart:
3059 	spin_lock(&journal->j_list_lock);
3060 	/* Is commit writing out inode - we have to wait */
3061 	if (jinode->i_flags & JI_COMMIT_RUNNING) {
3062 		wait_queue_head_t *wq;
3063 		DEFINE_WAIT_BIT(wait, &jinode->i_flags, __JI_COMMIT_RUNNING);
3064 		wq = bit_waitqueue(&jinode->i_flags, __JI_COMMIT_RUNNING);
3065 		prepare_to_wait(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE);
3066 		spin_unlock(&journal->j_list_lock);
3067 		schedule();
3068 		finish_wait(wq, &wait.wq_entry);
3069 		goto restart;
3070 	}
3071 
3072 	if (jinode->i_transaction) {
3073 		list_del(&jinode->i_list);
3074 		jinode->i_transaction = NULL;
3075 	}
3076 	spin_unlock(&journal->j_list_lock);
3077 }
3078 
3079 
3080 #ifdef CONFIG_PROC_FS
3081 
3082 #define JBD2_STATS_PROC_NAME "fs/jbd2"
3083 
jbd2_create_jbd_stats_proc_entry(void)3084 static void __init jbd2_create_jbd_stats_proc_entry(void)
3085 {
3086 	proc_jbd2_stats = proc_mkdir(JBD2_STATS_PROC_NAME, NULL);
3087 }
3088 
jbd2_remove_jbd_stats_proc_entry(void)3089 static void __exit jbd2_remove_jbd_stats_proc_entry(void)
3090 {
3091 	if (proc_jbd2_stats)
3092 		remove_proc_entry(JBD2_STATS_PROC_NAME, NULL);
3093 }
3094 
3095 #else
3096 
3097 #define jbd2_create_jbd_stats_proc_entry() do {} while (0)
3098 #define jbd2_remove_jbd_stats_proc_entry() do {} while (0)
3099 
3100 #endif
3101 
3102 struct kmem_cache *jbd2_handle_cache, *jbd2_inode_cache;
3103 
jbd2_journal_init_inode_cache(void)3104 static int __init jbd2_journal_init_inode_cache(void)
3105 {
3106 	J_ASSERT(!jbd2_inode_cache);
3107 	jbd2_inode_cache = KMEM_CACHE(jbd2_inode, 0);
3108 	if (!jbd2_inode_cache) {
3109 		pr_emerg("JBD2: failed to create inode cache\n");
3110 		return -ENOMEM;
3111 	}
3112 	return 0;
3113 }
3114 
jbd2_journal_init_handle_cache(void)3115 static int __init jbd2_journal_init_handle_cache(void)
3116 {
3117 	J_ASSERT(!jbd2_handle_cache);
3118 	jbd2_handle_cache = KMEM_CACHE(jbd2_journal_handle, SLAB_TEMPORARY);
3119 	if (!jbd2_handle_cache) {
3120 		printk(KERN_EMERG "JBD2: failed to create handle cache\n");
3121 		return -ENOMEM;
3122 	}
3123 	return 0;
3124 }
3125 
jbd2_journal_destroy_inode_cache(void)3126 static void jbd2_journal_destroy_inode_cache(void)
3127 {
3128 	kmem_cache_destroy(jbd2_inode_cache);
3129 	jbd2_inode_cache = NULL;
3130 }
3131 
jbd2_journal_destroy_handle_cache(void)3132 static void jbd2_journal_destroy_handle_cache(void)
3133 {
3134 	kmem_cache_destroy(jbd2_handle_cache);
3135 	jbd2_handle_cache = NULL;
3136 }
3137 
3138 /*
3139  * Module startup and shutdown
3140  */
3141 
journal_init_caches(void)3142 static int __init journal_init_caches(void)
3143 {
3144 	int ret;
3145 
3146 	ret = jbd2_journal_init_revoke_record_cache();
3147 	if (ret == 0)
3148 		ret = jbd2_journal_init_revoke_table_cache();
3149 	if (ret == 0)
3150 		ret = jbd2_journal_init_journal_head_cache();
3151 	if (ret == 0)
3152 		ret = jbd2_journal_init_handle_cache();
3153 	if (ret == 0)
3154 		ret = jbd2_journal_init_inode_cache();
3155 	if (ret == 0)
3156 		ret = jbd2_journal_init_transaction_cache();
3157 	return ret;
3158 }
3159 
jbd2_journal_destroy_caches(void)3160 static void jbd2_journal_destroy_caches(void)
3161 {
3162 	jbd2_journal_destroy_revoke_record_cache();
3163 	jbd2_journal_destroy_revoke_table_cache();
3164 	jbd2_journal_destroy_journal_head_cache();
3165 	jbd2_journal_destroy_handle_cache();
3166 	jbd2_journal_destroy_inode_cache();
3167 	jbd2_journal_destroy_transaction_cache();
3168 	jbd2_journal_destroy_slabs();
3169 }
3170 
journal_init(void)3171 static int __init journal_init(void)
3172 {
3173 	int ret;
3174 
3175 	BUILD_BUG_ON(sizeof(struct journal_superblock_s) != 1024);
3176 
3177 	ret = journal_init_caches();
3178 	if (ret == 0) {
3179 		jbd2_create_jbd_stats_proc_entry();
3180 	} else {
3181 		jbd2_journal_destroy_caches();
3182 	}
3183 	return ret;
3184 }
3185 
journal_exit(void)3186 static void __exit journal_exit(void)
3187 {
3188 #ifdef CONFIG_JBD2_DEBUG
3189 	int n = atomic_read(&nr_journal_heads);
3190 	if (n)
3191 		printk(KERN_ERR "JBD2: leaked %d journal_heads!\n", n);
3192 #endif
3193 	jbd2_remove_jbd_stats_proc_entry();
3194 	jbd2_journal_destroy_caches();
3195 }
3196 
3197 MODULE_LICENSE("GPL");
3198 module_init(journal_init);
3199 module_exit(journal_exit);
3200 
3201