2 * linux/fs/jbd2/journal.c
4 * Written by Stephen C. Tweedie <sct@redhat.com>, 1998
6 * Copyright 1998 Red Hat corp --- All Rights Reserved
8 * This file is part of the Linux kernel and is made available under
9 * the terms of the GNU General Public License, version 2, or at your
10 * option, any later version, incorporated herein by reference.
12 * Generic filesystem journal-writing code; part of the ext2fs
15 * This file manages journals: areas of disk reserved for logging
16 * transactional updates. This includes the kernel journaling thread
17 * which is responsible for scheduling updates to the log.
19 * We do not actually manage the physical storage of the journal in this
20 * file: that is left to a per-journal policy function, which allows us
21 * to store the journal within a filesystem-specified area for ext2
22 * journaling (ext2 can use a reserved inode for storing the log).
25 #include <linux/module.h>
26 #include <linux/time.h>
28 #include <linux/jbd2.h>
29 #include <linux/errno.h>
30 #include <linux/slab.h>
31 #include <linux/init.h>
33 #include <linux/freezer.h>
34 #include <linux/pagemap.h>
35 #include <linux/kthread.h>
36 #include <linux/poison.h>
37 #include <linux/proc_fs.h>
38 #include <linux/debugfs.h>
39 #include <linux/seq_file.h>
40 #include <linux/math64.h>
41 #include <linux/hash.h>
43 #define CREATE_TRACE_POINTS
44 #include <trace/events/jbd2.h>
46 #include <asm/uaccess.h>
49 EXPORT_SYMBOL(jbd2_journal_start);
50 EXPORT_SYMBOL(jbd2_journal_restart);
51 EXPORT_SYMBOL(jbd2_journal_extend);
52 EXPORT_SYMBOL(jbd2_journal_stop);
53 EXPORT_SYMBOL(jbd2_journal_lock_updates);
54 EXPORT_SYMBOL(jbd2_journal_unlock_updates);
55 EXPORT_SYMBOL(jbd2_journal_get_write_access);
56 EXPORT_SYMBOL(jbd2_journal_get_create_access);
57 EXPORT_SYMBOL(jbd2_journal_get_undo_access);
58 EXPORT_SYMBOL(jbd2_journal_set_triggers);
59 EXPORT_SYMBOL(jbd2_journal_dirty_metadata);
60 EXPORT_SYMBOL(jbd2_journal_release_buffer);
61 EXPORT_SYMBOL(jbd2_journal_forget);
63 EXPORT_SYMBOL(journal_sync_buffer);
65 EXPORT_SYMBOL(jbd2_journal_flush);
66 EXPORT_SYMBOL(jbd2_journal_revoke);
68 EXPORT_SYMBOL(jbd2_journal_init_dev);
69 EXPORT_SYMBOL(jbd2_journal_init_inode);
70 EXPORT_SYMBOL(jbd2_journal_update_format);
71 EXPORT_SYMBOL(jbd2_journal_check_used_features);
72 EXPORT_SYMBOL(jbd2_journal_check_available_features);
73 EXPORT_SYMBOL(jbd2_journal_set_features);
74 EXPORT_SYMBOL(jbd2_journal_load);
75 EXPORT_SYMBOL(jbd2_journal_destroy);
76 EXPORT_SYMBOL(jbd2_journal_abort);
77 EXPORT_SYMBOL(jbd2_journal_errno);
78 EXPORT_SYMBOL(jbd2_journal_ack_err);
79 EXPORT_SYMBOL(jbd2_journal_clear_err);
80 EXPORT_SYMBOL(jbd2_log_wait_commit);
81 EXPORT_SYMBOL(jbd2_journal_start_commit);
82 EXPORT_SYMBOL(jbd2_journal_force_commit_nested);
83 EXPORT_SYMBOL(jbd2_journal_wipe);
84 EXPORT_SYMBOL(jbd2_journal_blocks_per_page);
85 EXPORT_SYMBOL(jbd2_journal_invalidatepage);
86 EXPORT_SYMBOL(jbd2_journal_try_to_free_buffers);
87 EXPORT_SYMBOL(jbd2_journal_force_commit);
88 EXPORT_SYMBOL(jbd2_journal_file_inode);
89 EXPORT_SYMBOL(jbd2_journal_init_jbd_inode);
90 EXPORT_SYMBOL(jbd2_journal_release_jbd_inode);
91 EXPORT_SYMBOL(jbd2_journal_begin_ordered_truncate);
93 static int journal_convert_superblock_v1(journal_t *, journal_superblock_t *);
94 static void __journal_abort_soft (journal_t *journal, int errno);
97 * Helper function used to manage commit timeouts
100 static void commit_timeout(unsigned long __data)
102 struct task_struct * p = (struct task_struct *) __data;
108 * kjournald2: The main thread function used to manage a logging device
111 * This kernel thread is responsible for two things:
113 * 1) COMMIT: Every so often we need to commit the current state of the
114 * filesystem to disk. The journal thread is responsible for writing
115 * all of the metadata buffers to disk.
117 * 2) CHECKPOINT: We cannot reuse a used section of the log file until all
118 * of the data in that part of the log has been rewritten elsewhere on
119 * the disk. Flushing these old buffers to reclaim space in the log is
120 * known as checkpointing, and this thread is responsible for that job.
123 static int kjournald2(void *arg)
125 journal_t *journal = arg;
126 transaction_t *transaction;
129 * Set up an interval timer which can be used to trigger a commit wakeup
130 * after the commit interval expires
132 setup_timer(&journal->j_commit_timer, commit_timeout,
133 (unsigned long)current);
135 /* Record that the journal thread is running */
136 journal->j_task = current;
137 wake_up(&journal->j_wait_done_commit);
140 * And now, wait forever for commit wakeup events.
142 spin_lock(&journal->j_state_lock);
145 if (journal->j_flags & JBD2_UNMOUNT)
148 jbd_debug(1, "commit_sequence=%d, commit_request=%d\n",
149 journal->j_commit_sequence, journal->j_commit_request);
151 if (journal->j_commit_sequence != journal->j_commit_request) {
152 jbd_debug(1, "OK, requests differ\n");
153 spin_unlock(&journal->j_state_lock);
154 del_timer_sync(&journal->j_commit_timer);
155 jbd2_journal_commit_transaction(journal);
156 spin_lock(&journal->j_state_lock);
160 wake_up(&journal->j_wait_done_commit);
161 if (freezing(current)) {
163 * The simpler the better. Flushing journal isn't a
164 * good idea, because that depends on threads that may
165 * be already stopped.
167 jbd_debug(1, "Now suspending kjournald2\n");
168 spin_unlock(&journal->j_state_lock);
170 spin_lock(&journal->j_state_lock);
173 * We assume on resume that commits are already there,
177 int should_sleep = 1;
179 prepare_to_wait(&journal->j_wait_commit, &wait,
181 if (journal->j_commit_sequence != journal->j_commit_request)
183 transaction = journal->j_running_transaction;
184 if (transaction && time_after_eq(jiffies,
185 transaction->t_expires))
187 if (journal->j_flags & JBD2_UNMOUNT)
190 spin_unlock(&journal->j_state_lock);
192 spin_lock(&journal->j_state_lock);
194 finish_wait(&journal->j_wait_commit, &wait);
197 jbd_debug(1, "kjournald2 wakes\n");
200 * Were we woken up by a commit wakeup event?
202 transaction = journal->j_running_transaction;
203 if (transaction && time_after_eq(jiffies, transaction->t_expires)) {
204 journal->j_commit_request = transaction->t_tid;
205 jbd_debug(1, "woke because of timeout\n");
210 spin_unlock(&journal->j_state_lock);
211 del_timer_sync(&journal->j_commit_timer);
212 journal->j_task = NULL;
213 wake_up(&journal->j_wait_done_commit);
214 jbd_debug(1, "Journal thread exiting.\n");
218 static int jbd2_journal_start_thread(journal_t *journal)
220 struct task_struct *t;
222 t = kthread_run(kjournald2, journal, "jbd2/%s",
227 wait_event(journal->j_wait_done_commit, journal->j_task != NULL);
231 static void journal_kill_thread(journal_t *journal)
233 spin_lock(&journal->j_state_lock);
234 journal->j_flags |= JBD2_UNMOUNT;
236 while (journal->j_task) {
237 wake_up(&journal->j_wait_commit);
238 spin_unlock(&journal->j_state_lock);
239 wait_event(journal->j_wait_done_commit, journal->j_task == NULL);
240 spin_lock(&journal->j_state_lock);
242 spin_unlock(&journal->j_state_lock);
246 * jbd2_journal_write_metadata_buffer: write a metadata buffer to the journal.
248 * Writes a metadata buffer to a given disk block. The actual IO is not
249 * performed but a new buffer_head is constructed which labels the data
250 * to be written with the correct destination disk block.
252 * Any magic-number escaping which needs to be done will cause a
253 * copy-out here. If the buffer happens to start with the
254 * JBD2_MAGIC_NUMBER, then we can't write it to the log directly: the
255 * magic number is only written to the log for descripter blocks. In
256 * this case, we copy the data and replace the first word with 0, and we
257 * return a result code which indicates that this buffer needs to be
258 * marked as an escaped buffer in the corresponding log descriptor
259 * block. The missing word can then be restored when the block is read
262 * If the source buffer has already been modified by a new transaction
263 * since we took the last commit snapshot, we use the frozen copy of
264 * that data for IO. If we end up using the existing buffer_head's data
265 * for the write, then we *have* to lock the buffer to prevent anyone
266 * else from using and possibly modifying it while the IO is in
269 * The function returns a pointer to the buffer_heads to be used for IO.
271 * We assume that the journal has already been locked in this function.
278 * Bit 0 set == escape performed on the data
279 * Bit 1 set == buffer copy-out performed (kfree the data after IO)
282 int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
283 struct journal_head *jh_in,
284 struct journal_head **jh_out,
285 unsigned long long blocknr)
287 int need_copy_out = 0;
288 int done_copy_out = 0;
291 struct buffer_head *new_bh;
292 struct journal_head *new_jh;
293 struct page *new_page;
294 unsigned int new_offset;
295 struct buffer_head *bh_in = jh2bh(jh_in);
296 struct jbd2_buffer_trigger_type *triggers;
297 journal_t *journal = transaction->t_journal;
300 * The buffer really shouldn't be locked: only the current committing
301 * transaction is allowed to write it, so nobody else is allowed
304 * akpm: except if we're journalling data, and write() output is
305 * also part of a shared mapping, and another thread has
306 * decided to launch a writepage() against this buffer.
308 J_ASSERT_BH(bh_in, buffer_jbddirty(bh_in));
310 new_bh = alloc_buffer_head(GFP_NOFS|__GFP_NOFAIL);
311 /* keep subsequent assertions sane */
313 init_buffer(new_bh, NULL, NULL);
314 atomic_set(&new_bh->b_count, 1);
315 new_jh = jbd2_journal_add_journal_head(new_bh); /* This sleeps */
318 * If a new transaction has already done a buffer copy-out, then
319 * we use that version of the data for the commit.
321 jbd_lock_bh_state(bh_in);
323 if (jh_in->b_frozen_data) {
325 new_page = virt_to_page(jh_in->b_frozen_data);
326 new_offset = offset_in_page(jh_in->b_frozen_data);
327 triggers = jh_in->b_frozen_triggers;
329 new_page = jh2bh(jh_in)->b_page;
330 new_offset = offset_in_page(jh2bh(jh_in)->b_data);
331 triggers = jh_in->b_triggers;
334 mapped_data = kmap_atomic(new_page, KM_USER0);
336 * Fire any commit trigger. Do this before checking for escaping,
337 * as the trigger may modify the magic offset. If a copy-out
338 * happens afterwards, it will have the correct data in the buffer.
340 jbd2_buffer_commit_trigger(jh_in, mapped_data + new_offset,
346 if (*((__be32 *)(mapped_data + new_offset)) ==
347 cpu_to_be32(JBD2_MAGIC_NUMBER)) {
351 kunmap_atomic(mapped_data, KM_USER0);
354 * Do we need to do a data copy?
356 if (need_copy_out && !done_copy_out) {
359 jbd_unlock_bh_state(bh_in);
360 tmp = jbd2_alloc(bh_in->b_size, GFP_NOFS);
361 jbd_lock_bh_state(bh_in);
362 if (jh_in->b_frozen_data) {
363 jbd2_free(tmp, bh_in->b_size);
367 jh_in->b_frozen_data = tmp;
368 mapped_data = kmap_atomic(new_page, KM_USER0);
369 memcpy(tmp, mapped_data + new_offset, jh2bh(jh_in)->b_size);
370 kunmap_atomic(mapped_data, KM_USER0);
372 new_page = virt_to_page(tmp);
373 new_offset = offset_in_page(tmp);
377 * This isn't strictly necessary, as we're using frozen
378 * data for the escaping, but it keeps consistency with
379 * b_frozen_data usage.
381 jh_in->b_frozen_triggers = jh_in->b_triggers;
385 * Did we need to do an escaping? Now we've done all the
386 * copying, we can finally do so.
389 mapped_data = kmap_atomic(new_page, KM_USER0);
390 *((unsigned int *)(mapped_data + new_offset)) = 0;
391 kunmap_atomic(mapped_data, KM_USER0);
394 set_bh_page(new_bh, new_page, new_offset);
395 new_jh->b_transaction = NULL;
396 new_bh->b_size = jh2bh(jh_in)->b_size;
397 new_bh->b_bdev = transaction->t_journal->j_dev;
398 new_bh->b_blocknr = blocknr;
399 set_buffer_mapped(new_bh);
400 set_buffer_dirty(new_bh);
405 * The to-be-written buffer needs to get moved to the io queue,
406 * and the original buffer whose contents we are shadowing or
407 * copying is moved to the transaction's shadow queue.
409 JBUFFER_TRACE(jh_in, "file as BJ_Shadow");
410 spin_lock(&journal->j_list_lock);
411 __jbd2_journal_file_buffer(jh_in, transaction, BJ_Shadow);
412 spin_unlock(&journal->j_list_lock);
413 jbd_unlock_bh_state(bh_in);
415 JBUFFER_TRACE(new_jh, "file as BJ_IO");
416 jbd2_journal_file_buffer(new_jh, transaction, BJ_IO);
418 return do_escape | (done_copy_out << 1);
422 * Allocation code for the journal file. Manage the space left in the
423 * journal, so that we can begin checkpointing when appropriate.
427 * __jbd2_log_space_left: Return the number of free blocks left in the journal.
429 * Called with the journal already locked.
431 * Called under j_state_lock
434 int __jbd2_log_space_left(journal_t *journal)
436 int left = journal->j_free;
438 assert_spin_locked(&journal->j_state_lock);
441 * Be pessimistic here about the number of those free blocks which
442 * might be required for log descriptor control blocks.
445 #define MIN_LOG_RESERVED_BLOCKS 32 /* Allow for rounding errors */
447 left -= MIN_LOG_RESERVED_BLOCKS;
456 * Called under j_state_lock. Returns true if a transaction commit was started.
458 int __jbd2_log_start_commit(journal_t *journal, tid_t target)
461 * Are we already doing a recent enough commit?
463 if (!tid_geq(journal->j_commit_request, target)) {
465 * We want a new commit: OK, mark the request and wakup the
466 * commit thread. We do _not_ do the commit ourselves.
469 journal->j_commit_request = target;
470 jbd_debug(1, "JBD: requesting commit %d/%d\n",
471 journal->j_commit_request,
472 journal->j_commit_sequence);
473 wake_up(&journal->j_wait_commit);
479 int jbd2_log_start_commit(journal_t *journal, tid_t tid)
483 spin_lock(&journal->j_state_lock);
484 ret = __jbd2_log_start_commit(journal, tid);
485 spin_unlock(&journal->j_state_lock);
490 * Force and wait upon a commit if the calling process is not within
491 * transaction. This is used for forcing out undo-protected data which contains
492 * bitmaps, when the fs is running out of space.
494 * We can only force the running transaction if we don't have an active handle;
495 * otherwise, we will deadlock.
497 * Returns true if a transaction was started.
499 int jbd2_journal_force_commit_nested(journal_t *journal)
501 transaction_t *transaction = NULL;
504 spin_lock(&journal->j_state_lock);
505 if (journal->j_running_transaction && !current->journal_info) {
506 transaction = journal->j_running_transaction;
507 __jbd2_log_start_commit(journal, transaction->t_tid);
508 } else if (journal->j_committing_transaction)
509 transaction = journal->j_committing_transaction;
512 spin_unlock(&journal->j_state_lock);
513 return 0; /* Nothing to retry */
516 tid = transaction->t_tid;
517 spin_unlock(&journal->j_state_lock);
518 jbd2_log_wait_commit(journal, tid);
523 * Start a commit of the current running transaction (if any). Returns true
524 * if a transaction is going to be committed (or is currently already
525 * committing), and fills its tid in at *ptid
527 int jbd2_journal_start_commit(journal_t *journal, tid_t *ptid)
531 spin_lock(&journal->j_state_lock);
532 if (journal->j_running_transaction) {
533 tid_t tid = journal->j_running_transaction->t_tid;
535 __jbd2_log_start_commit(journal, tid);
536 /* There's a running transaction and we've just made sure
537 * it's commit has been scheduled. */
541 } else if (journal->j_committing_transaction) {
543 * If ext3_write_super() recently started a commit, then we
544 * have to wait for completion of that transaction
547 *ptid = journal->j_committing_transaction->t_tid;
550 spin_unlock(&journal->j_state_lock);
555 * Wait for a specified commit to complete.
556 * The caller may not hold the journal lock.
558 int jbd2_log_wait_commit(journal_t *journal, tid_t tid)
562 #ifdef CONFIG_JBD2_DEBUG
563 spin_lock(&journal->j_state_lock);
564 if (!tid_geq(journal->j_commit_request, tid)) {
566 "%s: error: j_commit_request=%d, tid=%d\n",
567 __func__, journal->j_commit_request, tid);
569 spin_unlock(&journal->j_state_lock);
571 spin_lock(&journal->j_state_lock);
572 while (tid_gt(tid, journal->j_commit_sequence)) {
573 jbd_debug(1, "JBD: want %d, j_commit_sequence=%d\n",
574 tid, journal->j_commit_sequence);
575 wake_up(&journal->j_wait_commit);
576 spin_unlock(&journal->j_state_lock);
577 wait_event(journal->j_wait_done_commit,
578 !tid_gt(tid, journal->j_commit_sequence));
579 spin_lock(&journal->j_state_lock);
581 spin_unlock(&journal->j_state_lock);
583 if (unlikely(is_journal_aborted(journal))) {
584 printk(KERN_EMERG "journal commit I/O error\n");
591 * Log buffer allocation routines:
594 int jbd2_journal_next_log_block(journal_t *journal, unsigned long long *retp)
596 unsigned long blocknr;
598 spin_lock(&journal->j_state_lock);
599 J_ASSERT(journal->j_free > 1);
601 blocknr = journal->j_head;
604 if (journal->j_head == journal->j_last)
605 journal->j_head = journal->j_first;
606 spin_unlock(&journal->j_state_lock);
607 return jbd2_journal_bmap(journal, blocknr, retp);
611 * Conversion of logical to physical block numbers for the journal
613 * On external journals the journal blocks are identity-mapped, so
614 * this is a no-op. If needed, we can use j_blk_offset - everything is
617 int jbd2_journal_bmap(journal_t *journal, unsigned long blocknr,
618 unsigned long long *retp)
621 unsigned long long ret;
623 if (journal->j_inode) {
624 ret = bmap(journal->j_inode, blocknr);
628 printk(KERN_ALERT "%s: journal block not found "
629 "at offset %lu on %s\n",
630 __func__, blocknr, journal->j_devname);
632 __journal_abort_soft(journal, err);
635 *retp = blocknr; /* +journal->j_blk_offset */
641 * We play buffer_head aliasing tricks to write data/metadata blocks to
642 * the journal without copying their contents, but for journal
643 * descriptor blocks we do need to generate bona fide buffers.
645 * After the caller of jbd2_journal_get_descriptor_buffer() has finished modifying
646 * the buffer's contents they really should run flush_dcache_page(bh->b_page).
647 * But we don't bother doing that, so there will be coherency problems with
648 * mmaps of blockdevs which hold live JBD-controlled filesystems.
650 struct journal_head *jbd2_journal_get_descriptor_buffer(journal_t *journal)
652 struct buffer_head *bh;
653 unsigned long long blocknr;
656 err = jbd2_journal_next_log_block(journal, &blocknr);
661 bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
665 memset(bh->b_data, 0, journal->j_blocksize);
666 set_buffer_uptodate(bh);
668 BUFFER_TRACE(bh, "return this buffer");
669 return jbd2_journal_add_journal_head(bh);
672 struct jbd2_stats_proc_session {
674 struct transaction_stats_s *stats;
679 static void *jbd2_seq_info_start(struct seq_file *seq, loff_t *pos)
681 return *pos ? NULL : SEQ_START_TOKEN;
684 static void *jbd2_seq_info_next(struct seq_file *seq, void *v, loff_t *pos)
689 static int jbd2_seq_info_show(struct seq_file *seq, void *v)
691 struct jbd2_stats_proc_session *s = seq->private;
693 if (v != SEQ_START_TOKEN)
695 seq_printf(seq, "%lu transaction, each up to %u blocks\n",
697 s->journal->j_max_transaction_buffers);
698 if (s->stats->ts_tid == 0)
700 seq_printf(seq, "average: \n %ums waiting for transaction\n",
701 jiffies_to_msecs(s->stats->run.rs_wait / s->stats->ts_tid));
702 seq_printf(seq, " %ums running transaction\n",
703 jiffies_to_msecs(s->stats->run.rs_running / s->stats->ts_tid));
704 seq_printf(seq, " %ums transaction was being locked\n",
705 jiffies_to_msecs(s->stats->run.rs_locked / s->stats->ts_tid));
706 seq_printf(seq, " %ums flushing data (in ordered mode)\n",
707 jiffies_to_msecs(s->stats->run.rs_flushing / s->stats->ts_tid));
708 seq_printf(seq, " %ums logging transaction\n",
709 jiffies_to_msecs(s->stats->run.rs_logging / s->stats->ts_tid));
710 seq_printf(seq, " %lluus average transaction commit time\n",
711 div_u64(s->journal->j_average_commit_time, 1000));
712 seq_printf(seq, " %lu handles per transaction\n",
713 s->stats->run.rs_handle_count / s->stats->ts_tid);
714 seq_printf(seq, " %lu blocks per transaction\n",
715 s->stats->run.rs_blocks / s->stats->ts_tid);
716 seq_printf(seq, " %lu logged blocks per transaction\n",
717 s->stats->run.rs_blocks_logged / s->stats->ts_tid);
721 static void jbd2_seq_info_stop(struct seq_file *seq, void *v)
725 static const struct seq_operations jbd2_seq_info_ops = {
726 .start = jbd2_seq_info_start,
727 .next = jbd2_seq_info_next,
728 .stop = jbd2_seq_info_stop,
729 .show = jbd2_seq_info_show,
732 static int jbd2_seq_info_open(struct inode *inode, struct file *file)
734 journal_t *journal = PDE(inode)->data;
735 struct jbd2_stats_proc_session *s;
738 s = kmalloc(sizeof(*s), GFP_KERNEL);
741 size = sizeof(struct transaction_stats_s);
742 s->stats = kmalloc(size, GFP_KERNEL);
743 if (s->stats == NULL) {
747 spin_lock(&journal->j_history_lock);
748 memcpy(s->stats, &journal->j_stats, size);
749 s->journal = journal;
750 spin_unlock(&journal->j_history_lock);
752 rc = seq_open(file, &jbd2_seq_info_ops);
754 struct seq_file *m = file->private_data;
764 static int jbd2_seq_info_release(struct inode *inode, struct file *file)
766 struct seq_file *seq = file->private_data;
767 struct jbd2_stats_proc_session *s = seq->private;
770 return seq_release(inode, file);
773 static const struct file_operations jbd2_seq_info_fops = {
774 .owner = THIS_MODULE,
775 .open = jbd2_seq_info_open,
778 .release = jbd2_seq_info_release,
781 static struct proc_dir_entry *proc_jbd2_stats;
783 static void jbd2_stats_proc_init(journal_t *journal)
785 journal->j_proc_entry = proc_mkdir(journal->j_devname, proc_jbd2_stats);
786 if (journal->j_proc_entry) {
787 proc_create_data("info", S_IRUGO, journal->j_proc_entry,
788 &jbd2_seq_info_fops, journal);
792 static void jbd2_stats_proc_exit(journal_t *journal)
794 remove_proc_entry("info", journal->j_proc_entry);
795 remove_proc_entry(journal->j_devname, proc_jbd2_stats);
799 * Management for journal control blocks: functions to create and
800 * destroy journal_t structures, and to initialise and read existing
801 * journal blocks from disk. */
803 /* First: create and setup a journal_t object in memory. We initialise
804 * very few fields yet: that has to wait until we have created the
805 * journal structures from from scratch, or loaded them from disk. */
807 static journal_t * journal_init_common (void)
812 journal = kzalloc(sizeof(*journal), GFP_KERNEL|__GFP_NOFAIL);
816 init_waitqueue_head(&journal->j_wait_transaction_locked);
817 init_waitqueue_head(&journal->j_wait_logspace);
818 init_waitqueue_head(&journal->j_wait_done_commit);
819 init_waitqueue_head(&journal->j_wait_checkpoint);
820 init_waitqueue_head(&journal->j_wait_commit);
821 init_waitqueue_head(&journal->j_wait_updates);
822 mutex_init(&journal->j_barrier);
823 mutex_init(&journal->j_checkpoint_mutex);
824 spin_lock_init(&journal->j_revoke_lock);
825 spin_lock_init(&journal->j_list_lock);
826 spin_lock_init(&journal->j_state_lock);
828 journal->j_commit_interval = (HZ * JBD2_DEFAULT_MAX_COMMIT_AGE);
829 journal->j_min_batch_time = 0;
830 journal->j_max_batch_time = 15000; /* 15ms */
832 /* The journal is marked for error until we succeed with recovery! */
833 journal->j_flags = JBD2_ABORT;
835 /* Set up a default-sized revoke table for the new mount. */
836 err = jbd2_journal_init_revoke(journal, JOURNAL_REVOKE_DEFAULT_HASH);
842 spin_lock_init(&journal->j_history_lock);
849 /* jbd2_journal_init_dev and jbd2_journal_init_inode:
851 * Create a journal structure assigned some fixed set of disk blocks to
852 * the journal. We don't actually touch those disk blocks yet, but we
853 * need to set up all of the mapping information to tell the journaling
854 * system where the journal blocks are.
859 * journal_t * jbd2_journal_init_dev() - creates and initialises a journal structure
860 * @bdev: Block device on which to create the journal
861 * @fs_dev: Device which hold journalled filesystem for this journal.
862 * @start: Block nr Start of journal.
863 * @len: Length of the journal in blocks.
864 * @blocksize: blocksize of journalling device
866 * Returns: a newly created journal_t *
868 * jbd2_journal_init_dev creates a journal which maps a fixed contiguous
869 * range of blocks on an arbitrary block device.
872 journal_t * jbd2_journal_init_dev(struct block_device *bdev,
873 struct block_device *fs_dev,
874 unsigned long long start, int len, int blocksize)
876 journal_t *journal = journal_init_common();
877 struct buffer_head *bh;
884 /* journal descriptor can store up to n blocks -bzzz */
885 journal->j_blocksize = blocksize;
886 jbd2_stats_proc_init(journal);
887 n = journal->j_blocksize / sizeof(journal_block_tag_t);
888 journal->j_wbufsize = n;
889 journal->j_wbuf = kmalloc(n * sizeof(struct buffer_head*), GFP_KERNEL);
890 if (!journal->j_wbuf) {
891 printk(KERN_ERR "%s: Cant allocate bhs for commit thread\n",
895 journal->j_dev = bdev;
896 journal->j_fs_dev = fs_dev;
897 journal->j_blk_offset = start;
898 journal->j_maxlen = len;
899 bdevname(journal->j_dev, journal->j_devname);
900 p = journal->j_devname;
901 while ((p = strchr(p, '/')))
904 bh = __getblk(journal->j_dev, start, journal->j_blocksize);
907 "%s: Cannot get buffer for journal superblock\n",
911 journal->j_sb_buffer = bh;
912 journal->j_superblock = (journal_superblock_t *)bh->b_data;
916 kfree(journal->j_wbuf);
917 jbd2_stats_proc_exit(journal);
923 * journal_t * jbd2_journal_init_inode () - creates a journal which maps to a inode.
924 * @inode: An inode to create the journal in
926 * jbd2_journal_init_inode creates a journal which maps an on-disk inode as
927 * the journal. The inode must exist already, must support bmap() and
928 * must have all data blocks preallocated.
930 journal_t * jbd2_journal_init_inode (struct inode *inode)
932 struct buffer_head *bh;
933 journal_t *journal = journal_init_common();
937 unsigned long long blocknr;
942 journal->j_dev = journal->j_fs_dev = inode->i_sb->s_bdev;
943 journal->j_inode = inode;
944 bdevname(journal->j_dev, journal->j_devname);
945 p = journal->j_devname;
946 while ((p = strchr(p, '/')))
948 p = journal->j_devname + strlen(journal->j_devname);
949 sprintf(p, "-%lu", journal->j_inode->i_ino);
951 "journal %p: inode %s/%ld, size %Ld, bits %d, blksize %ld\n",
952 journal, inode->i_sb->s_id, inode->i_ino,
953 (long long) inode->i_size,
954 inode->i_sb->s_blocksize_bits, inode->i_sb->s_blocksize);
956 journal->j_maxlen = inode->i_size >> inode->i_sb->s_blocksize_bits;
957 journal->j_blocksize = inode->i_sb->s_blocksize;
958 jbd2_stats_proc_init(journal);
960 /* journal descriptor can store up to n blocks -bzzz */
961 n = journal->j_blocksize / sizeof(journal_block_tag_t);
962 journal->j_wbufsize = n;
963 journal->j_wbuf = kmalloc(n * sizeof(struct buffer_head*), GFP_KERNEL);
964 if (!journal->j_wbuf) {
965 printk(KERN_ERR "%s: Cant allocate bhs for commit thread\n",
970 err = jbd2_journal_bmap(journal, 0, &blocknr);
971 /* If that failed, give up */
973 printk(KERN_ERR "%s: Cannnot locate journal superblock\n",
978 bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
981 "%s: Cannot get buffer for journal superblock\n",
985 journal->j_sb_buffer = bh;
986 journal->j_superblock = (journal_superblock_t *)bh->b_data;
990 kfree(journal->j_wbuf);
991 jbd2_stats_proc_exit(journal);
997 * If the journal init or create aborts, we need to mark the journal
998 * superblock as being NULL to prevent the journal destroy from writing
999 * back a bogus superblock.
1001 static void journal_fail_superblock (journal_t *journal)
1003 struct buffer_head *bh = journal->j_sb_buffer;
1005 journal->j_sb_buffer = NULL;
1009 * Given a journal_t structure, initialise the various fields for
1010 * startup of a new journaling session. We use this both when creating
1011 * a journal, and after recovering an old journal to reset it for
1015 static int journal_reset(journal_t *journal)
1017 journal_superblock_t *sb = journal->j_superblock;
1018 unsigned long long first, last;
1020 first = be32_to_cpu(sb->s_first);
1021 last = be32_to_cpu(sb->s_maxlen);
1022 if (first + JBD2_MIN_JOURNAL_BLOCKS > last + 1) {
1023 printk(KERN_ERR "JBD: Journal too short (blocks %llu-%llu).\n",
1025 journal_fail_superblock(journal);
1029 journal->j_first = first;
1030 journal->j_last = last;
1032 journal->j_head = first;
1033 journal->j_tail = first;
1034 journal->j_free = last - first;
1036 journal->j_tail_sequence = journal->j_transaction_sequence;
1037 journal->j_commit_sequence = journal->j_transaction_sequence - 1;
1038 journal->j_commit_request = journal->j_commit_sequence;
1040 journal->j_max_transaction_buffers = journal->j_maxlen / 4;
1042 /* Add the dynamic fields and write it to disk. */
1043 jbd2_journal_update_superblock(journal, 1);
1044 return jbd2_journal_start_thread(journal);
1048 * void jbd2_journal_update_superblock() - Update journal sb on disk.
1049 * @journal: The journal to update.
1050 * @wait: Set to '0' if you don't want to wait for IO completion.
1052 * Update a journal's dynamic superblock fields and write it to disk,
1053 * optionally waiting for the IO to complete.
1055 void jbd2_journal_update_superblock(journal_t *journal, int wait)
1057 journal_superblock_t *sb = journal->j_superblock;
1058 struct buffer_head *bh = journal->j_sb_buffer;
1061 * As a special case, if the on-disk copy is already marked as needing
1062 * no recovery (s_start == 0) and there are no outstanding transactions
1063 * in the filesystem, then we can safely defer the superblock update
1064 * until the next commit by setting JBD2_FLUSHED. This avoids
1065 * attempting a write to a potential-readonly device.
1067 if (sb->s_start == 0 && journal->j_tail_sequence ==
1068 journal->j_transaction_sequence) {
1069 jbd_debug(1,"JBD: Skipping superblock update on recovered sb "
1070 "(start %ld, seq %d, errno %d)\n",
1071 journal->j_tail, journal->j_tail_sequence,
1076 if (buffer_write_io_error(bh)) {
1078 * Oh, dear. A previous attempt to write the journal
1079 * superblock failed. This could happen because the
1080 * USB device was yanked out. Or it could happen to
1081 * be a transient write error and maybe the block will
1082 * be remapped. Nothing we can do but to retry the
1083 * write and hope for the best.
1085 printk(KERN_ERR "JBD2: previous I/O error detected "
1086 "for journal superblock update for %s.\n",
1087 journal->j_devname);
1088 clear_buffer_write_io_error(bh);
1089 set_buffer_uptodate(bh);
1092 spin_lock(&journal->j_state_lock);
1093 jbd_debug(1,"JBD: updating superblock (start %ld, seq %d, errno %d)\n",
1094 journal->j_tail, journal->j_tail_sequence, journal->j_errno);
1096 sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);
1097 sb->s_start = cpu_to_be32(journal->j_tail);
1098 sb->s_errno = cpu_to_be32(journal->j_errno);
1099 spin_unlock(&journal->j_state_lock);
1101 BUFFER_TRACE(bh, "marking dirty");
1102 mark_buffer_dirty(bh);
1104 sync_dirty_buffer(bh);
1105 if (buffer_write_io_error(bh)) {
1106 printk(KERN_ERR "JBD2: I/O error detected "
1107 "when updating journal superblock for %s.\n",
1108 journal->j_devname);
1109 clear_buffer_write_io_error(bh);
1110 set_buffer_uptodate(bh);
1113 ll_rw_block(SWRITE, 1, &bh);
1116 /* If we have just flushed the log (by marking s_start==0), then
1117 * any future commit will have to be careful to update the
1118 * superblock again to re-record the true start of the log. */
1120 spin_lock(&journal->j_state_lock);
1122 journal->j_flags &= ~JBD2_FLUSHED;
1124 journal->j_flags |= JBD2_FLUSHED;
1125 spin_unlock(&journal->j_state_lock);
1129 * Read the superblock for a given journal, performing initial
1130 * validation of the format.
1133 static int journal_get_superblock(journal_t *journal)
1135 struct buffer_head *bh;
1136 journal_superblock_t *sb;
1139 bh = journal->j_sb_buffer;
1141 J_ASSERT(bh != NULL);
1142 if (!buffer_uptodate(bh)) {
1143 ll_rw_block(READ, 1, &bh);
1145 if (!buffer_uptodate(bh)) {
1147 "JBD: IO error reading journal superblock\n");
1152 sb = journal->j_superblock;
1156 if (sb->s_header.h_magic != cpu_to_be32(JBD2_MAGIC_NUMBER) ||
1157 sb->s_blocksize != cpu_to_be32(journal->j_blocksize)) {
1158 printk(KERN_WARNING "JBD: no valid journal superblock found\n");
1162 switch(be32_to_cpu(sb->s_header.h_blocktype)) {
1163 case JBD2_SUPERBLOCK_V1:
1164 journal->j_format_version = 1;
1166 case JBD2_SUPERBLOCK_V2:
1167 journal->j_format_version = 2;
1170 printk(KERN_WARNING "JBD: unrecognised superblock format ID\n");
1174 if (be32_to_cpu(sb->s_maxlen) < journal->j_maxlen)
1175 journal->j_maxlen = be32_to_cpu(sb->s_maxlen);
1176 else if (be32_to_cpu(sb->s_maxlen) > journal->j_maxlen) {
1177 printk (KERN_WARNING "JBD: journal file too short\n");
1184 journal_fail_superblock(journal);
1189 * Load the on-disk journal superblock and read the key fields into the
1193 static int load_superblock(journal_t *journal)
1196 journal_superblock_t *sb;
1198 err = journal_get_superblock(journal);
1202 sb = journal->j_superblock;
1204 journal->j_tail_sequence = be32_to_cpu(sb->s_sequence);
1205 journal->j_tail = be32_to_cpu(sb->s_start);
1206 journal->j_first = be32_to_cpu(sb->s_first);
1207 journal->j_last = be32_to_cpu(sb->s_maxlen);
1208 journal->j_errno = be32_to_cpu(sb->s_errno);
1215 * int jbd2_journal_load() - Read journal from disk.
1216 * @journal: Journal to act on.
1218 * Given a journal_t structure which tells us which disk blocks contain
1219 * a journal, read the journal from disk to initialise the in-memory
1222 int jbd2_journal_load(journal_t *journal)
1225 journal_superblock_t *sb;
1227 err = load_superblock(journal);
1231 sb = journal->j_superblock;
1232 /* If this is a V2 superblock, then we have to check the
1233 * features flags on it. */
1235 if (journal->j_format_version >= 2) {
1236 if ((sb->s_feature_ro_compat &
1237 ~cpu_to_be32(JBD2_KNOWN_ROCOMPAT_FEATURES)) ||
1238 (sb->s_feature_incompat &
1239 ~cpu_to_be32(JBD2_KNOWN_INCOMPAT_FEATURES))) {
1240 printk (KERN_WARNING
1241 "JBD: Unrecognised features on journal\n");
1246 /* Let the recovery code check whether it needs to recover any
1247 * data from the journal. */
1248 if (jbd2_journal_recover(journal))
1249 goto recovery_error;
1251 if (journal->j_failed_commit) {
1252 printk(KERN_ERR "JBD2: journal transaction %u on %s "
1253 "is corrupt.\n", journal->j_failed_commit,
1254 journal->j_devname);
1258 /* OK, we've finished with the dynamic journal bits:
1259 * reinitialise the dynamic contents of the superblock in memory
1260 * and reset them on disk. */
1261 if (journal_reset(journal))
1262 goto recovery_error;
1264 journal->j_flags &= ~JBD2_ABORT;
1265 journal->j_flags |= JBD2_LOADED;
1269 printk (KERN_WARNING "JBD: recovery failed\n");
1274 * void jbd2_journal_destroy() - Release a journal_t structure.
1275 * @journal: Journal to act on.
1277 * Release a journal_t structure once it is no longer in use by the
1279 * Return <0 if we couldn't clean up the journal.
1281 int jbd2_journal_destroy(journal_t *journal)
1285 /* Wait for the commit thread to wake up and die. */
1286 journal_kill_thread(journal);
1288 /* Force a final log commit */
1289 if (journal->j_running_transaction)
1290 jbd2_journal_commit_transaction(journal);
1292 /* Force any old transactions to disk */
1294 /* Totally anal locking here... */
1295 spin_lock(&journal->j_list_lock);
1296 while (journal->j_checkpoint_transactions != NULL) {
1297 spin_unlock(&journal->j_list_lock);
1298 mutex_lock(&journal->j_checkpoint_mutex);
1299 jbd2_log_do_checkpoint(journal);
1300 mutex_unlock(&journal->j_checkpoint_mutex);
1301 spin_lock(&journal->j_list_lock);
1304 J_ASSERT(journal->j_running_transaction == NULL);
1305 J_ASSERT(journal->j_committing_transaction == NULL);
1306 J_ASSERT(journal->j_checkpoint_transactions == NULL);
1307 spin_unlock(&journal->j_list_lock);
1309 if (journal->j_sb_buffer) {
1310 if (!is_journal_aborted(journal)) {
1311 /* We can now mark the journal as empty. */
1312 journal->j_tail = 0;
1313 journal->j_tail_sequence =
1314 ++journal->j_transaction_sequence;
1315 jbd2_journal_update_superblock(journal, 1);
1319 brelse(journal->j_sb_buffer);
1322 if (journal->j_proc_entry)
1323 jbd2_stats_proc_exit(journal);
1324 if (journal->j_inode)
1325 iput(journal->j_inode);
1326 if (journal->j_revoke)
1327 jbd2_journal_destroy_revoke(journal);
1328 kfree(journal->j_wbuf);
1336 *int jbd2_journal_check_used_features () - Check if features specified are used.
1337 * @journal: Journal to check.
1338 * @compat: bitmask of compatible features
1339 * @ro: bitmask of features that force read-only mount
1340 * @incompat: bitmask of incompatible features
1342 * Check whether the journal uses all of a given set of
1343 * features. Return true (non-zero) if it does.
1346 int jbd2_journal_check_used_features (journal_t *journal, unsigned long compat,
1347 unsigned long ro, unsigned long incompat)
1349 journal_superblock_t *sb;
1351 if (!compat && !ro && !incompat)
1353 if (journal->j_format_version == 1)
1356 sb = journal->j_superblock;
1358 if (((be32_to_cpu(sb->s_feature_compat) & compat) == compat) &&
1359 ((be32_to_cpu(sb->s_feature_ro_compat) & ro) == ro) &&
1360 ((be32_to_cpu(sb->s_feature_incompat) & incompat) == incompat))
1367 * int jbd2_journal_check_available_features() - Check feature set in journalling layer
1368 * @journal: Journal to check.
1369 * @compat: bitmask of compatible features
1370 * @ro: bitmask of features that force read-only mount
1371 * @incompat: bitmask of incompatible features
1373 * Check whether the journaling code supports the use of
1374 * all of a given set of features on this journal. Return true
1375 * (non-zero) if it can. */
1377 int jbd2_journal_check_available_features (journal_t *journal, unsigned long compat,
1378 unsigned long ro, unsigned long incompat)
1380 journal_superblock_t *sb;
1382 if (!compat && !ro && !incompat)
1385 sb = journal->j_superblock;
1387 /* We can support any known requested features iff the
1388 * superblock is in version 2. Otherwise we fail to support any
1389 * extended sb features. */
1391 if (journal->j_format_version != 2)
1394 if ((compat & JBD2_KNOWN_COMPAT_FEATURES) == compat &&
1395 (ro & JBD2_KNOWN_ROCOMPAT_FEATURES) == ro &&
1396 (incompat & JBD2_KNOWN_INCOMPAT_FEATURES) == incompat)
1403 * int jbd2_journal_set_features () - Mark a given journal feature in the superblock
1404 * @journal: Journal to act on.
1405 * @compat: bitmask of compatible features
1406 * @ro: bitmask of features that force read-only mount
1407 * @incompat: bitmask of incompatible features
1409 * Mark a given journal feature as present on the
1410 * superblock. Returns true if the requested features could be set.
1414 int jbd2_journal_set_features (journal_t *journal, unsigned long compat,
1415 unsigned long ro, unsigned long incompat)
1417 journal_superblock_t *sb;
1419 if (jbd2_journal_check_used_features(journal, compat, ro, incompat))
1422 if (!jbd2_journal_check_available_features(journal, compat, ro, incompat))
1425 jbd_debug(1, "Setting new features 0x%lx/0x%lx/0x%lx\n",
1426 compat, ro, incompat);
1428 sb = journal->j_superblock;
1430 sb->s_feature_compat |= cpu_to_be32(compat);
1431 sb->s_feature_ro_compat |= cpu_to_be32(ro);
1432 sb->s_feature_incompat |= cpu_to_be32(incompat);
1438 * jbd2_journal_clear_features () - Clear a given journal feature in the
1440 * @journal: Journal to act on.
1441 * @compat: bitmask of compatible features
1442 * @ro: bitmask of features that force read-only mount
1443 * @incompat: bitmask of incompatible features
1445 * Clear a given journal feature as present on the
1448 void jbd2_journal_clear_features(journal_t *journal, unsigned long compat,
1449 unsigned long ro, unsigned long incompat)
1451 journal_superblock_t *sb;
1453 jbd_debug(1, "Clear features 0x%lx/0x%lx/0x%lx\n",
1454 compat, ro, incompat);
1456 sb = journal->j_superblock;
1458 sb->s_feature_compat &= ~cpu_to_be32(compat);
1459 sb->s_feature_ro_compat &= ~cpu_to_be32(ro);
1460 sb->s_feature_incompat &= ~cpu_to_be32(incompat);
1462 EXPORT_SYMBOL(jbd2_journal_clear_features);
1465 * int jbd2_journal_update_format () - Update on-disk journal structure.
1466 * @journal: Journal to act on.
1468 * Given an initialised but unloaded journal struct, poke about in the
1469 * on-disk structure to update it to the most recent supported version.
1471 int jbd2_journal_update_format (journal_t *journal)
1473 journal_superblock_t *sb;
1476 err = journal_get_superblock(journal);
1480 sb = journal->j_superblock;
1482 switch (be32_to_cpu(sb->s_header.h_blocktype)) {
1483 case JBD2_SUPERBLOCK_V2:
1485 case JBD2_SUPERBLOCK_V1:
1486 return journal_convert_superblock_v1(journal, sb);
1493 static int journal_convert_superblock_v1(journal_t *journal,
1494 journal_superblock_t *sb)
1496 int offset, blocksize;
1497 struct buffer_head *bh;
1500 "JBD: Converting superblock from version 1 to 2.\n");
1502 /* Pre-initialise new fields to zero */
1503 offset = ((char *) &(sb->s_feature_compat)) - ((char *) sb);
1504 blocksize = be32_to_cpu(sb->s_blocksize);
1505 memset(&sb->s_feature_compat, 0, blocksize-offset);
1507 sb->s_nr_users = cpu_to_be32(1);
1508 sb->s_header.h_blocktype = cpu_to_be32(JBD2_SUPERBLOCK_V2);
1509 journal->j_format_version = 2;
1511 bh = journal->j_sb_buffer;
1512 BUFFER_TRACE(bh, "marking dirty");
1513 mark_buffer_dirty(bh);
1514 sync_dirty_buffer(bh);
1520 * int jbd2_journal_flush () - Flush journal
1521 * @journal: Journal to act on.
1523 * Flush all data for a given journal to disk and empty the journal.
1524 * Filesystems can use this when remounting readonly to ensure that
1525 * recovery does not need to happen on remount.
1528 int jbd2_journal_flush(journal_t *journal)
1531 transaction_t *transaction = NULL;
1532 unsigned long old_tail;
1534 spin_lock(&journal->j_state_lock);
1536 /* Force everything buffered to the log... */
1537 if (journal->j_running_transaction) {
1538 transaction = journal->j_running_transaction;
1539 __jbd2_log_start_commit(journal, transaction->t_tid);
1540 } else if (journal->j_committing_transaction)
1541 transaction = journal->j_committing_transaction;
1543 /* Wait for the log commit to complete... */
1545 tid_t tid = transaction->t_tid;
1547 spin_unlock(&journal->j_state_lock);
1548 jbd2_log_wait_commit(journal, tid);
1550 spin_unlock(&journal->j_state_lock);
1553 /* ...and flush everything in the log out to disk. */
1554 spin_lock(&journal->j_list_lock);
1555 while (!err && journal->j_checkpoint_transactions != NULL) {
1556 spin_unlock(&journal->j_list_lock);
1557 mutex_lock(&journal->j_checkpoint_mutex);
1558 err = jbd2_log_do_checkpoint(journal);
1559 mutex_unlock(&journal->j_checkpoint_mutex);
1560 spin_lock(&journal->j_list_lock);
1562 spin_unlock(&journal->j_list_lock);
1564 if (is_journal_aborted(journal))
1567 jbd2_cleanup_journal_tail(journal);
1569 /* Finally, mark the journal as really needing no recovery.
1570 * This sets s_start==0 in the underlying superblock, which is
1571 * the magic code for a fully-recovered superblock. Any future
1572 * commits of data to the journal will restore the current
1574 spin_lock(&journal->j_state_lock);
1575 old_tail = journal->j_tail;
1576 journal->j_tail = 0;
1577 spin_unlock(&journal->j_state_lock);
1578 jbd2_journal_update_superblock(journal, 1);
1579 spin_lock(&journal->j_state_lock);
1580 journal->j_tail = old_tail;
1582 J_ASSERT(!journal->j_running_transaction);
1583 J_ASSERT(!journal->j_committing_transaction);
1584 J_ASSERT(!journal->j_checkpoint_transactions);
1585 J_ASSERT(journal->j_head == journal->j_tail);
1586 J_ASSERT(journal->j_tail_sequence == journal->j_transaction_sequence);
1587 spin_unlock(&journal->j_state_lock);
1592 * int jbd2_journal_wipe() - Wipe journal contents
1593 * @journal: Journal to act on.
1594 * @write: flag (see below)
1596 * Wipe out all of the contents of a journal, safely. This will produce
1597 * a warning if the journal contains any valid recovery information.
1598 * Must be called between journal_init_*() and jbd2_journal_load().
1600 * If 'write' is non-zero, then we wipe out the journal on disk; otherwise
1601 * we merely suppress recovery.
1604 int jbd2_journal_wipe(journal_t *journal, int write)
1606 journal_superblock_t *sb;
1609 J_ASSERT (!(journal->j_flags & JBD2_LOADED));
1611 err = load_superblock(journal);
1615 sb = journal->j_superblock;
1617 if (!journal->j_tail)
1620 printk (KERN_WARNING "JBD: %s recovery information on journal\n",
1621 write ? "Clearing" : "Ignoring");
1623 err = jbd2_journal_skip_recovery(journal);
1625 jbd2_journal_update_superblock(journal, 1);
1632 * Journal abort has very specific semantics, which we describe
1633 * for journal abort.
1635 * Two internal functions, which provide abort to the jbd layer
1640 * Quick version for internal journal use (doesn't lock the journal).
1641 * Aborts hard --- we mark the abort as occurred, but do _nothing_ else,
1642 * and don't attempt to make any other journal updates.
1644 void __jbd2_journal_abort_hard(journal_t *journal)
1646 transaction_t *transaction;
1648 if (journal->j_flags & JBD2_ABORT)
1651 printk(KERN_ERR "Aborting journal on device %s.\n",
1652 journal->j_devname);
1654 spin_lock(&journal->j_state_lock);
1655 journal->j_flags |= JBD2_ABORT;
1656 transaction = journal->j_running_transaction;
1658 __jbd2_log_start_commit(journal, transaction->t_tid);
1659 spin_unlock(&journal->j_state_lock);
1662 /* Soft abort: record the abort error status in the journal superblock,
1663 * but don't do any other IO. */
1664 static void __journal_abort_soft (journal_t *journal, int errno)
1666 if (journal->j_flags & JBD2_ABORT)
1669 if (!journal->j_errno)
1670 journal->j_errno = errno;
1672 __jbd2_journal_abort_hard(journal);
1675 jbd2_journal_update_superblock(journal, 1);
1679 * void jbd2_journal_abort () - Shutdown the journal immediately.
1680 * @journal: the journal to shutdown.
1681 * @errno: an error number to record in the journal indicating
1682 * the reason for the shutdown.
1684 * Perform a complete, immediate shutdown of the ENTIRE
1685 * journal (not of a single transaction). This operation cannot be
1686 * undone without closing and reopening the journal.
1688 * The jbd2_journal_abort function is intended to support higher level error
1689 * recovery mechanisms such as the ext2/ext3 remount-readonly error
1692 * Journal abort has very specific semantics. Any existing dirty,
1693 * unjournaled buffers in the main filesystem will still be written to
1694 * disk by bdflush, but the journaling mechanism will be suspended
1695 * immediately and no further transaction commits will be honoured.
1697 * Any dirty, journaled buffers will be written back to disk without
1698 * hitting the journal. Atomicity cannot be guaranteed on an aborted
1699 * filesystem, but we _do_ attempt to leave as much data as possible
1700 * behind for fsck to use for cleanup.
1702 * Any attempt to get a new transaction handle on a journal which is in
1703 * ABORT state will just result in an -EROFS error return. A
1704 * jbd2_journal_stop on an existing handle will return -EIO if we have
1705 * entered abort state during the update.
1707 * Recursive transactions are not disturbed by journal abort until the
1708 * final jbd2_journal_stop, which will receive the -EIO error.
1710 * Finally, the jbd2_journal_abort call allows the caller to supply an errno
1711 * which will be recorded (if possible) in the journal superblock. This
1712 * allows a client to record failure conditions in the middle of a
1713 * transaction without having to complete the transaction to record the
1714 * failure to disk. ext3_error, for example, now uses this
1717 * Errors which originate from within the journaling layer will NOT
1718 * supply an errno; a null errno implies that absolutely no further
1719 * writes are done to the journal (unless there are any already in
1724 void jbd2_journal_abort(journal_t *journal, int errno)
1726 __journal_abort_soft(journal, errno);
1730 * int jbd2_journal_errno () - returns the journal's error state.
1731 * @journal: journal to examine.
1733 * This is the errno number set with jbd2_journal_abort(), the last
1734 * time the journal was mounted - if the journal was stopped
1735 * without calling abort this will be 0.
1737 * If the journal has been aborted on this mount time -EROFS will
1740 int jbd2_journal_errno(journal_t *journal)
1744 spin_lock(&journal->j_state_lock);
1745 if (journal->j_flags & JBD2_ABORT)
1748 err = journal->j_errno;
1749 spin_unlock(&journal->j_state_lock);
1754 * int jbd2_journal_clear_err () - clears the journal's error state
1755 * @journal: journal to act on.
1757 * An error must be cleared or acked to take a FS out of readonly
1760 int jbd2_journal_clear_err(journal_t *journal)
1764 spin_lock(&journal->j_state_lock);
1765 if (journal->j_flags & JBD2_ABORT)
1768 journal->j_errno = 0;
1769 spin_unlock(&journal->j_state_lock);
1774 * void jbd2_journal_ack_err() - Ack journal err.
1775 * @journal: journal to act on.
1777 * An error must be cleared or acked to take a FS out of readonly
1780 void jbd2_journal_ack_err(journal_t *journal)
1782 spin_lock(&journal->j_state_lock);
1783 if (journal->j_errno)
1784 journal->j_flags |= JBD2_ACK_ERR;
1785 spin_unlock(&journal->j_state_lock);
1788 int jbd2_journal_blocks_per_page(struct inode *inode)
1790 return 1 << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
1794 * helper functions to deal with 32 or 64bit block numbers.
1796 size_t journal_tag_bytes(journal_t *journal)
1798 if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_64BIT))
1799 return JBD2_TAG_SIZE64;
1801 return JBD2_TAG_SIZE32;
1805 * Journal_head storage management
1807 static struct kmem_cache *jbd2_journal_head_cache;
1808 #ifdef CONFIG_JBD2_DEBUG
1809 static atomic_t nr_journal_heads = ATOMIC_INIT(0);
1812 static int journal_init_jbd2_journal_head_cache(void)
1816 J_ASSERT(jbd2_journal_head_cache == NULL);
1817 jbd2_journal_head_cache = kmem_cache_create("jbd2_journal_head",
1818 sizeof(struct journal_head),
1820 SLAB_TEMPORARY, /* flags */
1823 if (!jbd2_journal_head_cache) {
1825 printk(KERN_EMERG "JBD: no memory for journal_head cache\n");
1830 static void jbd2_journal_destroy_jbd2_journal_head_cache(void)
1832 if (jbd2_journal_head_cache) {
1833 kmem_cache_destroy(jbd2_journal_head_cache);
1834 jbd2_journal_head_cache = NULL;
1839 * journal_head splicing and dicing
1841 static struct journal_head *journal_alloc_journal_head(void)
1843 struct journal_head *ret;
1844 static unsigned long last_warning;
1846 #ifdef CONFIG_JBD2_DEBUG
1847 atomic_inc(&nr_journal_heads);
1849 ret = kmem_cache_alloc(jbd2_journal_head_cache, GFP_NOFS);
1851 jbd_debug(1, "out of memory for journal_head\n");
1852 if (time_after(jiffies, last_warning + 5*HZ)) {
1853 printk(KERN_NOTICE "ENOMEM in %s, retrying.\n",
1855 last_warning = jiffies;
1859 ret = kmem_cache_alloc(jbd2_journal_head_cache, GFP_NOFS);
1865 static void journal_free_journal_head(struct journal_head *jh)
1867 #ifdef CONFIG_JBD2_DEBUG
1868 atomic_dec(&nr_journal_heads);
1869 memset(jh, JBD2_POISON_FREE, sizeof(*jh));
1871 kmem_cache_free(jbd2_journal_head_cache, jh);
1875 * A journal_head is attached to a buffer_head whenever JBD has an
1876 * interest in the buffer.
1878 * Whenever a buffer has an attached journal_head, its ->b_state:BH_JBD bit
1879 * is set. This bit is tested in core kernel code where we need to take
1880 * JBD-specific actions. Testing the zeroness of ->b_private is not reliable
1883 * When a buffer has its BH_JBD bit set, its ->b_count is elevated by one.
1885 * When a buffer has its BH_JBD bit set it is immune from being released by
1886 * core kernel code, mainly via ->b_count.
1888 * A journal_head may be detached from its buffer_head when the journal_head's
1889 * b_transaction, b_cp_transaction and b_next_transaction pointers are NULL.
1890 * Various places in JBD call jbd2_journal_remove_journal_head() to indicate that the
1891 * journal_head can be dropped if needed.
1893 * Various places in the kernel want to attach a journal_head to a buffer_head
1894 * _before_ attaching the journal_head to a transaction. To protect the
1895 * journal_head in this situation, jbd2_journal_add_journal_head elevates the
1896 * journal_head's b_jcount refcount by one. The caller must call
1897 * jbd2_journal_put_journal_head() to undo this.
1899 * So the typical usage would be:
1901 * (Attach a journal_head if needed. Increments b_jcount)
1902 * struct journal_head *jh = jbd2_journal_add_journal_head(bh);
1904 * jh->b_transaction = xxx;
1905 * jbd2_journal_put_journal_head(jh);
1907 * Now, the journal_head's b_jcount is zero, but it is safe from being released
1908 * because it has a non-zero b_transaction.
1912 * Give a buffer_head a journal_head.
1914 * Doesn't need the journal lock.
1917 struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh)
1919 struct journal_head *jh;
1920 struct journal_head *new_jh = NULL;
1923 if (!buffer_jbd(bh)) {
1924 new_jh = journal_alloc_journal_head();
1925 memset(new_jh, 0, sizeof(*new_jh));
1928 jbd_lock_bh_journal_head(bh);
1929 if (buffer_jbd(bh)) {
1933 (atomic_read(&bh->b_count) > 0) ||
1934 (bh->b_page && bh->b_page->mapping));
1937 jbd_unlock_bh_journal_head(bh);
1942 new_jh = NULL; /* We consumed it */
1947 BUFFER_TRACE(bh, "added journal_head");
1950 jbd_unlock_bh_journal_head(bh);
1952 journal_free_journal_head(new_jh);
1953 return bh->b_private;
1957 * Grab a ref against this buffer_head's journal_head. If it ended up not
1958 * having a journal_head, return NULL
1960 struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh)
1962 struct journal_head *jh = NULL;
1964 jbd_lock_bh_journal_head(bh);
1965 if (buffer_jbd(bh)) {
1969 jbd_unlock_bh_journal_head(bh);
1973 static void __journal_remove_journal_head(struct buffer_head *bh)
1975 struct journal_head *jh = bh2jh(bh);
1977 J_ASSERT_JH(jh, jh->b_jcount >= 0);
1980 if (jh->b_jcount == 0) {
1981 if (jh->b_transaction == NULL &&
1982 jh->b_next_transaction == NULL &&
1983 jh->b_cp_transaction == NULL) {
1984 J_ASSERT_JH(jh, jh->b_jlist == BJ_None);
1985 J_ASSERT_BH(bh, buffer_jbd(bh));
1986 J_ASSERT_BH(bh, jh2bh(jh) == bh);
1987 BUFFER_TRACE(bh, "remove journal_head");
1988 if (jh->b_frozen_data) {
1989 printk(KERN_WARNING "%s: freeing "
1992 jbd2_free(jh->b_frozen_data, bh->b_size);
1994 if (jh->b_committed_data) {
1995 printk(KERN_WARNING "%s: freeing "
1996 "b_committed_data\n",
1998 jbd2_free(jh->b_committed_data, bh->b_size);
2000 bh->b_private = NULL;
2001 jh->b_bh = NULL; /* debug, really */
2002 clear_buffer_jbd(bh);
2004 journal_free_journal_head(jh);
2006 BUFFER_TRACE(bh, "journal_head was locked");
2012 * jbd2_journal_remove_journal_head(): if the buffer isn't attached to a transaction
2013 * and has a zero b_jcount then remove and release its journal_head. If we did
2014 * see that the buffer is not used by any transaction we also "logically"
2015 * decrement ->b_count.
2017 * We in fact take an additional increment on ->b_count as a convenience,
2018 * because the caller usually wants to do additional things with the bh
2019 * after calling here.
2020 * The caller of jbd2_journal_remove_journal_head() *must* run __brelse(bh) at some
2021 * time. Once the caller has run __brelse(), the buffer is eligible for
2022 * reaping by try_to_free_buffers().
2024 void jbd2_journal_remove_journal_head(struct buffer_head *bh)
2026 jbd_lock_bh_journal_head(bh);
2027 __journal_remove_journal_head(bh);
2028 jbd_unlock_bh_journal_head(bh);
2032 * Drop a reference on the passed journal_head. If it fell to zero then try to
2033 * release the journal_head from the buffer_head.
2035 void jbd2_journal_put_journal_head(struct journal_head *jh)
2037 struct buffer_head *bh = jh2bh(jh);
2039 jbd_lock_bh_journal_head(bh);
2040 J_ASSERT_JH(jh, jh->b_jcount > 0);
2042 if (!jh->b_jcount && !jh->b_transaction) {
2043 __journal_remove_journal_head(bh);
2046 jbd_unlock_bh_journal_head(bh);
2050 * Initialize jbd inode head
2052 void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode)
2054 jinode->i_transaction = NULL;
2055 jinode->i_next_transaction = NULL;
2056 jinode->i_vfs_inode = inode;
2057 jinode->i_flags = 0;
2058 INIT_LIST_HEAD(&jinode->i_list);
2062 * Function to be called before we start removing inode from memory (i.e.,
2063 * clear_inode() is a fine place to be called from). It removes inode from
2064 * transaction's lists.
2066 void jbd2_journal_release_jbd_inode(journal_t *journal,
2067 struct jbd2_inode *jinode)
2074 spin_lock(&journal->j_list_lock);
2075 /* Is commit writing out inode - we have to wait */
2076 if (jinode->i_flags & JI_COMMIT_RUNNING) {
2077 wait_queue_head_t *wq;
2078 DEFINE_WAIT_BIT(wait, &jinode->i_flags, __JI_COMMIT_RUNNING);
2079 wq = bit_waitqueue(&jinode->i_flags, __JI_COMMIT_RUNNING);
2080 prepare_to_wait(wq, &wait.wait, TASK_UNINTERRUPTIBLE);
2081 spin_unlock(&journal->j_list_lock);
2083 finish_wait(wq, &wait.wait);
2087 /* Do we need to wait for data writeback? */
2088 if (journal->j_committing_transaction == jinode->i_transaction)
2090 if (jinode->i_transaction) {
2091 list_del(&jinode->i_list);
2092 jinode->i_transaction = NULL;
2094 spin_unlock(&journal->j_list_lock);
2100 #ifdef CONFIG_JBD2_DEBUG
2101 u8 jbd2_journal_enable_debug __read_mostly;
2102 EXPORT_SYMBOL(jbd2_journal_enable_debug);
2104 #define JBD2_DEBUG_NAME "jbd2-debug"
2106 static struct dentry *jbd2_debugfs_dir;
2107 static struct dentry *jbd2_debug;
2109 static void __init jbd2_create_debugfs_entry(void)
2111 jbd2_debugfs_dir = debugfs_create_dir("jbd2", NULL);
2112 if (jbd2_debugfs_dir)
2113 jbd2_debug = debugfs_create_u8(JBD2_DEBUG_NAME, S_IRUGO,
2115 &jbd2_journal_enable_debug);
2118 static void __exit jbd2_remove_debugfs_entry(void)
2120 debugfs_remove(jbd2_debug);
2121 debugfs_remove(jbd2_debugfs_dir);
2126 static void __init jbd2_create_debugfs_entry(void)
2130 static void __exit jbd2_remove_debugfs_entry(void)
2136 #ifdef CONFIG_PROC_FS
2138 #define JBD2_STATS_PROC_NAME "fs/jbd2"
2140 static void __init jbd2_create_jbd_stats_proc_entry(void)
2142 proc_jbd2_stats = proc_mkdir(JBD2_STATS_PROC_NAME, NULL);
2145 static void __exit jbd2_remove_jbd_stats_proc_entry(void)
2147 if (proc_jbd2_stats)
2148 remove_proc_entry(JBD2_STATS_PROC_NAME, NULL);
2153 #define jbd2_create_jbd_stats_proc_entry() do {} while (0)
2154 #define jbd2_remove_jbd_stats_proc_entry() do {} while (0)
2158 struct kmem_cache *jbd2_handle_cache;
2160 static int __init journal_init_handle_cache(void)
2162 jbd2_handle_cache = kmem_cache_create("jbd2_journal_handle",
2165 SLAB_TEMPORARY, /* flags */
2167 if (jbd2_handle_cache == NULL) {
2168 printk(KERN_EMERG "JBD: failed to create handle cache\n");
2174 static void jbd2_journal_destroy_handle_cache(void)
2176 if (jbd2_handle_cache)
2177 kmem_cache_destroy(jbd2_handle_cache);
2181 * Module startup and shutdown
2184 static int __init journal_init_caches(void)
2188 ret = jbd2_journal_init_revoke_caches();
2190 ret = journal_init_jbd2_journal_head_cache();
2192 ret = journal_init_handle_cache();
2196 static void jbd2_journal_destroy_caches(void)
2198 jbd2_journal_destroy_revoke_caches();
2199 jbd2_journal_destroy_jbd2_journal_head_cache();
2200 jbd2_journal_destroy_handle_cache();
2203 static int __init journal_init(void)
2207 BUILD_BUG_ON(sizeof(struct journal_superblock_s) != 1024);
2209 ret = journal_init_caches();
2211 jbd2_create_debugfs_entry();
2212 jbd2_create_jbd_stats_proc_entry();
2214 jbd2_journal_destroy_caches();
2219 static void __exit journal_exit(void)
2221 #ifdef CONFIG_JBD2_DEBUG
2222 int n = atomic_read(&nr_journal_heads);
2224 printk(KERN_EMERG "JBD: leaked %d journal_heads!\n", n);
2226 jbd2_remove_debugfs_entry();
2227 jbd2_remove_jbd_stats_proc_entry();
2228 jbd2_journal_destroy_caches();
2232 * jbd2_dev_to_name is a utility function used by the jbd2 and ext4
2233 * tracing infrastructure to map a dev_t to a device name.
2235 * The caller should use rcu_read_lock() in order to make sure the
2236 * device name stays valid until its done with it. We use
2237 * rcu_read_lock() as well to make sure we're safe in case the caller
2238 * gets sloppy, and because rcu_read_lock() is cheap and can be safely
2241 struct devname_cache {
2242 struct rcu_head rcu;
2244 char devname[BDEVNAME_SIZE];
2246 #define CACHE_SIZE_BITS 6
2247 static struct devname_cache *devcache[1 << CACHE_SIZE_BITS];
2248 static DEFINE_SPINLOCK(devname_cache_lock);
2250 static void free_devcache(struct rcu_head *rcu)
2255 const char *jbd2_dev_to_name(dev_t device)
2257 int i = hash_32(device, CACHE_SIZE_BITS);
2259 struct block_device *bd;
2260 static struct devname_cache *new_dev;
2263 if (devcache[i] && devcache[i]->device == device) {
2264 ret = devcache[i]->devname;
2270 new_dev = kmalloc(sizeof(struct devname_cache), GFP_KERNEL);
2272 return "NODEV-ALLOCFAILURE"; /* Something non-NULL */
2273 spin_lock(&devname_cache_lock);
2275 if (devcache[i]->device == device) {
2277 ret = devcache[i]->devname;
2278 spin_unlock(&devname_cache_lock);
2281 call_rcu(&devcache[i]->rcu, free_devcache);
2283 devcache[i] = new_dev;
2284 devcache[i]->device = device;
2287 bdevname(bd, devcache[i]->devname);
2290 __bdevname(device, devcache[i]->devname);
2291 ret = devcache[i]->devname;
2292 spin_unlock(&devname_cache_lock);
2295 EXPORT_SYMBOL(jbd2_dev_to_name);
2297 MODULE_LICENSE("GPL");
2298 module_init(journal_init);
2299 module_exit(journal_exit);