1f5166768STheodore Ts'o // SPDX-License-Identifier: GPL-2.0+ 2470decc6SDave Kleikamp /* 3f7f4bccbSMingming Cao * linux/fs/jbd2/journal.c 4470decc6SDave Kleikamp * 5470decc6SDave Kleikamp * Written by Stephen C. Tweedie <sct@redhat.com>, 1998 6470decc6SDave Kleikamp * 7470decc6SDave Kleikamp * Copyright 1998 Red Hat corp --- All Rights Reserved 8470decc6SDave Kleikamp * 9470decc6SDave Kleikamp * Generic filesystem journal-writing code; part of the ext2fs 10470decc6SDave Kleikamp * journaling system. 11470decc6SDave Kleikamp * 12470decc6SDave Kleikamp * This file manages journals: areas of disk reserved for logging 13470decc6SDave Kleikamp * transactional updates. This includes the kernel journaling thread 14470decc6SDave Kleikamp * which is responsible for scheduling updates to the log. 15470decc6SDave Kleikamp * 16470decc6SDave Kleikamp * We do not actually manage the physical storage of the journal in this 17470decc6SDave Kleikamp * file: that is left to a per-journal policy function, which allows us 18470decc6SDave Kleikamp * to store the journal within a filesystem-specified area for ext2 19470decc6SDave Kleikamp * journaling (ext2 can use a reserved inode for storing the log). 20470decc6SDave Kleikamp */ 21470decc6SDave Kleikamp 22470decc6SDave Kleikamp #include <linux/module.h> 23470decc6SDave Kleikamp #include <linux/time.h> 24470decc6SDave Kleikamp #include <linux/fs.h> 25f7f4bccbSMingming Cao #include <linux/jbd2.h> 26470decc6SDave Kleikamp #include <linux/errno.h> 27470decc6SDave Kleikamp #include <linux/slab.h> 28470decc6SDave Kleikamp #include <linux/init.h> 29470decc6SDave Kleikamp #include <linux/mm.h> 307dfb7103SNigel Cunningham #include <linux/freezer.h> 31470decc6SDave Kleikamp #include <linux/pagemap.h> 32470decc6SDave Kleikamp #include <linux/kthread.h> 33470decc6SDave Kleikamp #include <linux/poison.h> 34470decc6SDave Kleikamp #include <linux/proc_fs.h> 358e85fb3fSJohann Lombardi #include <linux/seq_file.h> 36c225aa57SSimon Holm Thøgersen #include <linux/math64.h> 37879c5e6bSTheodore Ts'o #include <linux/hash.h> 38d2eecb03STheodore Ts'o #include <linux/log2.h> 39d2eecb03STheodore Ts'o #include <linux/vmalloc.h> 4047def826STheodore Ts'o #include <linux/backing-dev.h> 4139e3ac25SBrian King #include <linux/bitops.h> 42670be5a7STheodore Ts'o #include <linux/ratelimit.h> 43eb52da3fSMichal Hocko #include <linux/sched/mm.h> 44879c5e6bSTheodore Ts'o 45879c5e6bSTheodore Ts'o #define CREATE_TRACE_POINTS 46879c5e6bSTheodore Ts'o #include <trace/events/jbd2.h> 47470decc6SDave Kleikamp 487c0f6ba6SLinus Torvalds #include <linux/uaccess.h> 49470decc6SDave Kleikamp #include <asm/page.h> 50470decc6SDave Kleikamp 51b6e96d00STheodore Ts'o #ifdef CONFIG_JBD2_DEBUG 5268af74e9SJan Kara static ushort jbd2_journal_enable_debug __read_mostly; 53b6e96d00STheodore Ts'o 54b6e96d00STheodore Ts'o module_param_named(jbd2_debug, jbd2_journal_enable_debug, ushort, 0644); 55b6e96d00STheodore Ts'o MODULE_PARM_DESC(jbd2_debug, "Debugging level for jbd2"); 56b6e96d00STheodore Ts'o #endif 57b6e96d00STheodore Ts'o 58f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_extend); 59f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_stop); 60f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_lock_updates); 61f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_unlock_updates); 62f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_get_write_access); 63f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_get_create_access); 64f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_get_undo_access); 65e06c8227SJoel Becker EXPORT_SYMBOL(jbd2_journal_set_triggers); 66f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_dirty_metadata); 67f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_forget); 68f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_flush); 69f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_revoke); 70470decc6SDave Kleikamp 71f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_init_dev); 72f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_init_inode); 73f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_check_used_features); 74f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_check_available_features); 75f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_set_features); 76f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_load); 77f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_destroy); 78f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_abort); 79f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_errno); 80f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_ack_err); 81f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_clear_err); 82f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_log_wait_commit); 83f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_start_commit); 84f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_force_commit_nested); 85f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_wipe); 86f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_blocks_per_page); 87ccd16945SMatthew Wilcox (Oracle) EXPORT_SYMBOL(jbd2_journal_invalidate_folio); 88f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_try_to_free_buffers); 89f7f4bccbSMingming Cao EXPORT_SYMBOL(jbd2_journal_force_commit); 906ba0e7dcSRoss Zwisler EXPORT_SYMBOL(jbd2_journal_inode_ranged_write); 916ba0e7dcSRoss Zwisler EXPORT_SYMBOL(jbd2_journal_inode_ranged_wait); 92aa3c0c61SMauricio Faria de Oliveira EXPORT_SYMBOL(jbd2_journal_finish_inode_data_buffers); 93c851ed54SJan Kara EXPORT_SYMBOL(jbd2_journal_init_jbd_inode); 94c851ed54SJan Kara EXPORT_SYMBOL(jbd2_journal_release_jbd_inode); 95c851ed54SJan Kara EXPORT_SYMBOL(jbd2_journal_begin_ordered_truncate); 968aefcd55STheodore Ts'o EXPORT_SYMBOL(jbd2_inode_cache); 97470decc6SDave Kleikamp 98d2eecb03STheodore Ts'o static int jbd2_journal_create_slab(size_t slab_size); 99470decc6SDave Kleikamp 100169f1a2aSPaul Gortmaker #ifdef CONFIG_JBD2_DEBUG 101169f1a2aSPaul Gortmaker void __jbd2_debug(int level, const char *file, const char *func, 102169f1a2aSPaul Gortmaker unsigned int line, const char *fmt, ...) 103169f1a2aSPaul Gortmaker { 104169f1a2aSPaul Gortmaker struct va_format vaf; 105169f1a2aSPaul Gortmaker va_list args; 106169f1a2aSPaul Gortmaker 107169f1a2aSPaul Gortmaker if (level > jbd2_journal_enable_debug) 108169f1a2aSPaul Gortmaker return; 109169f1a2aSPaul Gortmaker va_start(args, fmt); 110169f1a2aSPaul Gortmaker vaf.fmt = fmt; 111169f1a2aSPaul Gortmaker vaf.va = &args; 1129196f571SWang Shilong printk(KERN_DEBUG "%s: (%s, %u): %pV", file, func, line, &vaf); 113169f1a2aSPaul Gortmaker va_end(args); 114169f1a2aSPaul Gortmaker } 115169f1a2aSPaul Gortmaker #endif 116169f1a2aSPaul Gortmaker 11725ed6e8aSDarrick J. Wong /* Checksumming functions */ 1187747e6d0SRashika Kheria static int jbd2_verify_csum_type(journal_t *j, journal_superblock_t *sb) 11925ed6e8aSDarrick J. Wong { 1208595798cSDarrick J. Wong if (!jbd2_journal_has_csum_v2or3_feature(j)) 12125ed6e8aSDarrick J. Wong return 1; 12225ed6e8aSDarrick J. Wong 12325ed6e8aSDarrick J. Wong return sb->s_checksum_type == JBD2_CRC32C_CHKSUM; 12425ed6e8aSDarrick J. Wong } 12525ed6e8aSDarrick J. Wong 12618a6ea1eSDarrick J. Wong static __be32 jbd2_superblock_csum(journal_t *j, journal_superblock_t *sb) 1274fd5ea43SDarrick J. Wong { 12818a6ea1eSDarrick J. Wong __u32 csum; 12918a6ea1eSDarrick J. Wong __be32 old_csum; 1304fd5ea43SDarrick J. Wong 1314fd5ea43SDarrick J. Wong old_csum = sb->s_checksum; 1324fd5ea43SDarrick J. Wong sb->s_checksum = 0; 1334fd5ea43SDarrick J. Wong csum = jbd2_chksum(j, ~0, (char *)sb, sizeof(journal_superblock_t)); 1344fd5ea43SDarrick J. Wong sb->s_checksum = old_csum; 1354fd5ea43SDarrick J. Wong 1364fd5ea43SDarrick J. Wong return cpu_to_be32(csum); 1374fd5ea43SDarrick J. Wong } 1384fd5ea43SDarrick J. Wong 139470decc6SDave Kleikamp /* 140470decc6SDave Kleikamp * Helper function used to manage commit timeouts 141470decc6SDave Kleikamp */ 142470decc6SDave Kleikamp 143e3c95788SKees Cook static void commit_timeout(struct timer_list *t) 144470decc6SDave Kleikamp { 145e3c95788SKees Cook journal_t *journal = from_timer(journal, t, j_commit_timer); 146470decc6SDave Kleikamp 147e3c95788SKees Cook wake_up_process(journal->j_task); 148470decc6SDave Kleikamp } 149470decc6SDave Kleikamp 150470decc6SDave Kleikamp /* 151f7f4bccbSMingming Cao * kjournald2: The main thread function used to manage a logging device 152470decc6SDave Kleikamp * journal. 153470decc6SDave Kleikamp * 154470decc6SDave Kleikamp * This kernel thread is responsible for two things: 155470decc6SDave Kleikamp * 156470decc6SDave Kleikamp * 1) COMMIT: Every so often we need to commit the current state of the 157470decc6SDave Kleikamp * filesystem to disk. The journal thread is responsible for writing 158ff780b91SHarshad Shirwadkar * all of the metadata buffers to disk. If a fast commit is ongoing 159ff780b91SHarshad Shirwadkar * journal thread waits until it's done and then continues from 160ff780b91SHarshad Shirwadkar * there on. 161470decc6SDave Kleikamp * 162470decc6SDave Kleikamp * 2) CHECKPOINT: We cannot reuse a used section of the log file until all 163470decc6SDave Kleikamp * of the data in that part of the log has been rewritten elsewhere on 164470decc6SDave Kleikamp * the disk. Flushing these old buffers to reclaim space in the log is 165470decc6SDave Kleikamp * known as checkpointing, and this thread is responsible for that job. 166470decc6SDave Kleikamp */ 167470decc6SDave Kleikamp 168f7f4bccbSMingming Cao static int kjournald2(void *arg) 169470decc6SDave Kleikamp { 170470decc6SDave Kleikamp journal_t *journal = arg; 171470decc6SDave Kleikamp transaction_t *transaction; 172470decc6SDave Kleikamp 173470decc6SDave Kleikamp /* 174470decc6SDave Kleikamp * Set up an interval timer which can be used to trigger a commit wakeup 175470decc6SDave Kleikamp * after the commit interval expires 176470decc6SDave Kleikamp */ 177e3c95788SKees Cook timer_setup(&journal->j_commit_timer, commit_timeout, 0); 178470decc6SDave Kleikamp 17935c80422SNigel Cunningham set_freezable(); 18035c80422SNigel Cunningham 181470decc6SDave Kleikamp /* Record that the journal thread is running */ 182470decc6SDave Kleikamp journal->j_task = current; 183470decc6SDave Kleikamp wake_up(&journal->j_wait_done_commit); 184470decc6SDave Kleikamp 185470decc6SDave Kleikamp /* 186eb52da3fSMichal Hocko * Make sure that no allocations from this kernel thread will ever 187eb52da3fSMichal Hocko * recurse to the fs layer because we are responsible for the 188eb52da3fSMichal Hocko * transaction commit and any fs involvement might get stuck waiting for 189eb52da3fSMichal Hocko * the trasn. commit. 190eb52da3fSMichal Hocko */ 191eb52da3fSMichal Hocko memalloc_nofs_save(); 192eb52da3fSMichal Hocko 193eb52da3fSMichal Hocko /* 194470decc6SDave Kleikamp * And now, wait forever for commit wakeup events. 195470decc6SDave Kleikamp */ 196a931da6aSTheodore Ts'o write_lock(&journal->j_state_lock); 197470decc6SDave Kleikamp 198470decc6SDave Kleikamp loop: 199f7f4bccbSMingming Cao if (journal->j_flags & JBD2_UNMOUNT) 200470decc6SDave Kleikamp goto end_loop; 201470decc6SDave Kleikamp 202cb3b3bf2SJan Kara jbd2_debug(1, "commit_sequence=%u, commit_request=%u\n", 203470decc6SDave Kleikamp journal->j_commit_sequence, journal->j_commit_request); 204470decc6SDave Kleikamp 205470decc6SDave Kleikamp if (journal->j_commit_sequence != journal->j_commit_request) { 206cb3b3bf2SJan Kara jbd2_debug(1, "OK, requests differ\n"); 207a931da6aSTheodore Ts'o write_unlock(&journal->j_state_lock); 208470decc6SDave Kleikamp del_timer_sync(&journal->j_commit_timer); 209f7f4bccbSMingming Cao jbd2_journal_commit_transaction(journal); 210a931da6aSTheodore Ts'o write_lock(&journal->j_state_lock); 211470decc6SDave Kleikamp goto loop; 212470decc6SDave Kleikamp } 213470decc6SDave Kleikamp 214470decc6SDave Kleikamp wake_up(&journal->j_wait_done_commit); 215470decc6SDave Kleikamp if (freezing(current)) { 216470decc6SDave Kleikamp /* 217470decc6SDave Kleikamp * The simpler the better. Flushing journal isn't a 218470decc6SDave Kleikamp * good idea, because that depends on threads that may 219470decc6SDave Kleikamp * be already stopped. 220470decc6SDave Kleikamp */ 221cb3b3bf2SJan Kara jbd2_debug(1, "Now suspending kjournald2\n"); 222a931da6aSTheodore Ts'o write_unlock(&journal->j_state_lock); 223a0acae0eSTejun Heo try_to_freeze(); 224a931da6aSTheodore Ts'o write_lock(&journal->j_state_lock); 225470decc6SDave Kleikamp } else { 226470decc6SDave Kleikamp /* 227470decc6SDave Kleikamp * We assume on resume that commits are already there, 228470decc6SDave Kleikamp * so we don't sleep 229470decc6SDave Kleikamp */ 230470decc6SDave Kleikamp DEFINE_WAIT(wait); 231470decc6SDave Kleikamp int should_sleep = 1; 232470decc6SDave Kleikamp 233470decc6SDave Kleikamp prepare_to_wait(&journal->j_wait_commit, &wait, 234470decc6SDave Kleikamp TASK_INTERRUPTIBLE); 235470decc6SDave Kleikamp if (journal->j_commit_sequence != journal->j_commit_request) 236470decc6SDave Kleikamp should_sleep = 0; 237470decc6SDave Kleikamp transaction = journal->j_running_transaction; 238470decc6SDave Kleikamp if (transaction && time_after_eq(jiffies, 239470decc6SDave Kleikamp transaction->t_expires)) 240470decc6SDave Kleikamp should_sleep = 0; 241f7f4bccbSMingming Cao if (journal->j_flags & JBD2_UNMOUNT) 242470decc6SDave Kleikamp should_sleep = 0; 243470decc6SDave Kleikamp if (should_sleep) { 244a931da6aSTheodore Ts'o write_unlock(&journal->j_state_lock); 245470decc6SDave Kleikamp schedule(); 246a931da6aSTheodore Ts'o write_lock(&journal->j_state_lock); 247470decc6SDave Kleikamp } 248470decc6SDave Kleikamp finish_wait(&journal->j_wait_commit, &wait); 249470decc6SDave Kleikamp } 250470decc6SDave Kleikamp 251cb3b3bf2SJan Kara jbd2_debug(1, "kjournald2 wakes\n"); 252470decc6SDave Kleikamp 253470decc6SDave Kleikamp /* 254470decc6SDave Kleikamp * Were we woken up by a commit wakeup event? 255470decc6SDave Kleikamp */ 256470decc6SDave Kleikamp transaction = journal->j_running_transaction; 257470decc6SDave Kleikamp if (transaction && time_after_eq(jiffies, transaction->t_expires)) { 258470decc6SDave Kleikamp journal->j_commit_request = transaction->t_tid; 259cb3b3bf2SJan Kara jbd2_debug(1, "woke because of timeout\n"); 260470decc6SDave Kleikamp } 261470decc6SDave Kleikamp goto loop; 262470decc6SDave Kleikamp 263470decc6SDave Kleikamp end_loop: 264470decc6SDave Kleikamp del_timer_sync(&journal->j_commit_timer); 265470decc6SDave Kleikamp journal->j_task = NULL; 266470decc6SDave Kleikamp wake_up(&journal->j_wait_done_commit); 267cb3b3bf2SJan Kara jbd2_debug(1, "Journal thread exiting.\n"); 268dbfcef6bSSahitya Tummala write_unlock(&journal->j_state_lock); 269470decc6SDave Kleikamp return 0; 270470decc6SDave Kleikamp } 271470decc6SDave Kleikamp 27297f06784SPavel Emelianov static int jbd2_journal_start_thread(journal_t *journal) 273470decc6SDave Kleikamp { 27497f06784SPavel Emelianov struct task_struct *t; 27597f06784SPavel Emelianov 27690576c0bSTheodore Ts'o t = kthread_run(kjournald2, journal, "jbd2/%s", 27790576c0bSTheodore Ts'o journal->j_devname); 27897f06784SPavel Emelianov if (IS_ERR(t)) 27997f06784SPavel Emelianov return PTR_ERR(t); 28097f06784SPavel Emelianov 2811076d17aSAl Viro wait_event(journal->j_wait_done_commit, journal->j_task != NULL); 28297f06784SPavel Emelianov return 0; 283470decc6SDave Kleikamp } 284470decc6SDave Kleikamp 285470decc6SDave Kleikamp static void journal_kill_thread(journal_t *journal) 286470decc6SDave Kleikamp { 287a931da6aSTheodore Ts'o write_lock(&journal->j_state_lock); 288f7f4bccbSMingming Cao journal->j_flags |= JBD2_UNMOUNT; 289470decc6SDave Kleikamp 290470decc6SDave Kleikamp while (journal->j_task) { 291a931da6aSTheodore Ts'o write_unlock(&journal->j_state_lock); 2923469a32aSTheodore Ts'o wake_up(&journal->j_wait_commit); 2931076d17aSAl Viro wait_event(journal->j_wait_done_commit, journal->j_task == NULL); 294a931da6aSTheodore Ts'o write_lock(&journal->j_state_lock); 295470decc6SDave Kleikamp } 296a931da6aSTheodore Ts'o write_unlock(&journal->j_state_lock); 297470decc6SDave Kleikamp } 298470decc6SDave Kleikamp 299470decc6SDave Kleikamp /* 300f7f4bccbSMingming Cao * jbd2_journal_write_metadata_buffer: write a metadata buffer to the journal. 301470decc6SDave Kleikamp * 302470decc6SDave Kleikamp * Writes a metadata buffer to a given disk block. The actual IO is not 303470decc6SDave Kleikamp * performed but a new buffer_head is constructed which labels the data 304470decc6SDave Kleikamp * to be written with the correct destination disk block. 305470decc6SDave Kleikamp * 306470decc6SDave Kleikamp * Any magic-number escaping which needs to be done will cause a 307470decc6SDave Kleikamp * copy-out here. If the buffer happens to start with the 308f7f4bccbSMingming Cao * JBD2_MAGIC_NUMBER, then we can't write it to the log directly: the 309470decc6SDave Kleikamp * magic number is only written to the log for descripter blocks. In 310470decc6SDave Kleikamp * this case, we copy the data and replace the first word with 0, and we 311470decc6SDave Kleikamp * return a result code which indicates that this buffer needs to be 312470decc6SDave Kleikamp * marked as an escaped buffer in the corresponding log descriptor 313470decc6SDave Kleikamp * block. The missing word can then be restored when the block is read 314470decc6SDave Kleikamp * during recovery. 315470decc6SDave Kleikamp * 316470decc6SDave Kleikamp * If the source buffer has already been modified by a new transaction 317470decc6SDave Kleikamp * since we took the last commit snapshot, we use the frozen copy of 318470decc6SDave Kleikamp * that data for IO. If we end up using the existing buffer_head's data 319f5113effSJan Kara * for the write, then we have to make sure nobody modifies it while the 320f5113effSJan Kara * IO is in progress. do_get_write_access() handles this. 321470decc6SDave Kleikamp * 322f5113effSJan Kara * The function returns a pointer to the buffer_head to be used for IO. 323470decc6SDave Kleikamp * 324470decc6SDave Kleikamp * 325470decc6SDave Kleikamp * Return value: 326470decc6SDave Kleikamp * <0: Error 327470decc6SDave Kleikamp * >=0: Finished OK 328470decc6SDave Kleikamp * 329470decc6SDave Kleikamp * On success: 330470decc6SDave Kleikamp * Bit 0 set == escape performed on the data 331470decc6SDave Kleikamp * Bit 1 set == buffer copy-out performed (kfree the data after IO) 332470decc6SDave Kleikamp */ 333470decc6SDave Kleikamp 334f7f4bccbSMingming Cao int jbd2_journal_write_metadata_buffer(transaction_t *transaction, 335470decc6SDave Kleikamp struct journal_head *jh_in, 336f5113effSJan Kara struct buffer_head **bh_out, 337f5113effSJan Kara sector_t blocknr) 338470decc6SDave Kleikamp { 339470decc6SDave Kleikamp int need_copy_out = 0; 340470decc6SDave Kleikamp int done_copy_out = 0; 341470decc6SDave Kleikamp int do_escape = 0; 342470decc6SDave Kleikamp char *mapped_data; 343470decc6SDave Kleikamp struct buffer_head *new_bh; 344470decc6SDave Kleikamp struct page *new_page; 345470decc6SDave Kleikamp unsigned int new_offset; 346470decc6SDave Kleikamp struct buffer_head *bh_in = jh2bh(jh_in); 34796577c43Sdingdinghua journal_t *journal = transaction->t_journal; 348470decc6SDave Kleikamp 349470decc6SDave Kleikamp /* 350470decc6SDave Kleikamp * The buffer really shouldn't be locked: only the current committing 351470decc6SDave Kleikamp * transaction is allowed to write it, so nobody else is allowed 352470decc6SDave Kleikamp * to do any IO. 353470decc6SDave Kleikamp * 354470decc6SDave Kleikamp * akpm: except if we're journalling data, and write() output is 355470decc6SDave Kleikamp * also part of a shared mapping, and another thread has 356470decc6SDave Kleikamp * decided to launch a writepage() against this buffer. 357470decc6SDave Kleikamp */ 358470decc6SDave Kleikamp J_ASSERT_BH(bh_in, buffer_jbddirty(bh_in)); 359470decc6SDave Kleikamp 3606ccaf3e2SMichal Hocko new_bh = alloc_buffer_head(GFP_NOFS|__GFP_NOFAIL); 36147def826STheodore Ts'o 36296577c43Sdingdinghua /* keep subsequent assertions sane */ 36396577c43Sdingdinghua atomic_set(&new_bh->b_count, 1); 364470decc6SDave Kleikamp 36546417064SThomas Gleixner spin_lock(&jh_in->b_state_lock); 366f5113effSJan Kara repeat: 367470decc6SDave Kleikamp /* 368470decc6SDave Kleikamp * If a new transaction has already done a buffer copy-out, then 369470decc6SDave Kleikamp * we use that version of the data for the commit. 370470decc6SDave Kleikamp */ 371470decc6SDave Kleikamp if (jh_in->b_frozen_data) { 372470decc6SDave Kleikamp done_copy_out = 1; 373470decc6SDave Kleikamp new_page = virt_to_page(jh_in->b_frozen_data); 374470decc6SDave Kleikamp new_offset = offset_in_page(jh_in->b_frozen_data); 375470decc6SDave Kleikamp } else { 376470decc6SDave Kleikamp new_page = jh2bh(jh_in)->b_page; 377470decc6SDave Kleikamp new_offset = offset_in_page(jh2bh(jh_in)->b_data); 378470decc6SDave Kleikamp } 379470decc6SDave Kleikamp 380303a8f2aSCong Wang mapped_data = kmap_atomic(new_page); 381470decc6SDave Kleikamp /* 38213ceef09SJan Kara * Fire data frozen trigger if data already wasn't frozen. Do this 38313ceef09SJan Kara * before checking for escaping, as the trigger may modify the magic 38413ceef09SJan Kara * offset. If a copy-out happens afterwards, it will have the correct 38513ceef09SJan Kara * data in the buffer. 386e06c8227SJoel Becker */ 38713ceef09SJan Kara if (!done_copy_out) 38813ceef09SJan Kara jbd2_buffer_frozen_trigger(jh_in, mapped_data + new_offset, 38913ceef09SJan Kara jh_in->b_triggers); 390e06c8227SJoel Becker 391e06c8227SJoel Becker /* 392470decc6SDave Kleikamp * Check for escaping 393470decc6SDave Kleikamp */ 394470decc6SDave Kleikamp if (*((__be32 *)(mapped_data + new_offset)) == 395f7f4bccbSMingming Cao cpu_to_be32(JBD2_MAGIC_NUMBER)) { 396470decc6SDave Kleikamp need_copy_out = 1; 397470decc6SDave Kleikamp do_escape = 1; 398470decc6SDave Kleikamp } 399303a8f2aSCong Wang kunmap_atomic(mapped_data); 400470decc6SDave Kleikamp 401470decc6SDave Kleikamp /* 402470decc6SDave Kleikamp * Do we need to do a data copy? 403470decc6SDave Kleikamp */ 404470decc6SDave Kleikamp if (need_copy_out && !done_copy_out) { 405470decc6SDave Kleikamp char *tmp; 406470decc6SDave Kleikamp 40746417064SThomas Gleixner spin_unlock(&jh_in->b_state_lock); 408af1e76d6SMingming Cao tmp = jbd2_alloc(bh_in->b_size, GFP_NOFS); 409e6ec116bSTheodore Ts'o if (!tmp) { 410f5113effSJan Kara brelse(new_bh); 411e6ec116bSTheodore Ts'o return -ENOMEM; 412e6ec116bSTheodore Ts'o } 41346417064SThomas Gleixner spin_lock(&jh_in->b_state_lock); 414470decc6SDave Kleikamp if (jh_in->b_frozen_data) { 415af1e76d6SMingming Cao jbd2_free(tmp, bh_in->b_size); 416470decc6SDave Kleikamp goto repeat; 417470decc6SDave Kleikamp } 418470decc6SDave Kleikamp 419470decc6SDave Kleikamp jh_in->b_frozen_data = tmp; 420303a8f2aSCong Wang mapped_data = kmap_atomic(new_page); 421f5113effSJan Kara memcpy(tmp, mapped_data + new_offset, bh_in->b_size); 422303a8f2aSCong Wang kunmap_atomic(mapped_data); 423470decc6SDave Kleikamp 424470decc6SDave Kleikamp new_page = virt_to_page(tmp); 425470decc6SDave Kleikamp new_offset = offset_in_page(tmp); 426470decc6SDave Kleikamp done_copy_out = 1; 427e06c8227SJoel Becker 428e06c8227SJoel Becker /* 429e06c8227SJoel Becker * This isn't strictly necessary, as we're using frozen 430e06c8227SJoel Becker * data for the escaping, but it keeps consistency with 431e06c8227SJoel Becker * b_frozen_data usage. 432e06c8227SJoel Becker */ 433e06c8227SJoel Becker jh_in->b_frozen_triggers = jh_in->b_triggers; 434470decc6SDave Kleikamp } 435470decc6SDave Kleikamp 436470decc6SDave Kleikamp /* 437470decc6SDave Kleikamp * Did we need to do an escaping? Now we've done all the 438470decc6SDave Kleikamp * copying, we can finally do so. 439470decc6SDave Kleikamp */ 440470decc6SDave Kleikamp if (do_escape) { 441303a8f2aSCong Wang mapped_data = kmap_atomic(new_page); 442470decc6SDave Kleikamp *((unsigned int *)(mapped_data + new_offset)) = 0; 443303a8f2aSCong Wang kunmap_atomic(mapped_data); 444470decc6SDave Kleikamp } 445470decc6SDave Kleikamp 446470decc6SDave Kleikamp set_bh_page(new_bh, new_page, new_offset); 447f5113effSJan Kara new_bh->b_size = bh_in->b_size; 448f5113effSJan Kara new_bh->b_bdev = journal->j_dev; 449470decc6SDave Kleikamp new_bh->b_blocknr = blocknr; 450b34090e5SJan Kara new_bh->b_private = bh_in; 451470decc6SDave Kleikamp set_buffer_mapped(new_bh); 452470decc6SDave Kleikamp set_buffer_dirty(new_bh); 453470decc6SDave Kleikamp 454f5113effSJan Kara *bh_out = new_bh; 455470decc6SDave Kleikamp 456470decc6SDave Kleikamp /* 457470decc6SDave Kleikamp * The to-be-written buffer needs to get moved to the io queue, 458470decc6SDave Kleikamp * and the original buffer whose contents we are shadowing or 459470decc6SDave Kleikamp * copying is moved to the transaction's shadow queue. 460470decc6SDave Kleikamp */ 461470decc6SDave Kleikamp JBUFFER_TRACE(jh_in, "file as BJ_Shadow"); 46296577c43Sdingdinghua spin_lock(&journal->j_list_lock); 46396577c43Sdingdinghua __jbd2_journal_file_buffer(jh_in, transaction, BJ_Shadow); 46496577c43Sdingdinghua spin_unlock(&journal->j_list_lock); 465b34090e5SJan Kara set_buffer_shadow(bh_in); 46646417064SThomas Gleixner spin_unlock(&jh_in->b_state_lock); 46796577c43Sdingdinghua 468470decc6SDave Kleikamp return do_escape | (done_copy_out << 1); 469470decc6SDave Kleikamp } 470470decc6SDave Kleikamp 471470decc6SDave Kleikamp /* 472470decc6SDave Kleikamp * Allocation code for the journal file. Manage the space left in the 473470decc6SDave Kleikamp * journal, so that we can begin checkpointing when appropriate. 474470decc6SDave Kleikamp */ 475470decc6SDave Kleikamp 476470decc6SDave Kleikamp /* 477e4471831STheodore Ts'o * Called with j_state_lock locked for writing. 478e4471831STheodore Ts'o * Returns true if a transaction commit was started. 479470decc6SDave Kleikamp */ 480d1324958SJan Kara static int __jbd2_log_start_commit(journal_t *journal, tid_t target) 481470decc6SDave Kleikamp { 482e7b04ac0SEric Sandeen /* Return if the txn has already requested to be committed */ 483e7b04ac0SEric Sandeen if (journal->j_commit_request == target) 484e7b04ac0SEric Sandeen return 0; 485e7b04ac0SEric Sandeen 486470decc6SDave Kleikamp /* 487deeeaf13STheodore Ts'o * The only transaction we can possibly wait upon is the 488deeeaf13STheodore Ts'o * currently running transaction (if it exists). Otherwise, 489deeeaf13STheodore Ts'o * the target tid must be an old one. 490470decc6SDave Kleikamp */ 491deeeaf13STheodore Ts'o if (journal->j_running_transaction && 492deeeaf13STheodore Ts'o journal->j_running_transaction->t_tid == target) { 493470decc6SDave Kleikamp /* 494bcf3d0bcSAndrea Gelmini * We want a new commit: OK, mark the request and wakeup the 495470decc6SDave Kleikamp * commit thread. We do _not_ do the commit ourselves. 496470decc6SDave Kleikamp */ 497470decc6SDave Kleikamp 498470decc6SDave Kleikamp journal->j_commit_request = target; 499cb3b3bf2SJan Kara jbd2_debug(1, "JBD2: requesting commit %u/%u\n", 500470decc6SDave Kleikamp journal->j_commit_request, 501470decc6SDave Kleikamp journal->j_commit_sequence); 5029fff24aaSTheodore Ts'o journal->j_running_transaction->t_requested = jiffies; 503470decc6SDave Kleikamp wake_up(&journal->j_wait_commit); 504470decc6SDave Kleikamp return 1; 505deeeaf13STheodore Ts'o } else if (!tid_geq(journal->j_commit_request, target)) 506deeeaf13STheodore Ts'o /* This should never happen, but if it does, preserve 507deeeaf13STheodore Ts'o the evidence before kjournald goes into a loop and 508deeeaf13STheodore Ts'o increments j_commit_sequence beyond all recognition. */ 509f2a44523SEryu Guan WARN_ONCE(1, "JBD2: bad log_start_commit: %u %u %u %u\n", 5101be2add6STheodore Ts'o journal->j_commit_request, 5111be2add6STheodore Ts'o journal->j_commit_sequence, 512deeeaf13STheodore Ts'o target, journal->j_running_transaction ? 513deeeaf13STheodore Ts'o journal->j_running_transaction->t_tid : 0); 514470decc6SDave Kleikamp return 0; 515470decc6SDave Kleikamp } 516470decc6SDave Kleikamp 517f7f4bccbSMingming Cao int jbd2_log_start_commit(journal_t *journal, tid_t tid) 518470decc6SDave Kleikamp { 519470decc6SDave Kleikamp int ret; 520470decc6SDave Kleikamp 521a931da6aSTheodore Ts'o write_lock(&journal->j_state_lock); 522f7f4bccbSMingming Cao ret = __jbd2_log_start_commit(journal, tid); 523a931da6aSTheodore Ts'o write_unlock(&journal->j_state_lock); 524470decc6SDave Kleikamp return ret; 525470decc6SDave Kleikamp } 526470decc6SDave Kleikamp 527470decc6SDave Kleikamp /* 5289ff86446SDmitry Monakhov * Force and wait any uncommitted transactions. We can only force the running 5299ff86446SDmitry Monakhov * transaction if we don't have an active handle, otherwise, we will deadlock. 5309ff86446SDmitry Monakhov * Returns: <0 in case of error, 5319ff86446SDmitry Monakhov * 0 if nothing to commit, 5329ff86446SDmitry Monakhov * 1 if transaction was successfully committed. 533470decc6SDave Kleikamp */ 5349ff86446SDmitry Monakhov static int __jbd2_journal_force_commit(journal_t *journal) 535470decc6SDave Kleikamp { 536470decc6SDave Kleikamp transaction_t *transaction = NULL; 537470decc6SDave Kleikamp tid_t tid; 5389ff86446SDmitry Monakhov int need_to_start = 0, ret = 0; 539470decc6SDave Kleikamp 540a931da6aSTheodore Ts'o read_lock(&journal->j_state_lock); 541470decc6SDave Kleikamp if (journal->j_running_transaction && !current->journal_info) { 542470decc6SDave Kleikamp transaction = journal->j_running_transaction; 543e4471831STheodore Ts'o if (!tid_geq(journal->j_commit_request, transaction->t_tid)) 544e4471831STheodore Ts'o need_to_start = 1; 545470decc6SDave Kleikamp } else if (journal->j_committing_transaction) 546470decc6SDave Kleikamp transaction = journal->j_committing_transaction; 547470decc6SDave Kleikamp 548470decc6SDave Kleikamp if (!transaction) { 5499ff86446SDmitry Monakhov /* Nothing to commit */ 550a931da6aSTheodore Ts'o read_unlock(&journal->j_state_lock); 5519ff86446SDmitry Monakhov return 0; 552470decc6SDave Kleikamp } 553470decc6SDave Kleikamp tid = transaction->t_tid; 554a931da6aSTheodore Ts'o read_unlock(&journal->j_state_lock); 555e4471831STheodore Ts'o if (need_to_start) 556e4471831STheodore Ts'o jbd2_log_start_commit(journal, tid); 5579ff86446SDmitry Monakhov ret = jbd2_log_wait_commit(journal, tid); 5589ff86446SDmitry Monakhov if (!ret) 5599ff86446SDmitry Monakhov ret = 1; 5609ff86446SDmitry Monakhov 5619ff86446SDmitry Monakhov return ret; 5629ff86446SDmitry Monakhov } 5639ff86446SDmitry Monakhov 5649ff86446SDmitry Monakhov /** 5652bf31d94SMauro Carvalho Chehab * jbd2_journal_force_commit_nested - Force and wait upon a commit if the 5662bf31d94SMauro Carvalho Chehab * calling process is not within transaction. 5679ff86446SDmitry Monakhov * 5689ff86446SDmitry Monakhov * @journal: journal to force 5699ff86446SDmitry Monakhov * Returns true if progress was made. 5702bf31d94SMauro Carvalho Chehab * 5712bf31d94SMauro Carvalho Chehab * This is used for forcing out undo-protected data which contains 5722bf31d94SMauro Carvalho Chehab * bitmaps, when the fs is running out of space. 5739ff86446SDmitry Monakhov */ 5749ff86446SDmitry Monakhov int jbd2_journal_force_commit_nested(journal_t *journal) 5759ff86446SDmitry Monakhov { 5769ff86446SDmitry Monakhov int ret; 5779ff86446SDmitry Monakhov 5789ff86446SDmitry Monakhov ret = __jbd2_journal_force_commit(journal); 5799ff86446SDmitry Monakhov return ret > 0; 5809ff86446SDmitry Monakhov } 5819ff86446SDmitry Monakhov 5829ff86446SDmitry Monakhov /** 5832bf31d94SMauro Carvalho Chehab * jbd2_journal_force_commit() - force any uncommitted transactions 5849ff86446SDmitry Monakhov * @journal: journal to force 5859ff86446SDmitry Monakhov * 5869ff86446SDmitry Monakhov * Caller want unconditional commit. We can only force the running transaction 5879ff86446SDmitry Monakhov * if we don't have an active handle, otherwise, we will deadlock. 5889ff86446SDmitry Monakhov */ 5899ff86446SDmitry Monakhov int jbd2_journal_force_commit(journal_t *journal) 5909ff86446SDmitry Monakhov { 5919ff86446SDmitry Monakhov int ret; 5929ff86446SDmitry Monakhov 5939ff86446SDmitry Monakhov J_ASSERT(!current->journal_info); 5949ff86446SDmitry Monakhov ret = __jbd2_journal_force_commit(journal); 5959ff86446SDmitry Monakhov if (ret > 0) 5969ff86446SDmitry Monakhov ret = 0; 5979ff86446SDmitry Monakhov return ret; 598470decc6SDave Kleikamp } 599470decc6SDave Kleikamp 600470decc6SDave Kleikamp /* 601470decc6SDave Kleikamp * Start a commit of the current running transaction (if any). Returns true 602c88ccea3SJan Kara * if a transaction is going to be committed (or is currently already 603c88ccea3SJan Kara * committing), and fills its tid in at *ptid 604470decc6SDave Kleikamp */ 605f7f4bccbSMingming Cao int jbd2_journal_start_commit(journal_t *journal, tid_t *ptid) 606470decc6SDave Kleikamp { 607470decc6SDave Kleikamp int ret = 0; 608470decc6SDave Kleikamp 609a931da6aSTheodore Ts'o write_lock(&journal->j_state_lock); 610470decc6SDave Kleikamp if (journal->j_running_transaction) { 611470decc6SDave Kleikamp tid_t tid = journal->j_running_transaction->t_tid; 612470decc6SDave Kleikamp 613c88ccea3SJan Kara __jbd2_log_start_commit(journal, tid); 614c88ccea3SJan Kara /* There's a running transaction and we've just made sure 615c88ccea3SJan Kara * it's commit has been scheduled. */ 616c88ccea3SJan Kara if (ptid) 617470decc6SDave Kleikamp *ptid = tid; 618c88ccea3SJan Kara ret = 1; 619c88ccea3SJan Kara } else if (journal->j_committing_transaction) { 620470decc6SDave Kleikamp /* 62112810ad7SArtem Bityutskiy * If commit has been started, then we have to wait for 62212810ad7SArtem Bityutskiy * completion of that transaction. 623470decc6SDave Kleikamp */ 624c88ccea3SJan Kara if (ptid) 625470decc6SDave Kleikamp *ptid = journal->j_committing_transaction->t_tid; 626470decc6SDave Kleikamp ret = 1; 627470decc6SDave Kleikamp } 628a931da6aSTheodore Ts'o write_unlock(&journal->j_state_lock); 629470decc6SDave Kleikamp return ret; 630470decc6SDave Kleikamp } 631470decc6SDave Kleikamp 632470decc6SDave Kleikamp /* 633bbd2be36SJan Kara * Return 1 if a given transaction has not yet sent barrier request 634bbd2be36SJan Kara * connected with a transaction commit. If 0 is returned, transaction 635bbd2be36SJan Kara * may or may not have sent the barrier. Used to avoid sending barrier 636bbd2be36SJan Kara * twice in common cases. 637bbd2be36SJan Kara */ 638bbd2be36SJan Kara int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid) 639bbd2be36SJan Kara { 640bbd2be36SJan Kara int ret = 0; 641bbd2be36SJan Kara transaction_t *commit_trans; 642bbd2be36SJan Kara 643bbd2be36SJan Kara if (!(journal->j_flags & JBD2_BARRIER)) 644bbd2be36SJan Kara return 0; 645bbd2be36SJan Kara read_lock(&journal->j_state_lock); 646bbd2be36SJan Kara /* Transaction already committed? */ 647bbd2be36SJan Kara if (tid_geq(journal->j_commit_sequence, tid)) 648bbd2be36SJan Kara goto out; 649bbd2be36SJan Kara commit_trans = journal->j_committing_transaction; 650bbd2be36SJan Kara if (!commit_trans || commit_trans->t_tid != tid) { 651bbd2be36SJan Kara ret = 1; 652bbd2be36SJan Kara goto out; 653bbd2be36SJan Kara } 654bbd2be36SJan Kara /* 655bbd2be36SJan Kara * Transaction is being committed and we already proceeded to 656bbd2be36SJan Kara * submitting a flush to fs partition? 657bbd2be36SJan Kara */ 658bbd2be36SJan Kara if (journal->j_fs_dev != journal->j_dev) { 659bbd2be36SJan Kara if (!commit_trans->t_need_data_flush || 660bbd2be36SJan Kara commit_trans->t_state >= T_COMMIT_DFLUSH) 661bbd2be36SJan Kara goto out; 662bbd2be36SJan Kara } else { 663bbd2be36SJan Kara if (commit_trans->t_state >= T_COMMIT_JFLUSH) 664bbd2be36SJan Kara goto out; 665bbd2be36SJan Kara } 666bbd2be36SJan Kara ret = 1; 667bbd2be36SJan Kara out: 668bbd2be36SJan Kara read_unlock(&journal->j_state_lock); 669bbd2be36SJan Kara return ret; 670bbd2be36SJan Kara } 671bbd2be36SJan Kara EXPORT_SYMBOL(jbd2_trans_will_send_data_barrier); 672bbd2be36SJan Kara 673bbd2be36SJan Kara /* 674470decc6SDave Kleikamp * Wait for a specified commit to complete. 675470decc6SDave Kleikamp * The caller may not hold the journal lock. 676470decc6SDave Kleikamp */ 677f7f4bccbSMingming Cao int jbd2_log_wait_commit(journal_t *journal, tid_t tid) 678470decc6SDave Kleikamp { 679470decc6SDave Kleikamp int err = 0; 680470decc6SDave Kleikamp 681c52c47e4SJan Kara read_lock(&journal->j_state_lock); 682c52c47e4SJan Kara #ifdef CONFIG_PROVE_LOCKING 683c52c47e4SJan Kara /* 684c52c47e4SJan Kara * Some callers make sure transaction is already committing and in that 685c52c47e4SJan Kara * case we cannot block on open handles anymore. So don't warn in that 686c52c47e4SJan Kara * case. 687c52c47e4SJan Kara */ 688c52c47e4SJan Kara if (tid_gt(tid, journal->j_commit_sequence) && 689c52c47e4SJan Kara (!journal->j_committing_transaction || 690c52c47e4SJan Kara journal->j_committing_transaction->t_tid != tid)) { 691c52c47e4SJan Kara read_unlock(&journal->j_state_lock); 6921eaa566dSJan Kara jbd2_might_wait_for_commit(journal); 693a931da6aSTheodore Ts'o read_lock(&journal->j_state_lock); 694c52c47e4SJan Kara } 695c52c47e4SJan Kara #endif 696e23291b9SJose R. Santos #ifdef CONFIG_JBD2_DEBUG 697470decc6SDave Kleikamp if (!tid_geq(journal->j_commit_request, tid)) { 69875685071SJan Kara printk(KERN_ERR 6997821ce41SGaowei Pu "%s: error: j_commit_request=%u, tid=%u\n", 700329d291fSHarvey Harrison __func__, journal->j_commit_request, tid); 701470decc6SDave Kleikamp } 702470decc6SDave Kleikamp #endif 703470decc6SDave Kleikamp while (tid_gt(tid, journal->j_commit_sequence)) { 704cb3b3bf2SJan Kara jbd2_debug(1, "JBD2: want %u, j_commit_sequence=%u\n", 705470decc6SDave Kleikamp tid, journal->j_commit_sequence); 706a931da6aSTheodore Ts'o read_unlock(&journal->j_state_lock); 7073469a32aSTheodore Ts'o wake_up(&journal->j_wait_commit); 708470decc6SDave Kleikamp wait_event(journal->j_wait_done_commit, 709470decc6SDave Kleikamp !tid_gt(tid, journal->j_commit_sequence)); 710a931da6aSTheodore Ts'o read_lock(&journal->j_state_lock); 711470decc6SDave Kleikamp } 712a931da6aSTheodore Ts'o read_unlock(&journal->j_state_lock); 713470decc6SDave Kleikamp 71475685071SJan Kara if (unlikely(is_journal_aborted(journal))) 715470decc6SDave Kleikamp err = -EIO; 716470decc6SDave Kleikamp return err; 717470decc6SDave Kleikamp } 718470decc6SDave Kleikamp 719ff780b91SHarshad Shirwadkar /* 720ff780b91SHarshad Shirwadkar * Start a fast commit. If there's an ongoing fast or full commit wait for 721ff780b91SHarshad Shirwadkar * it to complete. Returns 0 if a new fast commit was started. Returns -EALREADY 722ff780b91SHarshad Shirwadkar * if a fast commit is not needed, either because there's an already a commit 723ff780b91SHarshad Shirwadkar * going on or this tid has already been committed. Returns -EINVAL if no jbd2 724ff780b91SHarshad Shirwadkar * commit has yet been performed. 725ff780b91SHarshad Shirwadkar */ 726ff780b91SHarshad Shirwadkar int jbd2_fc_begin_commit(journal_t *journal, tid_t tid) 727ff780b91SHarshad Shirwadkar { 72887a144f0SHarshad Shirwadkar if (unlikely(is_journal_aborted(journal))) 72987a144f0SHarshad Shirwadkar return -EIO; 730ff780b91SHarshad Shirwadkar /* 731ff780b91SHarshad Shirwadkar * Fast commits only allowed if at least one full commit has 732ff780b91SHarshad Shirwadkar * been processed. 733ff780b91SHarshad Shirwadkar */ 734ff780b91SHarshad Shirwadkar if (!journal->j_stats.ts_tid) 735ff780b91SHarshad Shirwadkar return -EINVAL; 736ff780b91SHarshad Shirwadkar 737ff780b91SHarshad Shirwadkar write_lock(&journal->j_state_lock); 738480f89d5SHarshad Shirwadkar if (tid <= journal->j_commit_sequence) { 739480f89d5SHarshad Shirwadkar write_unlock(&journal->j_state_lock); 740480f89d5SHarshad Shirwadkar return -EALREADY; 741480f89d5SHarshad Shirwadkar } 742480f89d5SHarshad Shirwadkar 743ff780b91SHarshad Shirwadkar if (journal->j_flags & JBD2_FULL_COMMIT_ONGOING || 744ff780b91SHarshad Shirwadkar (journal->j_flags & JBD2_FAST_COMMIT_ONGOING)) { 745ff780b91SHarshad Shirwadkar DEFINE_WAIT(wait); 746ff780b91SHarshad Shirwadkar 747ff780b91SHarshad Shirwadkar prepare_to_wait(&journal->j_fc_wait, &wait, 748ff780b91SHarshad Shirwadkar TASK_UNINTERRUPTIBLE); 749ff780b91SHarshad Shirwadkar write_unlock(&journal->j_state_lock); 750ff780b91SHarshad Shirwadkar schedule(); 751ff780b91SHarshad Shirwadkar finish_wait(&journal->j_fc_wait, &wait); 752ff780b91SHarshad Shirwadkar return -EALREADY; 753ff780b91SHarshad Shirwadkar } 754ff780b91SHarshad Shirwadkar journal->j_flags |= JBD2_FAST_COMMIT_ONGOING; 755ff780b91SHarshad Shirwadkar write_unlock(&journal->j_state_lock); 7562729cfdcSHarshad Shirwadkar jbd2_journal_lock_updates(journal); 757ff780b91SHarshad Shirwadkar 758ff780b91SHarshad Shirwadkar return 0; 759ff780b91SHarshad Shirwadkar } 760ff780b91SHarshad Shirwadkar EXPORT_SYMBOL(jbd2_fc_begin_commit); 761ff780b91SHarshad Shirwadkar 762ff780b91SHarshad Shirwadkar /* 763ff780b91SHarshad Shirwadkar * Stop a fast commit. If fallback is set, this function starts commit of 764ff780b91SHarshad Shirwadkar * TID tid before any other fast commit can start. 765ff780b91SHarshad Shirwadkar */ 766ff780b91SHarshad Shirwadkar static int __jbd2_fc_end_commit(journal_t *journal, tid_t tid, bool fallback) 767ff780b91SHarshad Shirwadkar { 7682729cfdcSHarshad Shirwadkar jbd2_journal_unlock_updates(journal); 769ff780b91SHarshad Shirwadkar if (journal->j_fc_cleanup_callback) 770e85c81baSXin Yin journal->j_fc_cleanup_callback(journal, 0, tid); 771ff780b91SHarshad Shirwadkar write_lock(&journal->j_state_lock); 772ff780b91SHarshad Shirwadkar journal->j_flags &= ~JBD2_FAST_COMMIT_ONGOING; 773ff780b91SHarshad Shirwadkar if (fallback) 774ff780b91SHarshad Shirwadkar journal->j_flags |= JBD2_FULL_COMMIT_ONGOING; 775ff780b91SHarshad Shirwadkar write_unlock(&journal->j_state_lock); 776ff780b91SHarshad Shirwadkar wake_up(&journal->j_fc_wait); 777ff780b91SHarshad Shirwadkar if (fallback) 778ff780b91SHarshad Shirwadkar return jbd2_complete_transaction(journal, tid); 779ff780b91SHarshad Shirwadkar return 0; 780ff780b91SHarshad Shirwadkar } 781ff780b91SHarshad Shirwadkar 782ff780b91SHarshad Shirwadkar int jbd2_fc_end_commit(journal_t *journal) 783ff780b91SHarshad Shirwadkar { 7840bce577bSHarshad Shirwadkar return __jbd2_fc_end_commit(journal, 0, false); 785ff780b91SHarshad Shirwadkar } 786ff780b91SHarshad Shirwadkar EXPORT_SYMBOL(jbd2_fc_end_commit); 787ff780b91SHarshad Shirwadkar 7880bce577bSHarshad Shirwadkar int jbd2_fc_end_commit_fallback(journal_t *journal) 789ff780b91SHarshad Shirwadkar { 7900bce577bSHarshad Shirwadkar tid_t tid; 7910bce577bSHarshad Shirwadkar 7920bce577bSHarshad Shirwadkar read_lock(&journal->j_state_lock); 7930bce577bSHarshad Shirwadkar tid = journal->j_running_transaction ? 7940bce577bSHarshad Shirwadkar journal->j_running_transaction->t_tid : 0; 7950bce577bSHarshad Shirwadkar read_unlock(&journal->j_state_lock); 7960bce577bSHarshad Shirwadkar return __jbd2_fc_end_commit(journal, tid, true); 797ff780b91SHarshad Shirwadkar } 798ff780b91SHarshad Shirwadkar EXPORT_SYMBOL(jbd2_fc_end_commit_fallback); 799ff780b91SHarshad Shirwadkar 800b8a6176cSJan Kara /* Return 1 when transaction with given tid has already committed. */ 801b8a6176cSJan Kara int jbd2_transaction_committed(journal_t *journal, tid_t tid) 802b8a6176cSJan Kara { 803b8a6176cSJan Kara int ret = 1; 804b8a6176cSJan Kara 805b8a6176cSJan Kara read_lock(&journal->j_state_lock); 806b8a6176cSJan Kara if (journal->j_running_transaction && 807b8a6176cSJan Kara journal->j_running_transaction->t_tid == tid) 808b8a6176cSJan Kara ret = 0; 809b8a6176cSJan Kara if (journal->j_committing_transaction && 810b8a6176cSJan Kara journal->j_committing_transaction->t_tid == tid) 811b8a6176cSJan Kara ret = 0; 812b8a6176cSJan Kara read_unlock(&journal->j_state_lock); 813b8a6176cSJan Kara return ret; 814b8a6176cSJan Kara } 815b8a6176cSJan Kara EXPORT_SYMBOL(jbd2_transaction_committed); 816b8a6176cSJan Kara 817470decc6SDave Kleikamp /* 818d76a3a77STheodore Ts'o * When this function returns the transaction corresponding to tid 819d76a3a77STheodore Ts'o * will be completed. If the transaction has currently running, start 820d76a3a77STheodore Ts'o * committing that transaction before waiting for it to complete. If 821d76a3a77STheodore Ts'o * the transaction id is stale, it is by definition already completed, 822d76a3a77STheodore Ts'o * so just return SUCCESS. 823d76a3a77STheodore Ts'o */ 824d76a3a77STheodore Ts'o int jbd2_complete_transaction(journal_t *journal, tid_t tid) 825d76a3a77STheodore Ts'o { 826d76a3a77STheodore Ts'o int need_to_wait = 1; 827d76a3a77STheodore Ts'o 828d76a3a77STheodore Ts'o read_lock(&journal->j_state_lock); 829d76a3a77STheodore Ts'o if (journal->j_running_transaction && 830d76a3a77STheodore Ts'o journal->j_running_transaction->t_tid == tid) { 831d76a3a77STheodore Ts'o if (journal->j_commit_request != tid) { 832d76a3a77STheodore Ts'o /* transaction not yet started, so request it */ 833d76a3a77STheodore Ts'o read_unlock(&journal->j_state_lock); 834d76a3a77STheodore Ts'o jbd2_log_start_commit(journal, tid); 835d76a3a77STheodore Ts'o goto wait_commit; 836d76a3a77STheodore Ts'o } 837d76a3a77STheodore Ts'o } else if (!(journal->j_committing_transaction && 838d76a3a77STheodore Ts'o journal->j_committing_transaction->t_tid == tid)) 839d76a3a77STheodore Ts'o need_to_wait = 0; 840d76a3a77STheodore Ts'o read_unlock(&journal->j_state_lock); 841d76a3a77STheodore Ts'o if (!need_to_wait) 842d76a3a77STheodore Ts'o return 0; 843d76a3a77STheodore Ts'o wait_commit: 844d76a3a77STheodore Ts'o return jbd2_log_wait_commit(journal, tid); 845d76a3a77STheodore Ts'o } 846d76a3a77STheodore Ts'o EXPORT_SYMBOL(jbd2_complete_transaction); 847d76a3a77STheodore Ts'o 848d76a3a77STheodore Ts'o /* 849470decc6SDave Kleikamp * Log buffer allocation routines: 850470decc6SDave Kleikamp */ 851470decc6SDave Kleikamp 85218eba7aaSMingming Cao int jbd2_journal_next_log_block(journal_t *journal, unsigned long long *retp) 853470decc6SDave Kleikamp { 854470decc6SDave Kleikamp unsigned long blocknr; 855470decc6SDave Kleikamp 856a931da6aSTheodore Ts'o write_lock(&journal->j_state_lock); 857470decc6SDave Kleikamp J_ASSERT(journal->j_free > 1); 858470decc6SDave Kleikamp 859470decc6SDave Kleikamp blocknr = journal->j_head; 860470decc6SDave Kleikamp journal->j_head++; 861470decc6SDave Kleikamp journal->j_free--; 862470decc6SDave Kleikamp if (journal->j_head == journal->j_last) 863470decc6SDave Kleikamp journal->j_head = journal->j_first; 864a931da6aSTheodore Ts'o write_unlock(&journal->j_state_lock); 865f7f4bccbSMingming Cao return jbd2_journal_bmap(journal, blocknr, retp); 866470decc6SDave Kleikamp } 867470decc6SDave Kleikamp 868ff780b91SHarshad Shirwadkar /* Map one fast commit buffer for use by the file system */ 869ff780b91SHarshad Shirwadkar int jbd2_fc_get_buf(journal_t *journal, struct buffer_head **bh_out) 870ff780b91SHarshad Shirwadkar { 871ff780b91SHarshad Shirwadkar unsigned long long pblock; 872ff780b91SHarshad Shirwadkar unsigned long blocknr; 873ff780b91SHarshad Shirwadkar int ret = 0; 874ff780b91SHarshad Shirwadkar struct buffer_head *bh; 875ff780b91SHarshad Shirwadkar int fc_off; 876ff780b91SHarshad Shirwadkar 877ff780b91SHarshad Shirwadkar *bh_out = NULL; 878ff780b91SHarshad Shirwadkar 879ff780b91SHarshad Shirwadkar if (journal->j_fc_off + journal->j_fc_first < journal->j_fc_last) { 880ff780b91SHarshad Shirwadkar fc_off = journal->j_fc_off; 881ff780b91SHarshad Shirwadkar blocknr = journal->j_fc_first + fc_off; 882ff780b91SHarshad Shirwadkar journal->j_fc_off++; 883ff780b91SHarshad Shirwadkar } else { 884ff780b91SHarshad Shirwadkar ret = -EINVAL; 885ff780b91SHarshad Shirwadkar } 886ff780b91SHarshad Shirwadkar 887ff780b91SHarshad Shirwadkar if (ret) 888ff780b91SHarshad Shirwadkar return ret; 889ff780b91SHarshad Shirwadkar 890ff780b91SHarshad Shirwadkar ret = jbd2_journal_bmap(journal, blocknr, &pblock); 891ff780b91SHarshad Shirwadkar if (ret) 892ff780b91SHarshad Shirwadkar return ret; 893ff780b91SHarshad Shirwadkar 894ff780b91SHarshad Shirwadkar bh = __getblk(journal->j_dev, pblock, journal->j_blocksize); 895ff780b91SHarshad Shirwadkar if (!bh) 896ff780b91SHarshad Shirwadkar return -ENOMEM; 897ff780b91SHarshad Shirwadkar 898ff780b91SHarshad Shirwadkar 899ff780b91SHarshad Shirwadkar journal->j_fc_wbuf[fc_off] = bh; 900ff780b91SHarshad Shirwadkar 901ff780b91SHarshad Shirwadkar *bh_out = bh; 902ff780b91SHarshad Shirwadkar 903ff780b91SHarshad Shirwadkar return 0; 904ff780b91SHarshad Shirwadkar } 905ff780b91SHarshad Shirwadkar EXPORT_SYMBOL(jbd2_fc_get_buf); 906ff780b91SHarshad Shirwadkar 907ff780b91SHarshad Shirwadkar /* 908ff780b91SHarshad Shirwadkar * Wait on fast commit buffers that were allocated by jbd2_fc_get_buf 909ff780b91SHarshad Shirwadkar * for completion. 910ff780b91SHarshad Shirwadkar */ 911ff780b91SHarshad Shirwadkar int jbd2_fc_wait_bufs(journal_t *journal, int num_blks) 912ff780b91SHarshad Shirwadkar { 913ff780b91SHarshad Shirwadkar struct buffer_head *bh; 914ff780b91SHarshad Shirwadkar int i, j_fc_off; 915ff780b91SHarshad Shirwadkar 916ff780b91SHarshad Shirwadkar j_fc_off = journal->j_fc_off; 917ff780b91SHarshad Shirwadkar 918ff780b91SHarshad Shirwadkar /* 919ff780b91SHarshad Shirwadkar * Wait in reverse order to minimize chances of us being woken up before 920ff780b91SHarshad Shirwadkar * all IOs have completed 921ff780b91SHarshad Shirwadkar */ 922ff780b91SHarshad Shirwadkar for (i = j_fc_off - 1; i >= j_fc_off - num_blks; i--) { 923ff780b91SHarshad Shirwadkar bh = journal->j_fc_wbuf[i]; 924ff780b91SHarshad Shirwadkar wait_on_buffer(bh); 925e0d5fc7aSYe Bin /* 926e0d5fc7aSYe Bin * Update j_fc_off so jbd2_fc_release_bufs can release remain 927e0d5fc7aSYe Bin * buffer head. 928e0d5fc7aSYe Bin */ 929e0d5fc7aSYe Bin if (unlikely(!buffer_uptodate(bh))) { 930243d1a5dSYe Bin journal->j_fc_off = i + 1; 931ff780b91SHarshad Shirwadkar return -EIO; 932ff780b91SHarshad Shirwadkar } 933243d1a5dSYe Bin put_bh(bh); 934243d1a5dSYe Bin journal->j_fc_wbuf[i] = NULL; 935e0d5fc7aSYe Bin } 936ff780b91SHarshad Shirwadkar 937ff780b91SHarshad Shirwadkar return 0; 938ff780b91SHarshad Shirwadkar } 939ff780b91SHarshad Shirwadkar EXPORT_SYMBOL(jbd2_fc_wait_bufs); 940ff780b91SHarshad Shirwadkar 941ff780b91SHarshad Shirwadkar int jbd2_fc_release_bufs(journal_t *journal) 942ff780b91SHarshad Shirwadkar { 943ff780b91SHarshad Shirwadkar struct buffer_head *bh; 944ff780b91SHarshad Shirwadkar int i, j_fc_off; 945ff780b91SHarshad Shirwadkar 946ff780b91SHarshad Shirwadkar j_fc_off = journal->j_fc_off; 947ff780b91SHarshad Shirwadkar 948ff780b91SHarshad Shirwadkar for (i = j_fc_off - 1; i >= 0; i--) { 949ff780b91SHarshad Shirwadkar bh = journal->j_fc_wbuf[i]; 950ff780b91SHarshad Shirwadkar if (!bh) 951ff780b91SHarshad Shirwadkar break; 952ff780b91SHarshad Shirwadkar put_bh(bh); 953ff780b91SHarshad Shirwadkar journal->j_fc_wbuf[i] = NULL; 954ff780b91SHarshad Shirwadkar } 955ff780b91SHarshad Shirwadkar 956ff780b91SHarshad Shirwadkar return 0; 957ff780b91SHarshad Shirwadkar } 958ff780b91SHarshad Shirwadkar EXPORT_SYMBOL(jbd2_fc_release_bufs); 959ff780b91SHarshad Shirwadkar 960470decc6SDave Kleikamp /* 961470decc6SDave Kleikamp * Conversion of logical to physical block numbers for the journal 962470decc6SDave Kleikamp * 963470decc6SDave Kleikamp * On external journals the journal blocks are identity-mapped, so 964470decc6SDave Kleikamp * this is a no-op. If needed, we can use j_blk_offset - everything is 965470decc6SDave Kleikamp * ready. 966470decc6SDave Kleikamp */ 967f7f4bccbSMingming Cao int jbd2_journal_bmap(journal_t *journal, unsigned long blocknr, 96818eba7aaSMingming Cao unsigned long long *retp) 969470decc6SDave Kleikamp { 970470decc6SDave Kleikamp int err = 0; 97118eba7aaSMingming Cao unsigned long long ret; 97262913ae9STheodore Ts'o sector_t block = blocknr; 973470decc6SDave Kleikamp 97462913ae9STheodore Ts'o if (journal->j_bmap) { 97562913ae9STheodore Ts'o err = journal->j_bmap(journal, &block); 97662913ae9STheodore Ts'o if (err == 0) 97762913ae9STheodore Ts'o *retp = block; 97862913ae9STheodore Ts'o } else if (journal->j_inode) { 97930460e1eSCarlos Maiolino ret = bmap(journal->j_inode, &block); 98030460e1eSCarlos Maiolino 98130460e1eSCarlos Maiolino if (ret || !block) { 982470decc6SDave Kleikamp printk(KERN_ALERT "%s: journal block not found " 983470decc6SDave Kleikamp "at offset %lu on %s\n", 98405496769STheodore Ts'o __func__, blocknr, journal->j_devname); 985470decc6SDave Kleikamp err = -EIO; 9867f6225e4Szhangyi (F) jbd2_journal_abort(journal, err); 98730460e1eSCarlos Maiolino } else { 98830460e1eSCarlos Maiolino *retp = block; 989470decc6SDave Kleikamp } 99030460e1eSCarlos Maiolino 991470decc6SDave Kleikamp } else { 992470decc6SDave Kleikamp *retp = blocknr; /* +journal->j_blk_offset */ 993470decc6SDave Kleikamp } 994470decc6SDave Kleikamp return err; 995470decc6SDave Kleikamp } 996470decc6SDave Kleikamp 997470decc6SDave Kleikamp /* 998470decc6SDave Kleikamp * We play buffer_head aliasing tricks to write data/metadata blocks to 999470decc6SDave Kleikamp * the journal without copying their contents, but for journal 1000470decc6SDave Kleikamp * descriptor blocks we do need to generate bona fide buffers. 1001470decc6SDave Kleikamp * 1002f7f4bccbSMingming Cao * After the caller of jbd2_journal_get_descriptor_buffer() has finished modifying 1003470decc6SDave Kleikamp * the buffer's contents they really should run flush_dcache_page(bh->b_page). 1004470decc6SDave Kleikamp * But we don't bother doing that, so there will be coherency problems with 1005470decc6SDave Kleikamp * mmaps of blockdevs which hold live JBD-controlled filesystems. 1006470decc6SDave Kleikamp */ 100732ab6715SJan Kara struct buffer_head * 100832ab6715SJan Kara jbd2_journal_get_descriptor_buffer(transaction_t *transaction, int type) 1009470decc6SDave Kleikamp { 101032ab6715SJan Kara journal_t *journal = transaction->t_journal; 1011470decc6SDave Kleikamp struct buffer_head *bh; 101218eba7aaSMingming Cao unsigned long long blocknr; 101332ab6715SJan Kara journal_header_t *header; 1014470decc6SDave Kleikamp int err; 1015470decc6SDave Kleikamp 1016f7f4bccbSMingming Cao err = jbd2_journal_next_log_block(journal, &blocknr); 1017470decc6SDave Kleikamp 1018470decc6SDave Kleikamp if (err) 1019470decc6SDave Kleikamp return NULL; 1020470decc6SDave Kleikamp 1021470decc6SDave Kleikamp bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize); 10224b905671SJan Kara if (!bh) 10234b905671SJan Kara return NULL; 10249f356e5aSJan Kara atomic_dec(&transaction->t_outstanding_credits); 1025470decc6SDave Kleikamp lock_buffer(bh); 1026470decc6SDave Kleikamp memset(bh->b_data, 0, journal->j_blocksize); 102732ab6715SJan Kara header = (journal_header_t *)bh->b_data; 102832ab6715SJan Kara header->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER); 102932ab6715SJan Kara header->h_blocktype = cpu_to_be32(type); 103032ab6715SJan Kara header->h_sequence = cpu_to_be32(transaction->t_tid); 1031470decc6SDave Kleikamp set_buffer_uptodate(bh); 1032470decc6SDave Kleikamp unlock_buffer(bh); 1033470decc6SDave Kleikamp BUFFER_TRACE(bh, "return this buffer"); 1034e5a120aeSJan Kara return bh; 1035470decc6SDave Kleikamp } 1036470decc6SDave Kleikamp 10371101cd4dSJan Kara void jbd2_descriptor_block_csum_set(journal_t *j, struct buffer_head *bh) 10381101cd4dSJan Kara { 10391101cd4dSJan Kara struct jbd2_journal_block_tail *tail; 10401101cd4dSJan Kara __u32 csum; 10411101cd4dSJan Kara 10421101cd4dSJan Kara if (!jbd2_journal_has_csum_v2or3(j)) 10431101cd4dSJan Kara return; 10441101cd4dSJan Kara 10451101cd4dSJan Kara tail = (struct jbd2_journal_block_tail *)(bh->b_data + j->j_blocksize - 10461101cd4dSJan Kara sizeof(struct jbd2_journal_block_tail)); 10471101cd4dSJan Kara tail->t_checksum = 0; 10481101cd4dSJan Kara csum = jbd2_chksum(j, j->j_csum_seed, bh->b_data, j->j_blocksize); 10491101cd4dSJan Kara tail->t_checksum = cpu_to_be32(csum); 10501101cd4dSJan Kara } 10511101cd4dSJan Kara 105279feb521SJan Kara /* 105379feb521SJan Kara * Return tid of the oldest transaction in the journal and block in the journal 105479feb521SJan Kara * where the transaction starts. 105579feb521SJan Kara * 105679feb521SJan Kara * If the journal is now empty, return which will be the next transaction ID 105779feb521SJan Kara * we will write and where will that transaction start. 105879feb521SJan Kara * 105979feb521SJan Kara * The return value is 0 if journal tail cannot be pushed any further, 1 if 106079feb521SJan Kara * it can. 106179feb521SJan Kara */ 106279feb521SJan Kara int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid, 106379feb521SJan Kara unsigned long *block) 106479feb521SJan Kara { 106579feb521SJan Kara transaction_t *transaction; 106679feb521SJan Kara int ret; 106779feb521SJan Kara 106879feb521SJan Kara read_lock(&journal->j_state_lock); 106979feb521SJan Kara spin_lock(&journal->j_list_lock); 107079feb521SJan Kara transaction = journal->j_checkpoint_transactions; 107179feb521SJan Kara if (transaction) { 107279feb521SJan Kara *tid = transaction->t_tid; 107379feb521SJan Kara *block = transaction->t_log_start; 107479feb521SJan Kara } else if ((transaction = journal->j_committing_transaction) != NULL) { 107579feb521SJan Kara *tid = transaction->t_tid; 107679feb521SJan Kara *block = transaction->t_log_start; 107779feb521SJan Kara } else if ((transaction = journal->j_running_transaction) != NULL) { 107879feb521SJan Kara *tid = transaction->t_tid; 107979feb521SJan Kara *block = journal->j_head; 108079feb521SJan Kara } else { 108179feb521SJan Kara *tid = journal->j_transaction_sequence; 108279feb521SJan Kara *block = journal->j_head; 108379feb521SJan Kara } 108479feb521SJan Kara ret = tid_gt(*tid, journal->j_tail_sequence); 108579feb521SJan Kara spin_unlock(&journal->j_list_lock); 108679feb521SJan Kara read_unlock(&journal->j_state_lock); 108779feb521SJan Kara 108879feb521SJan Kara return ret; 108979feb521SJan Kara } 109079feb521SJan Kara 109179feb521SJan Kara /* 109279feb521SJan Kara * Update information in journal structure and in on disk journal superblock 109379feb521SJan Kara * about log tail. This function does not check whether information passed in 109479feb521SJan Kara * really pushes log tail further. It's responsibility of the caller to make 109579feb521SJan Kara * sure provided log tail information is valid (e.g. by holding 109679feb521SJan Kara * j_checkpoint_mutex all the time between computing log tail and calling this 109779feb521SJan Kara * function as is the case with jbd2_cleanup_journal_tail()). 109879feb521SJan Kara * 109979feb521SJan Kara * Requires j_checkpoint_mutex 110079feb521SJan Kara */ 11016f6a6fdaSJoseph Qi int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block) 110279feb521SJan Kara { 110379feb521SJan Kara unsigned long freed; 11046f6a6fdaSJoseph Qi int ret; 110579feb521SJan Kara 110679feb521SJan Kara BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex)); 110779feb521SJan Kara 110879feb521SJan Kara /* 110979feb521SJan Kara * We cannot afford for write to remain in drive's caches since as 111079feb521SJan Kara * soon as we update j_tail, next transaction can start reusing journal 111179feb521SJan Kara * space and if we lose sb update during power failure we'd replay 111279feb521SJan Kara * old transaction with possibly newly overwritten data. 111379feb521SJan Kara */ 111417f423b5SJan Kara ret = jbd2_journal_update_sb_log_tail(journal, tid, block, 111517f423b5SJan Kara REQ_SYNC | REQ_FUA); 11166f6a6fdaSJoseph Qi if (ret) 11176f6a6fdaSJoseph Qi goto out; 11186f6a6fdaSJoseph Qi 111979feb521SJan Kara write_lock(&journal->j_state_lock); 112079feb521SJan Kara freed = block - journal->j_tail; 112179feb521SJan Kara if (block < journal->j_tail) 112279feb521SJan Kara freed += journal->j_last - journal->j_first; 112379feb521SJan Kara 112479feb521SJan Kara trace_jbd2_update_log_tail(journal, tid, block, freed); 1125cb3b3bf2SJan Kara jbd2_debug(1, 11267821ce41SGaowei Pu "Cleaning journal tail from %u to %u (offset %lu), " 112779feb521SJan Kara "freeing %lu\n", 112879feb521SJan Kara journal->j_tail_sequence, tid, block, freed); 112979feb521SJan Kara 113079feb521SJan Kara journal->j_free += freed; 113179feb521SJan Kara journal->j_tail_sequence = tid; 113279feb521SJan Kara journal->j_tail = block; 113379feb521SJan Kara write_unlock(&journal->j_state_lock); 11346f6a6fdaSJoseph Qi 11356f6a6fdaSJoseph Qi out: 11366f6a6fdaSJoseph Qi return ret; 113779feb521SJan Kara } 113879feb521SJan Kara 11393339578fSJan Kara /* 114085e0c4e8STheodore Ts'o * This is a variation of __jbd2_update_log_tail which checks for validity of 11413339578fSJan Kara * provided log tail and locks j_checkpoint_mutex. So it is safe against races 11423339578fSJan Kara * with other threads updating log tail. 11433339578fSJan Kara */ 11443339578fSJan Kara void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block) 11453339578fSJan Kara { 11466fa7aa50STejun Heo mutex_lock_io(&journal->j_checkpoint_mutex); 11473339578fSJan Kara if (tid_gt(tid, journal->j_tail_sequence)) 11483339578fSJan Kara __jbd2_update_log_tail(journal, tid, block); 11493339578fSJan Kara mutex_unlock(&journal->j_checkpoint_mutex); 11503339578fSJan Kara } 11513339578fSJan Kara 11528e85fb3fSJohann Lombardi struct jbd2_stats_proc_session { 11538e85fb3fSJohann Lombardi journal_t *journal; 11548e85fb3fSJohann Lombardi struct transaction_stats_s *stats; 11558e85fb3fSJohann Lombardi int start; 11568e85fb3fSJohann Lombardi int max; 11578e85fb3fSJohann Lombardi }; 11588e85fb3fSJohann Lombardi 11598e85fb3fSJohann Lombardi static void *jbd2_seq_info_start(struct seq_file *seq, loff_t *pos) 11608e85fb3fSJohann Lombardi { 11618e85fb3fSJohann Lombardi return *pos ? NULL : SEQ_START_TOKEN; 11628e85fb3fSJohann Lombardi } 11638e85fb3fSJohann Lombardi 11648e85fb3fSJohann Lombardi static void *jbd2_seq_info_next(struct seq_file *seq, void *v, loff_t *pos) 11658e85fb3fSJohann Lombardi { 11661a8e9cf4SVasily Averin (*pos)++; 11678e85fb3fSJohann Lombardi return NULL; 11688e85fb3fSJohann Lombardi } 11698e85fb3fSJohann Lombardi 11708e85fb3fSJohann Lombardi static int jbd2_seq_info_show(struct seq_file *seq, void *v) 11718e85fb3fSJohann Lombardi { 11728e85fb3fSJohann Lombardi struct jbd2_stats_proc_session *s = seq->private; 11738e85fb3fSJohann Lombardi 11748e85fb3fSJohann Lombardi if (v != SEQ_START_TOKEN) 11758e85fb3fSJohann Lombardi return 0; 11769fff24aaSTheodore Ts'o seq_printf(seq, "%lu transactions (%lu requested), " 11779fff24aaSTheodore Ts'o "each up to %u blocks\n", 11789fff24aaSTheodore Ts'o s->stats->ts_tid, s->stats->ts_requested, 11798e85fb3fSJohann Lombardi s->journal->j_max_transaction_buffers); 11808e85fb3fSJohann Lombardi if (s->stats->ts_tid == 0) 11818e85fb3fSJohann Lombardi return 0; 11828e85fb3fSJohann Lombardi seq_printf(seq, "average: \n %ums waiting for transaction\n", 1183bf699327STheodore Ts'o jiffies_to_msecs(s->stats->run.rs_wait / s->stats->ts_tid)); 11849fff24aaSTheodore Ts'o seq_printf(seq, " %ums request delay\n", 11859fff24aaSTheodore Ts'o (s->stats->ts_requested == 0) ? 0 : 11869fff24aaSTheodore Ts'o jiffies_to_msecs(s->stats->run.rs_request_delay / 11879fff24aaSTheodore Ts'o s->stats->ts_requested)); 11888e85fb3fSJohann Lombardi seq_printf(seq, " %ums running transaction\n", 1189bf699327STheodore Ts'o jiffies_to_msecs(s->stats->run.rs_running / s->stats->ts_tid)); 11908e85fb3fSJohann Lombardi seq_printf(seq, " %ums transaction was being locked\n", 1191bf699327STheodore Ts'o jiffies_to_msecs(s->stats->run.rs_locked / s->stats->ts_tid)); 11928e85fb3fSJohann Lombardi seq_printf(seq, " %ums flushing data (in ordered mode)\n", 1193bf699327STheodore Ts'o jiffies_to_msecs(s->stats->run.rs_flushing / s->stats->ts_tid)); 11948e85fb3fSJohann Lombardi seq_printf(seq, " %ums logging transaction\n", 1195bf699327STheodore Ts'o jiffies_to_msecs(s->stats->run.rs_logging / s->stats->ts_tid)); 1196c225aa57SSimon Holm Thøgersen seq_printf(seq, " %lluus average transaction commit time\n", 1197c225aa57SSimon Holm Thøgersen div_u64(s->journal->j_average_commit_time, 1000)); 11988e85fb3fSJohann Lombardi seq_printf(seq, " %lu handles per transaction\n", 1199bf699327STheodore Ts'o s->stats->run.rs_handle_count / s->stats->ts_tid); 12008e85fb3fSJohann Lombardi seq_printf(seq, " %lu blocks per transaction\n", 1201bf699327STheodore Ts'o s->stats->run.rs_blocks / s->stats->ts_tid); 12028e85fb3fSJohann Lombardi seq_printf(seq, " %lu logged blocks per transaction\n", 1203bf699327STheodore Ts'o s->stats->run.rs_blocks_logged / s->stats->ts_tid); 12048e85fb3fSJohann Lombardi return 0; 12058e85fb3fSJohann Lombardi } 12068e85fb3fSJohann Lombardi 12078e85fb3fSJohann Lombardi static void jbd2_seq_info_stop(struct seq_file *seq, void *v) 12088e85fb3fSJohann Lombardi { 12098e85fb3fSJohann Lombardi } 12108e85fb3fSJohann Lombardi 121188e9d34cSJames Morris static const struct seq_operations jbd2_seq_info_ops = { 12128e85fb3fSJohann Lombardi .start = jbd2_seq_info_start, 12138e85fb3fSJohann Lombardi .next = jbd2_seq_info_next, 12148e85fb3fSJohann Lombardi .stop = jbd2_seq_info_stop, 12158e85fb3fSJohann Lombardi .show = jbd2_seq_info_show, 12168e85fb3fSJohann Lombardi }; 12178e85fb3fSJohann Lombardi 12188e85fb3fSJohann Lombardi static int jbd2_seq_info_open(struct inode *inode, struct file *file) 12198e85fb3fSJohann Lombardi { 1220359745d7SMuchun Song journal_t *journal = pde_data(inode); 12218e85fb3fSJohann Lombardi struct jbd2_stats_proc_session *s; 12228e85fb3fSJohann Lombardi int rc, size; 12238e85fb3fSJohann Lombardi 12248e85fb3fSJohann Lombardi s = kmalloc(sizeof(*s), GFP_KERNEL); 12258e85fb3fSJohann Lombardi if (s == NULL) 12268e85fb3fSJohann Lombardi return -ENOMEM; 12278e85fb3fSJohann Lombardi size = sizeof(struct transaction_stats_s); 12288e85fb3fSJohann Lombardi s->stats = kmalloc(size, GFP_KERNEL); 12298e85fb3fSJohann Lombardi if (s->stats == NULL) { 12308e85fb3fSJohann Lombardi kfree(s); 12318e85fb3fSJohann Lombardi return -ENOMEM; 12328e85fb3fSJohann Lombardi } 12338e85fb3fSJohann Lombardi spin_lock(&journal->j_history_lock); 12348e85fb3fSJohann Lombardi memcpy(s->stats, &journal->j_stats, size); 12358e85fb3fSJohann Lombardi s->journal = journal; 12368e85fb3fSJohann Lombardi spin_unlock(&journal->j_history_lock); 12378e85fb3fSJohann Lombardi 12388e85fb3fSJohann Lombardi rc = seq_open(file, &jbd2_seq_info_ops); 12398e85fb3fSJohann Lombardi if (rc == 0) { 12408e85fb3fSJohann Lombardi struct seq_file *m = file->private_data; 12418e85fb3fSJohann Lombardi m->private = s; 12428e85fb3fSJohann Lombardi } else { 12438e85fb3fSJohann Lombardi kfree(s->stats); 12448e85fb3fSJohann Lombardi kfree(s); 12458e85fb3fSJohann Lombardi } 12468e85fb3fSJohann Lombardi return rc; 12478e85fb3fSJohann Lombardi 12488e85fb3fSJohann Lombardi } 12498e85fb3fSJohann Lombardi 12508e85fb3fSJohann Lombardi static int jbd2_seq_info_release(struct inode *inode, struct file *file) 12518e85fb3fSJohann Lombardi { 12528e85fb3fSJohann Lombardi struct seq_file *seq = file->private_data; 12538e85fb3fSJohann Lombardi struct jbd2_stats_proc_session *s = seq->private; 12548e85fb3fSJohann Lombardi kfree(s->stats); 12558e85fb3fSJohann Lombardi kfree(s); 12568e85fb3fSJohann Lombardi return seq_release(inode, file); 12578e85fb3fSJohann Lombardi } 12588e85fb3fSJohann Lombardi 125997a32539SAlexey Dobriyan static const struct proc_ops jbd2_info_proc_ops = { 126097a32539SAlexey Dobriyan .proc_open = jbd2_seq_info_open, 126197a32539SAlexey Dobriyan .proc_read = seq_read, 126297a32539SAlexey Dobriyan .proc_lseek = seq_lseek, 126397a32539SAlexey Dobriyan .proc_release = jbd2_seq_info_release, 12648e85fb3fSJohann Lombardi }; 12658e85fb3fSJohann Lombardi 12668e85fb3fSJohann Lombardi static struct proc_dir_entry *proc_jbd2_stats; 12678e85fb3fSJohann Lombardi 12688e85fb3fSJohann Lombardi static void jbd2_stats_proc_init(journal_t *journal) 12698e85fb3fSJohann Lombardi { 127005496769STheodore Ts'o journal->j_proc_entry = proc_mkdir(journal->j_devname, proc_jbd2_stats); 12718e85fb3fSJohann Lombardi if (journal->j_proc_entry) { 127279da3664SDenis V. Lunev proc_create_data("info", S_IRUGO, journal->j_proc_entry, 127397a32539SAlexey Dobriyan &jbd2_info_proc_ops, journal); 12748e85fb3fSJohann Lombardi } 12758e85fb3fSJohann Lombardi } 12768e85fb3fSJohann Lombardi 12778e85fb3fSJohann Lombardi static void jbd2_stats_proc_exit(journal_t *journal) 12788e85fb3fSJohann Lombardi { 12798e85fb3fSJohann Lombardi remove_proc_entry("info", journal->j_proc_entry); 128005496769STheodore Ts'o remove_proc_entry(journal->j_devname, proc_jbd2_stats); 12818e85fb3fSJohann Lombardi } 12828e85fb3fSJohann Lombardi 1283b90bfdf5SJan Kara /* Minimum size of descriptor tag */ 1284b90bfdf5SJan Kara static int jbd2_min_tag_size(void) 1285b90bfdf5SJan Kara { 1286b90bfdf5SJan Kara /* 1287b90bfdf5SJan Kara * Tag with 32-bit block numbers does not use last four bytes of the 1288b90bfdf5SJan Kara * structure 1289b90bfdf5SJan Kara */ 1290b90bfdf5SJan Kara return sizeof(journal_block_tag_t) - 4; 1291b90bfdf5SJan Kara } 1292b90bfdf5SJan Kara 12930705e8d1STheodore Ts'o /** 12940705e8d1STheodore Ts'o * jbd2_journal_shrink_scan() 1295715a67f1SYang Li * @shrink: shrinker to work on 1296715a67f1SYang Li * @sc: reclaim request to process 12970705e8d1STheodore Ts'o * 12980705e8d1STheodore Ts'o * Scan the checkpointed buffer on the checkpoint list and release the 12990705e8d1STheodore Ts'o * journal_head. 13000705e8d1STheodore Ts'o */ 13010705e8d1STheodore Ts'o static unsigned long jbd2_journal_shrink_scan(struct shrinker *shrink, 13020705e8d1STheodore Ts'o struct shrink_control *sc) 13030705e8d1STheodore Ts'o { 13040705e8d1STheodore Ts'o journal_t *journal = container_of(shrink, journal_t, j_shrinker); 13050705e8d1STheodore Ts'o unsigned long nr_to_scan = sc->nr_to_scan; 13060705e8d1STheodore Ts'o unsigned long nr_shrunk; 13070705e8d1STheodore Ts'o unsigned long count; 13080705e8d1STheodore Ts'o 13090705e8d1STheodore Ts'o count = percpu_counter_read_positive(&journal->j_checkpoint_jh_count); 13100705e8d1STheodore Ts'o trace_jbd2_shrink_scan_enter(journal, sc->nr_to_scan, count); 13110705e8d1STheodore Ts'o 13120705e8d1STheodore Ts'o nr_shrunk = jbd2_journal_shrink_checkpoint_list(journal, &nr_to_scan); 13130705e8d1STheodore Ts'o 13140705e8d1STheodore Ts'o count = percpu_counter_read_positive(&journal->j_checkpoint_jh_count); 13150705e8d1STheodore Ts'o trace_jbd2_shrink_scan_exit(journal, nr_to_scan, nr_shrunk, count); 13160705e8d1STheodore Ts'o 13170705e8d1STheodore Ts'o return nr_shrunk; 13180705e8d1STheodore Ts'o } 13190705e8d1STheodore Ts'o 13200705e8d1STheodore Ts'o /** 13210705e8d1STheodore Ts'o * jbd2_journal_shrink_count() 1322715a67f1SYang Li * @shrink: shrinker to work on 1323715a67f1SYang Li * @sc: reclaim request to process 13240705e8d1STheodore Ts'o * 13250705e8d1STheodore Ts'o * Count the number of checkpoint buffers on the checkpoint list. 13260705e8d1STheodore Ts'o */ 13270705e8d1STheodore Ts'o static unsigned long jbd2_journal_shrink_count(struct shrinker *shrink, 13280705e8d1STheodore Ts'o struct shrink_control *sc) 13290705e8d1STheodore Ts'o { 13300705e8d1STheodore Ts'o journal_t *journal = container_of(shrink, journal_t, j_shrinker); 13310705e8d1STheodore Ts'o unsigned long count; 13320705e8d1STheodore Ts'o 13330705e8d1STheodore Ts'o count = percpu_counter_read_positive(&journal->j_checkpoint_jh_count); 13340705e8d1STheodore Ts'o trace_jbd2_shrink_count(journal, sc->nr_to_scan, count); 13350705e8d1STheodore Ts'o 13360705e8d1STheodore Ts'o return count; 13370705e8d1STheodore Ts'o } 13380705e8d1STheodore Ts'o 1339470decc6SDave Kleikamp /* 1340470decc6SDave Kleikamp * Management for journal control blocks: functions to create and 1341470decc6SDave Kleikamp * destroy journal_t structures, and to initialise and read existing 1342470decc6SDave Kleikamp * journal blocks from disk. */ 1343470decc6SDave Kleikamp 1344470decc6SDave Kleikamp /* First: create and setup a journal_t object in memory. We initialise 1345470decc6SDave Kleikamp * very few fields yet: that has to wait until we have created the 1346470decc6SDave Kleikamp * journal structures from from scratch, or loaded them from disk. */ 1347470decc6SDave Kleikamp 1348f0c9fd54SGeliang Tang static journal_t *journal_init_common(struct block_device *bdev, 1349f0c9fd54SGeliang Tang struct block_device *fs_dev, 1350f0c9fd54SGeliang Tang unsigned long long start, int len, int blocksize) 1351470decc6SDave Kleikamp { 1352ab714affSJan Kara static struct lock_class_key jbd2_trans_commit_key; 1353470decc6SDave Kleikamp journal_t *journal; 1354470decc6SDave Kleikamp int err; 1355f0c9fd54SGeliang Tang struct buffer_head *bh; 1356f0c9fd54SGeliang Tang int n; 1357470decc6SDave Kleikamp 13583ebfdf88SAndrew Morton journal = kzalloc(sizeof(*journal), GFP_KERNEL); 1359470decc6SDave Kleikamp if (!journal) 1360b7271b0aSTheodore Ts'o return NULL; 1361470decc6SDave Kleikamp 1362470decc6SDave Kleikamp init_waitqueue_head(&journal->j_wait_transaction_locked); 1363470decc6SDave Kleikamp init_waitqueue_head(&journal->j_wait_done_commit); 1364470decc6SDave Kleikamp init_waitqueue_head(&journal->j_wait_commit); 1365470decc6SDave Kleikamp init_waitqueue_head(&journal->j_wait_updates); 13668f7d89f3SJan Kara init_waitqueue_head(&journal->j_wait_reserved); 1367ff780b91SHarshad Shirwadkar init_waitqueue_head(&journal->j_fc_wait); 13687b97d868Szhangyi (F) mutex_init(&journal->j_abort_mutex); 1369470decc6SDave Kleikamp mutex_init(&journal->j_barrier); 1370470decc6SDave Kleikamp mutex_init(&journal->j_checkpoint_mutex); 1371470decc6SDave Kleikamp spin_lock_init(&journal->j_revoke_lock); 1372470decc6SDave Kleikamp spin_lock_init(&journal->j_list_lock); 1373a931da6aSTheodore Ts'o rwlock_init(&journal->j_state_lock); 1374470decc6SDave Kleikamp 1375cd02ff0bSMingming Cao journal->j_commit_interval = (HZ * JBD2_DEFAULT_MAX_COMMIT_AGE); 137630773840STheodore Ts'o journal->j_min_batch_time = 0; 137730773840STheodore Ts'o journal->j_max_batch_time = 15000; /* 15ms */ 13788f7d89f3SJan Kara atomic_set(&journal->j_reserved_credits, 0); 1379470decc6SDave Kleikamp 1380470decc6SDave Kleikamp /* The journal is marked for error until we succeed with recovery! */ 1381f7f4bccbSMingming Cao journal->j_flags = JBD2_ABORT; 1382470decc6SDave Kleikamp 1383470decc6SDave Kleikamp /* Set up a default-sized revoke table for the new mount. */ 1384f7f4bccbSMingming Cao err = jbd2_journal_init_revoke(journal, JOURNAL_REVOKE_DEFAULT_HASH); 1385cd9cb405SEric Biggers if (err) 1386cd9cb405SEric Biggers goto err_cleanup; 13878e85fb3fSJohann Lombardi 1388bf699327STheodore Ts'o spin_lock_init(&journal->j_history_lock); 13898e85fb3fSJohann Lombardi 1390ab714affSJan Kara lockdep_init_map(&journal->j_trans_commit_map, "jbd2_handle", 1391ab714affSJan Kara &jbd2_trans_commit_key, 0); 1392ab714affSJan Kara 1393f0c9fd54SGeliang Tang /* journal descriptor can store up to n blocks -bzzz */ 1394f0c9fd54SGeliang Tang journal->j_blocksize = blocksize; 1395f0c9fd54SGeliang Tang journal->j_dev = bdev; 1396f0c9fd54SGeliang Tang journal->j_fs_dev = fs_dev; 1397f0c9fd54SGeliang Tang journal->j_blk_offset = start; 1398ede7dc7fSHarshad Shirwadkar journal->j_total_len = len; 1399b90bfdf5SJan Kara /* We need enough buffers to write out full descriptor block. */ 1400b90bfdf5SJan Kara n = journal->j_blocksize / jbd2_min_tag_size(); 1401f0c9fd54SGeliang Tang journal->j_wbufsize = n; 1402a1e5e465SHarshad Shirwadkar journal->j_fc_wbuf = NULL; 1403f0c9fd54SGeliang Tang journal->j_wbuf = kmalloc_array(n, sizeof(struct buffer_head *), 1404f0c9fd54SGeliang Tang GFP_KERNEL); 1405cd9cb405SEric Biggers if (!journal->j_wbuf) 1406cd9cb405SEric Biggers goto err_cleanup; 1407f0c9fd54SGeliang Tang 1408f0c9fd54SGeliang Tang bh = getblk_unmovable(journal->j_dev, start, journal->j_blocksize); 1409f0c9fd54SGeliang Tang if (!bh) { 1410f0c9fd54SGeliang Tang pr_err("%s: Cannot get buffer for journal superblock\n", 1411f0c9fd54SGeliang Tang __func__); 1412cd9cb405SEric Biggers goto err_cleanup; 1413f0c9fd54SGeliang Tang } 1414f0c9fd54SGeliang Tang journal->j_sb_buffer = bh; 1415f0c9fd54SGeliang Tang journal->j_superblock = (journal_superblock_t *)bh->b_data; 1416f0c9fd54SGeliang Tang 14170705e8d1STheodore Ts'o journal->j_shrink_transaction = NULL; 14180705e8d1STheodore Ts'o journal->j_shrinker.scan_objects = jbd2_journal_shrink_scan; 14190705e8d1STheodore Ts'o journal->j_shrinker.count_objects = jbd2_journal_shrink_count; 14200705e8d1STheodore Ts'o journal->j_shrinker.seeks = DEFAULT_SEEKS; 14210705e8d1STheodore Ts'o journal->j_shrinker.batch = journal->j_max_transaction_buffers; 14220705e8d1STheodore Ts'o 14230705e8d1STheodore Ts'o if (percpu_counter_init(&journal->j_checkpoint_jh_count, 0, GFP_KERNEL)) 14240705e8d1STheodore Ts'o goto err_cleanup; 14250705e8d1STheodore Ts'o 1426e33c267aSRoman Gushchin if (register_shrinker(&journal->j_shrinker, "jbd2-journal:(%u:%u)", 1427e33c267aSRoman Gushchin MAJOR(bdev->bd_dev), MINOR(bdev->bd_dev))) { 14280705e8d1STheodore Ts'o percpu_counter_destroy(&journal->j_checkpoint_jh_count); 14290705e8d1STheodore Ts'o goto err_cleanup; 14300705e8d1STheodore Ts'o } 1431470decc6SDave Kleikamp return journal; 1432cd9cb405SEric Biggers 1433cd9cb405SEric Biggers err_cleanup: 14340705e8d1STheodore Ts'o brelse(journal->j_sb_buffer); 1435cd9cb405SEric Biggers kfree(journal->j_wbuf); 1436cd9cb405SEric Biggers jbd2_journal_destroy_revoke(journal); 1437cd9cb405SEric Biggers kfree(journal); 1438cd9cb405SEric Biggers return NULL; 1439470decc6SDave Kleikamp } 1440470decc6SDave Kleikamp 1441f7f4bccbSMingming Cao /* jbd2_journal_init_dev and jbd2_journal_init_inode: 1442470decc6SDave Kleikamp * 1443470decc6SDave Kleikamp * Create a journal structure assigned some fixed set of disk blocks to 1444470decc6SDave Kleikamp * the journal. We don't actually touch those disk blocks yet, but we 1445470decc6SDave Kleikamp * need to set up all of the mapping information to tell the journaling 1446470decc6SDave Kleikamp * system where the journal blocks are. 1447470decc6SDave Kleikamp * 1448470decc6SDave Kleikamp */ 1449470decc6SDave Kleikamp 1450470decc6SDave Kleikamp /** 14515648ba5bSRandy Dunlap * journal_t * jbd2_journal_init_dev() - creates and initialises a journal structure 1452470decc6SDave Kleikamp * @bdev: Block device on which to create the journal 1453470decc6SDave Kleikamp * @fs_dev: Device which hold journalled filesystem for this journal. 1454470decc6SDave Kleikamp * @start: Block nr Start of journal. 1455470decc6SDave Kleikamp * @len: Length of the journal in blocks. 1456470decc6SDave Kleikamp * @blocksize: blocksize of journalling device 14575648ba5bSRandy Dunlap * 14585648ba5bSRandy Dunlap * Returns: a newly created journal_t * 1459470decc6SDave Kleikamp * 1460f7f4bccbSMingming Cao * jbd2_journal_init_dev creates a journal which maps a fixed contiguous 1461470decc6SDave Kleikamp * range of blocks on an arbitrary block device. 1462470decc6SDave Kleikamp * 1463470decc6SDave Kleikamp */ 1464f7f4bccbSMingming Cao journal_t *jbd2_journal_init_dev(struct block_device *bdev, 1465470decc6SDave Kleikamp struct block_device *fs_dev, 146618eba7aaSMingming Cao unsigned long long start, int len, int blocksize) 1467470decc6SDave Kleikamp { 1468f0c9fd54SGeliang Tang journal_t *journal; 1469470decc6SDave Kleikamp 1470f0c9fd54SGeliang Tang journal = journal_init_common(bdev, fs_dev, start, len, blocksize); 1471470decc6SDave Kleikamp if (!journal) 1472470decc6SDave Kleikamp return NULL; 1473470decc6SDave Kleikamp 1474900d156bSChristoph Hellwig snprintf(journal->j_devname, sizeof(journal->j_devname), 1475900d156bSChristoph Hellwig "%pg", journal->j_dev); 147681ae394bSRasmus Villemoes strreplace(journal->j_devname, '/', '!'); 14774b905671SJan Kara jbd2_stats_proc_init(journal); 14784b905671SJan Kara 1479470decc6SDave Kleikamp return journal; 1480470decc6SDave Kleikamp } 1481470decc6SDave Kleikamp 1482470decc6SDave Kleikamp /** 1483f7f4bccbSMingming Cao * journal_t * jbd2_journal_init_inode () - creates a journal which maps to a inode. 1484470decc6SDave Kleikamp * @inode: An inode to create the journal in 1485470decc6SDave Kleikamp * 1486f7f4bccbSMingming Cao * jbd2_journal_init_inode creates a journal which maps an on-disk inode as 1487470decc6SDave Kleikamp * the journal. The inode must exist already, must support bmap() and 1488470decc6SDave Kleikamp * must have all data blocks preallocated. 1489470decc6SDave Kleikamp */ 1490f7f4bccbSMingming Cao journal_t *jbd2_journal_init_inode(struct inode *inode) 1491470decc6SDave Kleikamp { 1492f0c9fd54SGeliang Tang journal_t *journal; 149330460e1eSCarlos Maiolino sector_t blocknr; 149405496769STheodore Ts'o char *p; 149530460e1eSCarlos Maiolino int err = 0; 1496470decc6SDave Kleikamp 149730460e1eSCarlos Maiolino blocknr = 0; 149830460e1eSCarlos Maiolino err = bmap(inode, &blocknr); 149930460e1eSCarlos Maiolino 150030460e1eSCarlos Maiolino if (err || !blocknr) { 1501f0c9fd54SGeliang Tang pr_err("%s: Cannot locate journal superblock\n", 1502f0c9fd54SGeliang Tang __func__); 1503f0c9fd54SGeliang Tang return NULL; 1504f0c9fd54SGeliang Tang } 1505f0c9fd54SGeliang Tang 1506cb3b3bf2SJan Kara jbd2_debug(1, "JBD2: inode %s/%ld, size %lld, bits %d, blksize %ld\n", 1507f0c9fd54SGeliang Tang inode->i_sb->s_id, inode->i_ino, (long long) inode->i_size, 1508f0c9fd54SGeliang Tang inode->i_sb->s_blocksize_bits, inode->i_sb->s_blocksize); 1509f0c9fd54SGeliang Tang 1510f0c9fd54SGeliang Tang journal = journal_init_common(inode->i_sb->s_bdev, inode->i_sb->s_bdev, 1511f0c9fd54SGeliang Tang blocknr, inode->i_size >> inode->i_sb->s_blocksize_bits, 1512f0c9fd54SGeliang Tang inode->i_sb->s_blocksize); 1513470decc6SDave Kleikamp if (!journal) 1514470decc6SDave Kleikamp return NULL; 1515470decc6SDave Kleikamp 1516470decc6SDave Kleikamp journal->j_inode = inode; 1517900d156bSChristoph Hellwig snprintf(journal->j_devname, sizeof(journal->j_devname), 1518900d156bSChristoph Hellwig "%pg", journal->j_dev); 151981ae394bSRasmus Villemoes p = strreplace(journal->j_devname, '/', '!'); 152090576c0bSTheodore Ts'o sprintf(p, "-%lu", journal->j_inode->i_ino); 15218e85fb3fSJohann Lombardi jbd2_stats_proc_init(journal); 1522470decc6SDave Kleikamp 1523470decc6SDave Kleikamp return journal; 1524470decc6SDave Kleikamp } 1525470decc6SDave Kleikamp 1526470decc6SDave Kleikamp /* 1527470decc6SDave Kleikamp * If the journal init or create aborts, we need to mark the journal 1528470decc6SDave Kleikamp * superblock as being NULL to prevent the journal destroy from writing 1529470decc6SDave Kleikamp * back a bogus superblock. 1530470decc6SDave Kleikamp */ 1531470decc6SDave Kleikamp static void journal_fail_superblock(journal_t *journal) 1532470decc6SDave Kleikamp { 1533470decc6SDave Kleikamp struct buffer_head *bh = journal->j_sb_buffer; 1534470decc6SDave Kleikamp brelse(bh); 1535470decc6SDave Kleikamp journal->j_sb_buffer = NULL; 1536470decc6SDave Kleikamp } 1537470decc6SDave Kleikamp 1538470decc6SDave Kleikamp /* 1539470decc6SDave Kleikamp * Given a journal_t structure, initialise the various fields for 1540470decc6SDave Kleikamp * startup of a new journaling session. We use this both when creating 1541470decc6SDave Kleikamp * a journal, and after recovering an old journal to reset it for 1542470decc6SDave Kleikamp * subsequent use. 1543470decc6SDave Kleikamp */ 1544470decc6SDave Kleikamp 1545470decc6SDave Kleikamp static int journal_reset(journal_t *journal) 1546470decc6SDave Kleikamp { 1547470decc6SDave Kleikamp journal_superblock_t *sb = journal->j_superblock; 154818eba7aaSMingming Cao unsigned long long first, last; 1549470decc6SDave Kleikamp 1550470decc6SDave Kleikamp first = be32_to_cpu(sb->s_first); 1551470decc6SDave Kleikamp last = be32_to_cpu(sb->s_maxlen); 1552f6f50e28SJan Kara if (first + JBD2_MIN_JOURNAL_BLOCKS > last + 1) { 1553f2a44523SEryu Guan printk(KERN_ERR "JBD2: Journal too short (blocks %llu-%llu).\n", 1554f6f50e28SJan Kara first, last); 1555f6f50e28SJan Kara journal_fail_superblock(journal); 1556f6f50e28SJan Kara return -EINVAL; 1557f6f50e28SJan Kara } 1558470decc6SDave Kleikamp 1559470decc6SDave Kleikamp journal->j_first = first; 15606866d7b3SHarshad Shirwadkar journal->j_last = last; 15616866d7b3SHarshad Shirwadkar 1562*c7fc6055SZhang Yi if (journal->j_head != 0 && journal->j_flags & JBD2_CYCLE_RECORD) { 1563*c7fc6055SZhang Yi /* 1564*c7fc6055SZhang Yi * Disable the cycled recording mode if the journal head block 1565*c7fc6055SZhang Yi * number is not correct. 1566*c7fc6055SZhang Yi */ 1567*c7fc6055SZhang Yi if (journal->j_head < first || journal->j_head >= last) { 1568*c7fc6055SZhang Yi printk(KERN_WARNING "JBD2: Incorrect Journal head block %lu, " 1569*c7fc6055SZhang Yi "disable journal_cycle_record\n", 1570*c7fc6055SZhang Yi journal->j_head); 15716866d7b3SHarshad Shirwadkar journal->j_head = journal->j_first; 1572*c7fc6055SZhang Yi } 1573*c7fc6055SZhang Yi } else { 1574*c7fc6055SZhang Yi journal->j_head = journal->j_first; 1575*c7fc6055SZhang Yi } 1576*c7fc6055SZhang Yi journal->j_tail = journal->j_head; 15776866d7b3SHarshad Shirwadkar journal->j_free = journal->j_last - journal->j_first; 1578470decc6SDave Kleikamp 1579470decc6SDave Kleikamp journal->j_tail_sequence = journal->j_transaction_sequence; 1580470decc6SDave Kleikamp journal->j_commit_sequence = journal->j_transaction_sequence - 1; 1581470decc6SDave Kleikamp journal->j_commit_request = journal->j_commit_sequence; 1582470decc6SDave Kleikamp 1583ede7dc7fSHarshad Shirwadkar journal->j_max_transaction_buffers = jbd2_journal_get_max_txn_bufs(journal); 1584470decc6SDave Kleikamp 1585470decc6SDave Kleikamp /* 1586a1e5e465SHarshad Shirwadkar * Now that journal recovery is done, turn fast commits off here. This 1587a1e5e465SHarshad Shirwadkar * way, if fast commit was enabled before the crash but if now FS has 1588a1e5e465SHarshad Shirwadkar * disabled it, we don't enable fast commits. 1589a1e5e465SHarshad Shirwadkar */ 1590a1e5e465SHarshad Shirwadkar jbd2_clear_feature_fast_commit(journal); 1591a1e5e465SHarshad Shirwadkar 1592a1e5e465SHarshad Shirwadkar /* 1593470decc6SDave Kleikamp * As a special case, if the on-disk copy is already marked as needing 159424bcc89cSJan Kara * no recovery (s_start == 0), then we can safely defer the superblock 159524bcc89cSJan Kara * update until the next commit by setting JBD2_FLUSHED. This avoids 1596470decc6SDave Kleikamp * attempting a write to a potential-readonly device. 1597470decc6SDave Kleikamp */ 159824bcc89cSJan Kara if (sb->s_start == 0) { 1599cb3b3bf2SJan Kara jbd2_debug(1, "JBD2: Skipping superblock update on recovered sb " 16007821ce41SGaowei Pu "(start %ld, seq %u, errno %d)\n", 1601470decc6SDave Kleikamp journal->j_tail, journal->j_tail_sequence, 1602470decc6SDave Kleikamp journal->j_errno); 160324bcc89cSJan Kara journal->j_flags |= JBD2_FLUSHED; 160424bcc89cSJan Kara } else { 1605a78bb11dSJan Kara /* Lock here to make assertions happy... */ 16066fa7aa50STejun Heo mutex_lock_io(&journal->j_checkpoint_mutex); 160779feb521SJan Kara /* 160870fd7614SChristoph Hellwig * Update log tail information. We use REQ_FUA since new 160979feb521SJan Kara * transaction will start reusing journal space and so we 161079feb521SJan Kara * must make sure information about current log tail is on 161179feb521SJan Kara * disk before that. 161279feb521SJan Kara */ 161379feb521SJan Kara jbd2_journal_update_sb_log_tail(journal, 161479feb521SJan Kara journal->j_tail_sequence, 161579feb521SJan Kara journal->j_tail, 161617f423b5SJan Kara REQ_SYNC | REQ_FUA); 1617a78bb11dSJan Kara mutex_unlock(&journal->j_checkpoint_mutex); 161824bcc89cSJan Kara } 161924bcc89cSJan Kara return jbd2_journal_start_thread(journal); 1620470decc6SDave Kleikamp } 1621470decc6SDave Kleikamp 1622538bcaa6STheodore Ts'o /* 1623538bcaa6STheodore Ts'o * This function expects that the caller will have locked the journal 1624538bcaa6STheodore Ts'o * buffer head, and will return with it unlocked 1625538bcaa6STheodore Ts'o */ 16266669797bSBart Van Assche static int jbd2_write_superblock(journal_t *journal, blk_opf_t write_flags) 162724bcc89cSJan Kara { 162824bcc89cSJan Kara struct buffer_head *bh = journal->j_sb_buffer; 1629fe52d17cSTheodore Ts'o journal_superblock_t *sb = journal->j_superblock; 1630f3ed5df3SRitesh Harjani (IBM) int ret = 0; 163124bcc89cSJan Kara 1632742b06b5SJiufei Xue /* Buffer got discarded which means block device got invalidated */ 1633ef3f5830Szhangyi (F) if (!buffer_mapped(bh)) { 1634ef3f5830Szhangyi (F) unlock_buffer(bh); 1635742b06b5SJiufei Xue return -EIO; 1636ef3f5830Szhangyi (F) } 1637742b06b5SJiufei Xue 16382a222ca9SMike Christie trace_jbd2_write_superblock(journal, write_flags); 163979feb521SJan Kara if (!(journal->j_flags & JBD2_BARRIER)) 164028a8f0d3SMike Christie write_flags &= ~(REQ_FUA | REQ_PREFLUSH); 1641914258bfSTheodore Ts'o if (buffer_write_io_error(bh)) { 1642914258bfSTheodore Ts'o /* 1643914258bfSTheodore Ts'o * Oh, dear. A previous attempt to write the journal 1644914258bfSTheodore Ts'o * superblock failed. This could happen because the 1645914258bfSTheodore Ts'o * USB device was yanked out. Or it could happen to 1646914258bfSTheodore Ts'o * be a transient write error and maybe the block will 1647914258bfSTheodore Ts'o * be remapped. Nothing we can do but to retry the 1648914258bfSTheodore Ts'o * write and hope for the best. 1649914258bfSTheodore Ts'o */ 1650914258bfSTheodore Ts'o printk(KERN_ERR "JBD2: previous I/O error detected " 1651914258bfSTheodore Ts'o "for journal superblock update for %s.\n", 1652914258bfSTheodore Ts'o journal->j_devname); 1653914258bfSTheodore Ts'o clear_buffer_write_io_error(bh); 1654914258bfSTheodore Ts'o set_buffer_uptodate(bh); 1655914258bfSTheodore Ts'o } 1656a58ca992STheodore Ts'o if (jbd2_journal_has_csum_v2or3(journal)) 1657a58ca992STheodore Ts'o sb->s_checksum = jbd2_superblock_csum(journal, sb); 165879feb521SJan Kara get_bh(bh); 165979feb521SJan Kara bh->b_end_io = end_buffer_write_sync; 1660f3ed5df3SRitesh Harjani (IBM) submit_bh(REQ_OP_WRITE | write_flags, bh); 166179feb521SJan Kara wait_on_buffer(bh); 1662914258bfSTheodore Ts'o if (buffer_write_io_error(bh)) { 1663914258bfSTheodore Ts'o clear_buffer_write_io_error(bh); 1664914258bfSTheodore Ts'o set_buffer_uptodate(bh); 166579feb521SJan Kara ret = -EIO; 166679feb521SJan Kara } 166779feb521SJan Kara if (ret) { 1668f3ed5df3SRitesh Harjani (IBM) printk(KERN_ERR "JBD2: I/O error when updating journal superblock for %s.\n", 166979feb521SJan Kara journal->j_devname); 16707b97d868Szhangyi (F) if (!is_journal_aborted(journal)) 16716f6a6fdaSJoseph Qi jbd2_journal_abort(journal, ret); 1672914258bfSTheodore Ts'o } 16736f6a6fdaSJoseph Qi 16746f6a6fdaSJoseph Qi return ret; 167524bcc89cSJan Kara } 1676470decc6SDave Kleikamp 167724bcc89cSJan Kara /** 167824bcc89cSJan Kara * jbd2_journal_update_sb_log_tail() - Update log tail in journal sb on disk. 167924bcc89cSJan Kara * @journal: The journal to update. 168079feb521SJan Kara * @tail_tid: TID of the new transaction at the tail of the log 168179feb521SJan Kara * @tail_block: The first block of the transaction at the tail of the log 16826669797bSBart Van Assche * @write_flags: Flags for the journal sb write operation 168324bcc89cSJan Kara * 168424bcc89cSJan Kara * Update a journal's superblock information about log tail and write it to 168524bcc89cSJan Kara * disk, waiting for the IO to complete. 168624bcc89cSJan Kara */ 16876f6a6fdaSJoseph Qi int jbd2_journal_update_sb_log_tail(journal_t *journal, tid_t tail_tid, 16886669797bSBart Van Assche unsigned long tail_block, 16896669797bSBart Van Assche blk_opf_t write_flags) 169024bcc89cSJan Kara { 169124bcc89cSJan Kara journal_superblock_t *sb = journal->j_superblock; 16926f6a6fdaSJoseph Qi int ret; 16932201c590SSeiji Aguchi 169485e0c4e8STheodore Ts'o if (is_journal_aborted(journal)) 169585e0c4e8STheodore Ts'o return -EIO; 1696fcf37549SZhang Yi if (test_bit(JBD2_CHECKPOINT_IO_ERROR, &journal->j_atomic_flags)) { 1697fcf37549SZhang Yi jbd2_journal_abort(journal, -EIO); 1698fcf37549SZhang Yi return -EIO; 1699fcf37549SZhang Yi } 170085e0c4e8STheodore Ts'o 1701a78bb11dSJan Kara BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex)); 1702cb3b3bf2SJan Kara jbd2_debug(1, "JBD2: updating superblock (start %lu, seq %u)\n", 170379feb521SJan Kara tail_block, tail_tid); 1704470decc6SDave Kleikamp 1705538bcaa6STheodore Ts'o lock_buffer(journal->j_sb_buffer); 170679feb521SJan Kara sb->s_sequence = cpu_to_be32(tail_tid); 170779feb521SJan Kara sb->s_start = cpu_to_be32(tail_block); 170824bcc89cSJan Kara 17096669797bSBart Van Assche ret = jbd2_write_superblock(journal, write_flags); 17106f6a6fdaSJoseph Qi if (ret) 17116f6a6fdaSJoseph Qi goto out; 171224bcc89cSJan Kara 171324bcc89cSJan Kara /* Log is no longer empty */ 1714a931da6aSTheodore Ts'o write_lock(&journal->j_state_lock); 171524bcc89cSJan Kara WARN_ON(!sb->s_sequence); 1716f7f4bccbSMingming Cao journal->j_flags &= ~JBD2_FLUSHED; 171724bcc89cSJan Kara write_unlock(&journal->j_state_lock); 17186f6a6fdaSJoseph Qi 17196f6a6fdaSJoseph Qi out: 17206f6a6fdaSJoseph Qi return ret; 172124bcc89cSJan Kara } 172224bcc89cSJan Kara 172324bcc89cSJan Kara /** 172424bcc89cSJan Kara * jbd2_mark_journal_empty() - Mark on disk journal as empty. 172524bcc89cSJan Kara * @journal: The journal to update. 17266669797bSBart Van Assche * @write_flags: Flags for the journal sb write operation 172724bcc89cSJan Kara * 172824bcc89cSJan Kara * Update a journal's dynamic superblock fields to show that journal is empty. 172924bcc89cSJan Kara * Write updated superblock to disk waiting for IO to complete. 173024bcc89cSJan Kara */ 17316669797bSBart Van Assche static void jbd2_mark_journal_empty(journal_t *journal, blk_opf_t write_flags) 173224bcc89cSJan Kara { 173324bcc89cSJan Kara journal_superblock_t *sb = journal->j_superblock; 1734ff780b91SHarshad Shirwadkar bool had_fast_commit = false; 173524bcc89cSJan Kara 1736a78bb11dSJan Kara BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex)); 1737538bcaa6STheodore Ts'o lock_buffer(journal->j_sb_buffer); 1738538bcaa6STheodore Ts'o if (sb->s_start == 0) { /* Is it already empty? */ 1739538bcaa6STheodore Ts'o unlock_buffer(journal->j_sb_buffer); 1740eeecef0aSEric Sandeen return; 1741eeecef0aSEric Sandeen } 1742538bcaa6STheodore Ts'o 1743cb3b3bf2SJan Kara jbd2_debug(1, "JBD2: Marking journal as empty (seq %u)\n", 174424bcc89cSJan Kara journal->j_tail_sequence); 1745470decc6SDave Kleikamp 1746470decc6SDave Kleikamp sb->s_sequence = cpu_to_be32(journal->j_tail_sequence); 174724bcc89cSJan Kara sb->s_start = cpu_to_be32(0); 1748*c7fc6055SZhang Yi sb->s_head = cpu_to_be32(journal->j_head); 1749ff780b91SHarshad Shirwadkar if (jbd2_has_feature_fast_commit(journal)) { 1750ff780b91SHarshad Shirwadkar /* 1751ff780b91SHarshad Shirwadkar * When journal is clean, no need to commit fast commit flag and 1752ff780b91SHarshad Shirwadkar * make file system incompatible with older kernels. 1753ff780b91SHarshad Shirwadkar */ 1754ff780b91SHarshad Shirwadkar jbd2_clear_feature_fast_commit(journal); 1755ff780b91SHarshad Shirwadkar had_fast_commit = true; 1756ff780b91SHarshad Shirwadkar } 175724bcc89cSJan Kara 17586669797bSBart Van Assche jbd2_write_superblock(journal, write_flags); 175924bcc89cSJan Kara 1760ff780b91SHarshad Shirwadkar if (had_fast_commit) 1761ff780b91SHarshad Shirwadkar jbd2_set_feature_fast_commit(journal); 1762ff780b91SHarshad Shirwadkar 176324bcc89cSJan Kara /* Log is no longer empty */ 176424bcc89cSJan Kara write_lock(&journal->j_state_lock); 1765f7f4bccbSMingming Cao journal->j_flags |= JBD2_FLUSHED; 1766a931da6aSTheodore Ts'o write_unlock(&journal->j_state_lock); 1767470decc6SDave Kleikamp } 1768470decc6SDave Kleikamp 176901d5d965SLeah Rumancik /** 177001d5d965SLeah Rumancik * __jbd2_journal_erase() - Discard or zeroout journal blocks (excluding superblock) 177101d5d965SLeah Rumancik * @journal: The journal to erase. 177201d5d965SLeah Rumancik * @flags: A discard/zeroout request is sent for each physically contigous 177301d5d965SLeah Rumancik * region of the journal. Either JBD2_JOURNAL_FLUSH_DISCARD or 177401d5d965SLeah Rumancik * JBD2_JOURNAL_FLUSH_ZEROOUT must be set to determine which operation 177501d5d965SLeah Rumancik * to perform. 177601d5d965SLeah Rumancik * 177701d5d965SLeah Rumancik * Note: JBD2_JOURNAL_FLUSH_ZEROOUT attempts to use hardware offload. Zeroes 177801d5d965SLeah Rumancik * will be explicitly written if no hardware offload is available, see 177901d5d965SLeah Rumancik * blkdev_issue_zeroout for more details. 178001d5d965SLeah Rumancik */ 178101d5d965SLeah Rumancik static int __jbd2_journal_erase(journal_t *journal, unsigned int flags) 178201d5d965SLeah Rumancik { 178301d5d965SLeah Rumancik int err = 0; 178401d5d965SLeah Rumancik unsigned long block, log_offset; /* logical */ 178501d5d965SLeah Rumancik unsigned long long phys_block, block_start, block_stop; /* physical */ 178601d5d965SLeah Rumancik loff_t byte_start, byte_stop, byte_count; 178701d5d965SLeah Rumancik 178801d5d965SLeah Rumancik /* flags must be set to either discard or zeroout */ 178901d5d965SLeah Rumancik if ((flags & ~JBD2_JOURNAL_FLUSH_VALID) || !flags || 179001d5d965SLeah Rumancik ((flags & JBD2_JOURNAL_FLUSH_DISCARD) && 179101d5d965SLeah Rumancik (flags & JBD2_JOURNAL_FLUSH_ZEROOUT))) 179201d5d965SLeah Rumancik return -EINVAL; 179301d5d965SLeah Rumancik 179470200574SChristoph Hellwig if ((flags & JBD2_JOURNAL_FLUSH_DISCARD) && 179570200574SChristoph Hellwig !bdev_max_discard_sectors(journal->j_dev)) 179601d5d965SLeah Rumancik return -EOPNOTSUPP; 179701d5d965SLeah Rumancik 179801d5d965SLeah Rumancik /* 179901d5d965SLeah Rumancik * lookup block mapping and issue discard/zeroout for each 180001d5d965SLeah Rumancik * contiguous region 180101d5d965SLeah Rumancik */ 180201d5d965SLeah Rumancik log_offset = be32_to_cpu(journal->j_superblock->s_first); 180301d5d965SLeah Rumancik block_start = ~0ULL; 180401d5d965SLeah Rumancik for (block = log_offset; block < journal->j_total_len; block++) { 180501d5d965SLeah Rumancik err = jbd2_journal_bmap(journal, block, &phys_block); 180601d5d965SLeah Rumancik if (err) { 180701d5d965SLeah Rumancik pr_err("JBD2: bad block at offset %lu", block); 180801d5d965SLeah Rumancik return err; 180901d5d965SLeah Rumancik } 181001d5d965SLeah Rumancik 181101d5d965SLeah Rumancik if (block_start == ~0ULL) { 181201d5d965SLeah Rumancik block_start = phys_block; 181301d5d965SLeah Rumancik block_stop = block_start - 1; 181401d5d965SLeah Rumancik } 181501d5d965SLeah Rumancik 181601d5d965SLeah Rumancik /* 181701d5d965SLeah Rumancik * last block not contiguous with current block, 181801d5d965SLeah Rumancik * process last contiguous region and return to this block on 181901d5d965SLeah Rumancik * next loop 182001d5d965SLeah Rumancik */ 182101d5d965SLeah Rumancik if (phys_block != block_stop + 1) { 182201d5d965SLeah Rumancik block--; 182301d5d965SLeah Rumancik } else { 182401d5d965SLeah Rumancik block_stop++; 182501d5d965SLeah Rumancik /* 182601d5d965SLeah Rumancik * if this isn't the last block of journal, 182701d5d965SLeah Rumancik * no need to process now because next block may also 182801d5d965SLeah Rumancik * be part of this contiguous region 182901d5d965SLeah Rumancik */ 183001d5d965SLeah Rumancik if (block != journal->j_total_len - 1) 183101d5d965SLeah Rumancik continue; 183201d5d965SLeah Rumancik } 183301d5d965SLeah Rumancik 183401d5d965SLeah Rumancik /* 183501d5d965SLeah Rumancik * end of contiguous region or this is last block of journal, 183601d5d965SLeah Rumancik * take care of the region 183701d5d965SLeah Rumancik */ 183801d5d965SLeah Rumancik byte_start = block_start * journal->j_blocksize; 183901d5d965SLeah Rumancik byte_stop = block_stop * journal->j_blocksize; 184001d5d965SLeah Rumancik byte_count = (block_stop - block_start + 1) * 184101d5d965SLeah Rumancik journal->j_blocksize; 184201d5d965SLeah Rumancik 184301d5d965SLeah Rumancik truncate_inode_pages_range(journal->j_dev->bd_inode->i_mapping, 184401d5d965SLeah Rumancik byte_start, byte_stop); 184501d5d965SLeah Rumancik 184601d5d965SLeah Rumancik if (flags & JBD2_JOURNAL_FLUSH_DISCARD) { 184701d5d965SLeah Rumancik err = blkdev_issue_discard(journal->j_dev, 184801d5d965SLeah Rumancik byte_start >> SECTOR_SHIFT, 184901d5d965SLeah Rumancik byte_count >> SECTOR_SHIFT, 185044abff2cSChristoph Hellwig GFP_NOFS); 185101d5d965SLeah Rumancik } else if (flags & JBD2_JOURNAL_FLUSH_ZEROOUT) { 185201d5d965SLeah Rumancik err = blkdev_issue_zeroout(journal->j_dev, 185301d5d965SLeah Rumancik byte_start >> SECTOR_SHIFT, 185401d5d965SLeah Rumancik byte_count >> SECTOR_SHIFT, 185501d5d965SLeah Rumancik GFP_NOFS, 0); 185601d5d965SLeah Rumancik } 185701d5d965SLeah Rumancik 185801d5d965SLeah Rumancik if (unlikely(err != 0)) { 185901d5d965SLeah Rumancik pr_err("JBD2: (error %d) unable to wipe journal at physical blocks %llu - %llu", 186001d5d965SLeah Rumancik err, block_start, block_stop); 186101d5d965SLeah Rumancik return err; 186201d5d965SLeah Rumancik } 186301d5d965SLeah Rumancik 186401d5d965SLeah Rumancik /* reset start and stop after processing a region */ 186501d5d965SLeah Rumancik block_start = ~0ULL; 186601d5d965SLeah Rumancik } 186701d5d965SLeah Rumancik 186801d5d965SLeah Rumancik return blkdev_issue_flush(journal->j_dev); 186901d5d965SLeah Rumancik } 187024bcc89cSJan Kara 187124bcc89cSJan Kara /** 187224bcc89cSJan Kara * jbd2_journal_update_sb_errno() - Update error in the journal. 187324bcc89cSJan Kara * @journal: The journal to update. 187424bcc89cSJan Kara * 187524bcc89cSJan Kara * Update a journal's errno. Write updated superblock to disk waiting for IO 187624bcc89cSJan Kara * to complete. 187724bcc89cSJan Kara */ 1878d796c52eSTheodore Ts'o void jbd2_journal_update_sb_errno(journal_t *journal) 187924bcc89cSJan Kara { 188024bcc89cSJan Kara journal_superblock_t *sb = journal->j_superblock; 1881fb7c0244STheodore Ts'o int errcode; 188224bcc89cSJan Kara 1883538bcaa6STheodore Ts'o lock_buffer(journal->j_sb_buffer); 1884fb7c0244STheodore Ts'o errcode = journal->j_errno; 1885fb7c0244STheodore Ts'o if (errcode == -ESHUTDOWN) 1886fb7c0244STheodore Ts'o errcode = 0; 1887cb3b3bf2SJan Kara jbd2_debug(1, "JBD2: updating superblock error (errno %d)\n", errcode); 1888fb7c0244STheodore Ts'o sb->s_errno = cpu_to_be32(errcode); 1889470decc6SDave Kleikamp 189017f423b5SJan Kara jbd2_write_superblock(journal, REQ_SYNC | REQ_FUA); 1891470decc6SDave Kleikamp } 1892d796c52eSTheodore Ts'o EXPORT_SYMBOL(jbd2_journal_update_sb_errno); 1893470decc6SDave Kleikamp 1894fdc3ef88SJan Kara static int journal_revoke_records_per_block(journal_t *journal) 1895fdc3ef88SJan Kara { 1896fdc3ef88SJan Kara int record_size; 1897fdc3ef88SJan Kara int space = journal->j_blocksize - sizeof(jbd2_journal_revoke_header_t); 1898fdc3ef88SJan Kara 1899fdc3ef88SJan Kara if (jbd2_has_feature_64bit(journal)) 1900fdc3ef88SJan Kara record_size = 8; 1901fdc3ef88SJan Kara else 1902fdc3ef88SJan Kara record_size = 4; 1903fdc3ef88SJan Kara 1904fdc3ef88SJan Kara if (jbd2_journal_has_csum_v2or3(journal)) 1905fdc3ef88SJan Kara space -= sizeof(struct jbd2_journal_block_tail); 1906fdc3ef88SJan Kara return space / record_size; 1907fdc3ef88SJan Kara } 1908fdc3ef88SJan Kara 1909470decc6SDave Kleikamp /* 1910470decc6SDave Kleikamp * Read the superblock for a given journal, performing initial 1911470decc6SDave Kleikamp * validation of the format. 1912470decc6SDave Kleikamp */ 1913470decc6SDave Kleikamp static int journal_get_superblock(journal_t *journal) 1914470decc6SDave Kleikamp { 1915470decc6SDave Kleikamp struct buffer_head *bh; 1916470decc6SDave Kleikamp journal_superblock_t *sb; 19178c004d1fSZhang Yi int err; 1918470decc6SDave Kleikamp 1919470decc6SDave Kleikamp bh = journal->j_sb_buffer; 1920470decc6SDave Kleikamp 1921470decc6SDave Kleikamp J_ASSERT(bh != NULL); 19228c004d1fSZhang Yi err = bh_read(bh, 0); 19238c004d1fSZhang Yi if (err < 0) { 1924470decc6SDave Kleikamp printk(KERN_ERR 1925f2a44523SEryu Guan "JBD2: IO error reading journal superblock\n"); 1926470decc6SDave Kleikamp goto out; 1927470decc6SDave Kleikamp } 1928470decc6SDave Kleikamp 192925ed6e8aSDarrick J. Wong if (buffer_verified(bh)) 193025ed6e8aSDarrick J. Wong return 0; 193125ed6e8aSDarrick J. Wong 1932470decc6SDave Kleikamp sb = journal->j_superblock; 1933470decc6SDave Kleikamp 1934470decc6SDave Kleikamp err = -EINVAL; 1935470decc6SDave Kleikamp 1936f7f4bccbSMingming Cao if (sb->s_header.h_magic != cpu_to_be32(JBD2_MAGIC_NUMBER) || 1937470decc6SDave Kleikamp sb->s_blocksize != cpu_to_be32(journal->j_blocksize)) { 1938f2a44523SEryu Guan printk(KERN_WARNING "JBD2: no valid journal superblock found\n"); 1939470decc6SDave Kleikamp goto out; 1940470decc6SDave Kleikamp } 1941470decc6SDave Kleikamp 19423e5cf02cSZhang Yi if (be32_to_cpu(sb->s_header.h_blocktype) != JBD2_SUPERBLOCK_V1 && 19433e5cf02cSZhang Yi be32_to_cpu(sb->s_header.h_blocktype) != JBD2_SUPERBLOCK_V2) { 1944f2a44523SEryu Guan printk(KERN_WARNING "JBD2: unrecognised superblock format ID\n"); 1945470decc6SDave Kleikamp goto out; 1946470decc6SDave Kleikamp } 1947470decc6SDave Kleikamp 19483e5cf02cSZhang Yi if (be32_to_cpu(sb->s_maxlen) > journal->j_total_len) { 1949f2a44523SEryu Guan printk(KERN_WARNING "JBD2: journal file too short\n"); 1950470decc6SDave Kleikamp goto out; 1951470decc6SDave Kleikamp } 1952470decc6SDave Kleikamp 19538762202dSEryu Guan if (be32_to_cpu(sb->s_first) == 0 || 1954ede7dc7fSHarshad Shirwadkar be32_to_cpu(sb->s_first) >= journal->j_total_len) { 19558762202dSEryu Guan printk(KERN_WARNING 19568762202dSEryu Guan "JBD2: Invalid start block of journal: %u\n", 19578762202dSEryu Guan be32_to_cpu(sb->s_first)); 19588762202dSEryu Guan goto out; 19598762202dSEryu Guan } 19608762202dSEryu Guan 196156316a0dSDarrick J. Wong if (jbd2_has_feature_csum2(journal) && 196256316a0dSDarrick J. Wong jbd2_has_feature_csum3(journal)) { 1963db9ee220SDarrick J. Wong /* Can't have checksum v2 and v3 at the same time! */ 1964db9ee220SDarrick J. Wong printk(KERN_ERR "JBD2: Can't enable checksumming v2 and v3 " 1965db9ee220SDarrick J. Wong "at the same time!\n"); 1966db9ee220SDarrick J. Wong goto out; 1967db9ee220SDarrick J. Wong } 1968db9ee220SDarrick J. Wong 19698595798cSDarrick J. Wong if (jbd2_journal_has_csum_v2or3_feature(journal) && 197056316a0dSDarrick J. Wong jbd2_has_feature_checksum(journal)) { 1971feb8c6d3SDarrick J. Wong /* Can't have checksum v1 and v2 on at the same time! */ 1972feb8c6d3SDarrick J. Wong printk(KERN_ERR "JBD2: Can't enable checksumming v1 and v2/3 " 1973feb8c6d3SDarrick J. Wong "at the same time!\n"); 1974feb8c6d3SDarrick J. Wong goto out; 1975feb8c6d3SDarrick J. Wong } 1976feb8c6d3SDarrick J. Wong 197725ed6e8aSDarrick J. Wong if (!jbd2_verify_csum_type(journal, sb)) { 1978a67c848aSDmitry Monakhov printk(KERN_ERR "JBD2: Unknown checksum type\n"); 197925ed6e8aSDarrick J. Wong goto out; 198025ed6e8aSDarrick J. Wong } 198125ed6e8aSDarrick J. Wong 198201b5adceSDarrick J. Wong /* Load the checksum driver */ 19838595798cSDarrick J. Wong if (jbd2_journal_has_csum_v2or3_feature(journal)) { 198401b5adceSDarrick J. Wong journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0); 198501b5adceSDarrick J. Wong if (IS_ERR(journal->j_chksum_driver)) { 1986a67c848aSDmitry Monakhov printk(KERN_ERR "JBD2: Cannot load crc32c driver.\n"); 198701b5adceSDarrick J. Wong err = PTR_ERR(journal->j_chksum_driver); 198801b5adceSDarrick J. Wong journal->j_chksum_driver = NULL; 198901b5adceSDarrick J. Wong goto out; 199001b5adceSDarrick J. Wong } 19914fd5ea43SDarrick J. Wong /* Check superblock checksum */ 1992a58ca992STheodore Ts'o if (sb->s_checksum != jbd2_superblock_csum(journal, sb)) { 1993a67c848aSDmitry Monakhov printk(KERN_ERR "JBD2: journal checksum error\n"); 19946a797d27SDarrick J. Wong err = -EFSBADCRC; 19954fd5ea43SDarrick J. Wong goto out; 19964fd5ea43SDarrick J. Wong } 1997a58ca992STheodore Ts'o } 199825ed6e8aSDarrick J. Wong set_buffer_verified(bh); 1999470decc6SDave Kleikamp return 0; 2000470decc6SDave Kleikamp 2001470decc6SDave Kleikamp out: 2002470decc6SDave Kleikamp journal_fail_superblock(journal); 2003470decc6SDave Kleikamp return err; 2004470decc6SDave Kleikamp } 2005470decc6SDave Kleikamp 2006470decc6SDave Kleikamp /* 2007470decc6SDave Kleikamp * Load the on-disk journal superblock and read the key fields into the 2008470decc6SDave Kleikamp * journal_t. 2009470decc6SDave Kleikamp */ 2010470decc6SDave Kleikamp 2011470decc6SDave Kleikamp static int load_superblock(journal_t *journal) 2012470decc6SDave Kleikamp { 2013470decc6SDave Kleikamp int err; 2014470decc6SDave Kleikamp journal_superblock_t *sb; 2015a1e5e465SHarshad Shirwadkar int num_fc_blocks; 2016470decc6SDave Kleikamp 2017470decc6SDave Kleikamp err = journal_get_superblock(journal); 2018470decc6SDave Kleikamp if (err) 2019470decc6SDave Kleikamp return err; 2020470decc6SDave Kleikamp 2021470decc6SDave Kleikamp sb = journal->j_superblock; 2022470decc6SDave Kleikamp 2023470decc6SDave Kleikamp journal->j_tail_sequence = be32_to_cpu(sb->s_sequence); 2024470decc6SDave Kleikamp journal->j_tail = be32_to_cpu(sb->s_start); 2025470decc6SDave Kleikamp journal->j_first = be32_to_cpu(sb->s_first); 2026470decc6SDave Kleikamp journal->j_errno = be32_to_cpu(sb->s_errno); 2027a1e5e465SHarshad Shirwadkar journal->j_last = be32_to_cpu(sb->s_maxlen); 2028470decc6SDave Kleikamp 20293e5cf02cSZhang Yi if (be32_to_cpu(sb->s_maxlen) < journal->j_total_len) 20303e5cf02cSZhang Yi journal->j_total_len = be32_to_cpu(sb->s_maxlen); 20313e5cf02cSZhang Yi /* Precompute checksum seed for all metadata */ 20323e5cf02cSZhang Yi if (jbd2_journal_has_csum_v2or3(journal)) 20333e5cf02cSZhang Yi journal->j_csum_seed = jbd2_chksum(journal, ~0, sb->s_uuid, 20343e5cf02cSZhang Yi sizeof(sb->s_uuid)); 20353e5cf02cSZhang Yi journal->j_revoke_records_per_block = 20363e5cf02cSZhang Yi journal_revoke_records_per_block(journal); 20373e5cf02cSZhang Yi 2038a1e5e465SHarshad Shirwadkar if (jbd2_has_feature_fast_commit(journal)) { 20396866d7b3SHarshad Shirwadkar journal->j_fc_last = be32_to_cpu(sb->s_maxlen); 20409bd23c31SHarshad Shirwadkar num_fc_blocks = jbd2_journal_get_num_fc_blks(sb); 2041a1e5e465SHarshad Shirwadkar if (journal->j_last - num_fc_blocks >= JBD2_MIN_JOURNAL_BLOCKS) 2042a1e5e465SHarshad Shirwadkar journal->j_last = journal->j_fc_last - num_fc_blocks; 20436866d7b3SHarshad Shirwadkar journal->j_fc_first = journal->j_last + 1; 20446866d7b3SHarshad Shirwadkar journal->j_fc_off = 0; 20456866d7b3SHarshad Shirwadkar } 20466866d7b3SHarshad Shirwadkar 2047470decc6SDave Kleikamp return 0; 2048470decc6SDave Kleikamp } 2049470decc6SDave Kleikamp 2050470decc6SDave Kleikamp 2051470decc6SDave Kleikamp /** 20522bf31d94SMauro Carvalho Chehab * jbd2_journal_load() - Read journal from disk. 2053470decc6SDave Kleikamp * @journal: Journal to act on. 2054470decc6SDave Kleikamp * 2055470decc6SDave Kleikamp * Given a journal_t structure which tells us which disk blocks contain 2056470decc6SDave Kleikamp * a journal, read the journal from disk to initialise the in-memory 2057470decc6SDave Kleikamp * structures. 2058470decc6SDave Kleikamp */ 2059f7f4bccbSMingming Cao int jbd2_journal_load(journal_t *journal) 2060470decc6SDave Kleikamp { 2061470decc6SDave Kleikamp int err; 2062470decc6SDave Kleikamp journal_superblock_t *sb; 2063470decc6SDave Kleikamp 2064470decc6SDave Kleikamp err = load_superblock(journal); 2065470decc6SDave Kleikamp if (err) 2066470decc6SDave Kleikamp return err; 2067470decc6SDave Kleikamp 2068470decc6SDave Kleikamp sb = journal->j_superblock; 2069470decc6SDave Kleikamp 20705cf036d4SZhang Yi /* 20715cf036d4SZhang Yi * If this is a V2 superblock, then we have to check the 20725cf036d4SZhang Yi * features flags on it. 20735cf036d4SZhang Yi */ 20745cf036d4SZhang Yi if (jbd2_format_support_feature(journal)) { 2075470decc6SDave Kleikamp if ((sb->s_feature_ro_compat & 2076f7f4bccbSMingming Cao ~cpu_to_be32(JBD2_KNOWN_ROCOMPAT_FEATURES)) || 2077470decc6SDave Kleikamp (sb->s_feature_incompat & 2078f7f4bccbSMingming Cao ~cpu_to_be32(JBD2_KNOWN_INCOMPAT_FEATURES))) { 2079470decc6SDave Kleikamp printk(KERN_WARNING 2080f2a44523SEryu Guan "JBD2: Unrecognised features on journal\n"); 2081470decc6SDave Kleikamp return -EINVAL; 2082470decc6SDave Kleikamp } 2083470decc6SDave Kleikamp } 2084470decc6SDave Kleikamp 2085d2eecb03STheodore Ts'o /* 2086d2eecb03STheodore Ts'o * Create a slab for this blocksize 2087d2eecb03STheodore Ts'o */ 2088d2eecb03STheodore Ts'o err = jbd2_journal_create_slab(be32_to_cpu(sb->s_blocksize)); 2089d2eecb03STheodore Ts'o if (err) 2090d2eecb03STheodore Ts'o return err; 2091d2eecb03STheodore Ts'o 2092470decc6SDave Kleikamp /* Let the recovery code check whether it needs to recover any 2093470decc6SDave Kleikamp * data from the journal. */ 2094f7f4bccbSMingming Cao if (jbd2_journal_recover(journal)) 2095470decc6SDave Kleikamp goto recovery_error; 2096470decc6SDave Kleikamp 2097e6a47428STheodore Ts'o if (journal->j_failed_commit) { 2098e6a47428STheodore Ts'o printk(KERN_ERR "JBD2: journal transaction %u on %s " 2099e6a47428STheodore Ts'o "is corrupt.\n", journal->j_failed_commit, 2100e6a47428STheodore Ts'o journal->j_devname); 21016a797d27SDarrick J. Wong return -EFSCORRUPTED; 2102e6a47428STheodore Ts'o } 2103a09decffSKai Li /* 2104a09decffSKai Li * clear JBD2_ABORT flag initialized in journal_init_common 2105a09decffSKai Li * here to update log tail information with the newest seq. 2106a09decffSKai Li */ 2107a09decffSKai Li journal->j_flags &= ~JBD2_ABORT; 2108e6a47428STheodore Ts'o 2109470decc6SDave Kleikamp /* OK, we've finished with the dynamic journal bits: 2110470decc6SDave Kleikamp * reinitialise the dynamic contents of the superblock in memory 2111470decc6SDave Kleikamp * and reset them on disk. */ 2112470decc6SDave Kleikamp if (journal_reset(journal)) 2113470decc6SDave Kleikamp goto recovery_error; 2114470decc6SDave Kleikamp 2115f7f4bccbSMingming Cao journal->j_flags |= JBD2_LOADED; 2116470decc6SDave Kleikamp return 0; 2117470decc6SDave Kleikamp 2118470decc6SDave Kleikamp recovery_error: 2119f2a44523SEryu Guan printk(KERN_WARNING "JBD2: recovery failed\n"); 2120470decc6SDave Kleikamp return -EIO; 2121470decc6SDave Kleikamp } 2122470decc6SDave Kleikamp 2123470decc6SDave Kleikamp /** 21242bf31d94SMauro Carvalho Chehab * jbd2_journal_destroy() - Release a journal_t structure. 2125470decc6SDave Kleikamp * @journal: Journal to act on. 2126470decc6SDave Kleikamp * 2127470decc6SDave Kleikamp * Release a journal_t structure once it is no longer in use by the 2128470decc6SDave Kleikamp * journaled object. 212944519fafSHidehiro Kawai * Return <0 if we couldn't clean up the journal. 2130470decc6SDave Kleikamp */ 213144519fafSHidehiro Kawai int jbd2_journal_destroy(journal_t *journal) 2132470decc6SDave Kleikamp { 213344519fafSHidehiro Kawai int err = 0; 213444519fafSHidehiro Kawai 2135470decc6SDave Kleikamp /* Wait for the commit thread to wake up and die. */ 2136470decc6SDave Kleikamp journal_kill_thread(journal); 2137470decc6SDave Kleikamp 2138470decc6SDave Kleikamp /* Force a final log commit */ 2139470decc6SDave Kleikamp if (journal->j_running_transaction) 2140f7f4bccbSMingming Cao jbd2_journal_commit_transaction(journal); 2141470decc6SDave Kleikamp 2142470decc6SDave Kleikamp /* Force any old transactions to disk */ 2143470decc6SDave Kleikamp 2144470decc6SDave Kleikamp /* Totally anal locking here... */ 2145470decc6SDave Kleikamp spin_lock(&journal->j_list_lock); 2146470decc6SDave Kleikamp while (journal->j_checkpoint_transactions != NULL) { 2147470decc6SDave Kleikamp spin_unlock(&journal->j_list_lock); 21486fa7aa50STejun Heo mutex_lock_io(&journal->j_checkpoint_mutex); 2149841df7dfSJan Kara err = jbd2_log_do_checkpoint(journal); 21501a0d3786STheodore Ts'o mutex_unlock(&journal->j_checkpoint_mutex); 2151841df7dfSJan Kara /* 2152841df7dfSJan Kara * If checkpointing failed, just free the buffers to avoid 2153841df7dfSJan Kara * looping forever 2154841df7dfSJan Kara */ 2155841df7dfSJan Kara if (err) { 2156841df7dfSJan Kara jbd2_journal_destroy_checkpoint(journal); 2157841df7dfSJan Kara spin_lock(&journal->j_list_lock); 2158841df7dfSJan Kara break; 2159841df7dfSJan Kara } 2160470decc6SDave Kleikamp spin_lock(&journal->j_list_lock); 2161470decc6SDave Kleikamp } 2162470decc6SDave Kleikamp 2163470decc6SDave Kleikamp J_ASSERT(journal->j_running_transaction == NULL); 2164470decc6SDave Kleikamp J_ASSERT(journal->j_committing_transaction == NULL); 2165470decc6SDave Kleikamp J_ASSERT(journal->j_checkpoint_transactions == NULL); 2166470decc6SDave Kleikamp spin_unlock(&journal->j_list_lock); 2167470decc6SDave Kleikamp 2168fcf37549SZhang Yi /* 2169fcf37549SZhang Yi * OK, all checkpoint transactions have been checked, now check the 2170fcf37549SZhang Yi * write out io error flag and abort the journal if some buffer failed 2171fcf37549SZhang Yi * to write back to the original location, otherwise the filesystem 2172fcf37549SZhang Yi * may become inconsistent. 2173fcf37549SZhang Yi */ 2174fcf37549SZhang Yi if (!is_journal_aborted(journal) && 2175fcf37549SZhang Yi test_bit(JBD2_CHECKPOINT_IO_ERROR, &journal->j_atomic_flags)) 2176fcf37549SZhang Yi jbd2_journal_abort(journal, -EIO); 2177fcf37549SZhang Yi 217844519fafSHidehiro Kawai if (journal->j_sb_buffer) { 217944519fafSHidehiro Kawai if (!is_journal_aborted(journal)) { 21806fa7aa50STejun Heo mutex_lock_io(&journal->j_checkpoint_mutex); 2181c0a2ad9bSOGAWA Hirofumi 2182c0a2ad9bSOGAWA Hirofumi write_lock(&journal->j_state_lock); 2183c0a2ad9bSOGAWA Hirofumi journal->j_tail_sequence = 2184c0a2ad9bSOGAWA Hirofumi ++journal->j_transaction_sequence; 2185c0a2ad9bSOGAWA Hirofumi write_unlock(&journal->j_state_lock); 2186c0a2ad9bSOGAWA Hirofumi 218770fd7614SChristoph Hellwig jbd2_mark_journal_empty(journal, 218817f423b5SJan Kara REQ_SYNC | REQ_PREFLUSH | REQ_FUA); 2189a78bb11dSJan Kara mutex_unlock(&journal->j_checkpoint_mutex); 2190a78bb11dSJan Kara } else 219144519fafSHidehiro Kawai err = -EIO; 2192470decc6SDave Kleikamp brelse(journal->j_sb_buffer); 2193470decc6SDave Kleikamp } 2194470decc6SDave Kleikamp 21950705e8d1STheodore Ts'o if (journal->j_shrinker.flags & SHRINKER_REGISTERED) { 21960705e8d1STheodore Ts'o percpu_counter_destroy(&journal->j_checkpoint_jh_count); 21970705e8d1STheodore Ts'o unregister_shrinker(&journal->j_shrinker); 21980705e8d1STheodore Ts'o } 21998e85fb3fSJohann Lombardi if (journal->j_proc_entry) 22008e85fb3fSJohann Lombardi jbd2_stats_proc_exit(journal); 2201470decc6SDave Kleikamp iput(journal->j_inode); 2202470decc6SDave Kleikamp if (journal->j_revoke) 2203f7f4bccbSMingming Cao jbd2_journal_destroy_revoke(journal); 220401b5adceSDarrick J. Wong if (journal->j_chksum_driver) 220501b5adceSDarrick J. Wong crypto_free_shash(journal->j_chksum_driver); 22066866d7b3SHarshad Shirwadkar kfree(journal->j_fc_wbuf); 2207470decc6SDave Kleikamp kfree(journal->j_wbuf); 2208470decc6SDave Kleikamp kfree(journal); 220944519fafSHidehiro Kawai 221044519fafSHidehiro Kawai return err; 2211470decc6SDave Kleikamp } 2212470decc6SDave Kleikamp 2213470decc6SDave Kleikamp 2214470decc6SDave Kleikamp /** 22152bf31d94SMauro Carvalho Chehab * jbd2_journal_check_used_features() - Check if features specified are used. 2216470decc6SDave Kleikamp * @journal: Journal to check. 2217470decc6SDave Kleikamp * @compat: bitmask of compatible features 2218470decc6SDave Kleikamp * @ro: bitmask of features that force read-only mount 2219470decc6SDave Kleikamp * @incompat: bitmask of incompatible features 2220470decc6SDave Kleikamp * 2221470decc6SDave Kleikamp * Check whether the journal uses all of a given set of 2222470decc6SDave Kleikamp * features. Return true (non-zero) if it does. 2223470decc6SDave Kleikamp **/ 2224470decc6SDave Kleikamp 2225f7f4bccbSMingming Cao int jbd2_journal_check_used_features(journal_t *journal, unsigned long compat, 2226470decc6SDave Kleikamp unsigned long ro, unsigned long incompat) 2227470decc6SDave Kleikamp { 2228470decc6SDave Kleikamp journal_superblock_t *sb; 2229470decc6SDave Kleikamp 2230470decc6SDave Kleikamp if (!compat && !ro && !incompat) 2231470decc6SDave Kleikamp return 1; 22321113e1b5SPatrick J. LoPresti /* Load journal superblock if it is not loaded yet. */ 22333e5cf02cSZhang Yi if (journal_get_superblock(journal)) 22341113e1b5SPatrick J. LoPresti return 0; 22355cf036d4SZhang Yi if (!jbd2_format_support_feature(journal)) 2236470decc6SDave Kleikamp return 0; 2237470decc6SDave Kleikamp 2238470decc6SDave Kleikamp sb = journal->j_superblock; 2239470decc6SDave Kleikamp 2240470decc6SDave Kleikamp if (((be32_to_cpu(sb->s_feature_compat) & compat) == compat) && 2241470decc6SDave Kleikamp ((be32_to_cpu(sb->s_feature_ro_compat) & ro) == ro) && 2242470decc6SDave Kleikamp ((be32_to_cpu(sb->s_feature_incompat) & incompat) == incompat)) 2243470decc6SDave Kleikamp return 1; 2244470decc6SDave Kleikamp 2245470decc6SDave Kleikamp return 0; 2246470decc6SDave Kleikamp } 2247470decc6SDave Kleikamp 2248470decc6SDave Kleikamp /** 22492bf31d94SMauro Carvalho Chehab * jbd2_journal_check_available_features() - Check feature set in journalling layer 2250470decc6SDave Kleikamp * @journal: Journal to check. 2251470decc6SDave Kleikamp * @compat: bitmask of compatible features 2252470decc6SDave Kleikamp * @ro: bitmask of features that force read-only mount 2253470decc6SDave Kleikamp * @incompat: bitmask of incompatible features 2254470decc6SDave Kleikamp * 2255470decc6SDave Kleikamp * Check whether the journaling code supports the use of 2256470decc6SDave Kleikamp * all of a given set of features on this journal. Return true 2257470decc6SDave Kleikamp * (non-zero) if it can. */ 2258470decc6SDave Kleikamp 2259f7f4bccbSMingming Cao int jbd2_journal_check_available_features(journal_t *journal, unsigned long compat, 2260470decc6SDave Kleikamp unsigned long ro, unsigned long incompat) 2261470decc6SDave Kleikamp { 2262470decc6SDave Kleikamp if (!compat && !ro && !incompat) 2263470decc6SDave Kleikamp return 1; 2264470decc6SDave Kleikamp 22655cf036d4SZhang Yi if (!jbd2_format_support_feature(journal)) 2266470decc6SDave Kleikamp return 0; 2267470decc6SDave Kleikamp 2268f7f4bccbSMingming Cao if ((compat & JBD2_KNOWN_COMPAT_FEATURES) == compat && 2269f7f4bccbSMingming Cao (ro & JBD2_KNOWN_ROCOMPAT_FEATURES) == ro && 2270f7f4bccbSMingming Cao (incompat & JBD2_KNOWN_INCOMPAT_FEATURES) == incompat) 2271470decc6SDave Kleikamp return 1; 2272470decc6SDave Kleikamp 2273470decc6SDave Kleikamp return 0; 2274470decc6SDave Kleikamp } 2275470decc6SDave Kleikamp 2276a1e5e465SHarshad Shirwadkar static int 2277a1e5e465SHarshad Shirwadkar jbd2_journal_initialize_fast_commit(journal_t *journal) 2278a1e5e465SHarshad Shirwadkar { 2279a1e5e465SHarshad Shirwadkar journal_superblock_t *sb = journal->j_superblock; 2280a1e5e465SHarshad Shirwadkar unsigned long long num_fc_blks; 2281a1e5e465SHarshad Shirwadkar 22829bd23c31SHarshad Shirwadkar num_fc_blks = jbd2_journal_get_num_fc_blks(sb); 2283a1e5e465SHarshad Shirwadkar if (journal->j_last - num_fc_blks < JBD2_MIN_JOURNAL_BLOCKS) 2284a1e5e465SHarshad Shirwadkar return -ENOSPC; 2285a1e5e465SHarshad Shirwadkar 2286a1e5e465SHarshad Shirwadkar /* Are we called twice? */ 2287a1e5e465SHarshad Shirwadkar WARN_ON(journal->j_fc_wbuf != NULL); 2288a1e5e465SHarshad Shirwadkar journal->j_fc_wbuf = kmalloc_array(num_fc_blks, 2289a1e5e465SHarshad Shirwadkar sizeof(struct buffer_head *), GFP_KERNEL); 2290a1e5e465SHarshad Shirwadkar if (!journal->j_fc_wbuf) 2291a1e5e465SHarshad Shirwadkar return -ENOMEM; 2292a1e5e465SHarshad Shirwadkar 2293a1e5e465SHarshad Shirwadkar journal->j_fc_wbufsize = num_fc_blks; 2294a1e5e465SHarshad Shirwadkar journal->j_fc_last = journal->j_last; 2295a1e5e465SHarshad Shirwadkar journal->j_last = journal->j_fc_last - num_fc_blks; 2296a1e5e465SHarshad Shirwadkar journal->j_fc_first = journal->j_last + 1; 2297a1e5e465SHarshad Shirwadkar journal->j_fc_off = 0; 2298a1e5e465SHarshad Shirwadkar journal->j_free = journal->j_last - journal->j_first; 2299a1e5e465SHarshad Shirwadkar journal->j_max_transaction_buffers = 2300a1e5e465SHarshad Shirwadkar jbd2_journal_get_max_txn_bufs(journal); 2301a1e5e465SHarshad Shirwadkar 2302a1e5e465SHarshad Shirwadkar return 0; 2303a1e5e465SHarshad Shirwadkar } 2304a1e5e465SHarshad Shirwadkar 2305470decc6SDave Kleikamp /** 23062bf31d94SMauro Carvalho Chehab * jbd2_journal_set_features() - Mark a given journal feature in the superblock 2307470decc6SDave Kleikamp * @journal: Journal to act on. 2308470decc6SDave Kleikamp * @compat: bitmask of compatible features 2309470decc6SDave Kleikamp * @ro: bitmask of features that force read-only mount 2310470decc6SDave Kleikamp * @incompat: bitmask of incompatible features 2311470decc6SDave Kleikamp * 2312470decc6SDave Kleikamp * Mark a given journal feature as present on the 2313470decc6SDave Kleikamp * superblock. Returns true if the requested features could be set. 2314470decc6SDave Kleikamp * 2315470decc6SDave Kleikamp */ 2316470decc6SDave Kleikamp 2317f7f4bccbSMingming Cao int jbd2_journal_set_features(journal_t *journal, unsigned long compat, 2318470decc6SDave Kleikamp unsigned long ro, unsigned long incompat) 2319470decc6SDave Kleikamp { 232025ed6e8aSDarrick J. Wong #define INCOMPAT_FEATURE_ON(f) \ 232125ed6e8aSDarrick J. Wong ((incompat & (f)) && !(sb->s_feature_incompat & cpu_to_be32(f))) 232225ed6e8aSDarrick J. Wong #define COMPAT_FEATURE_ON(f) \ 232325ed6e8aSDarrick J. Wong ((compat & (f)) && !(sb->s_feature_compat & cpu_to_be32(f))) 2324470decc6SDave Kleikamp journal_superblock_t *sb; 2325470decc6SDave Kleikamp 2326f7f4bccbSMingming Cao if (jbd2_journal_check_used_features(journal, compat, ro, incompat)) 2327470decc6SDave Kleikamp return 1; 2328470decc6SDave Kleikamp 2329f7f4bccbSMingming Cao if (!jbd2_journal_check_available_features(journal, compat, ro, incompat)) 2330470decc6SDave Kleikamp return 0; 2331470decc6SDave Kleikamp 2332db9ee220SDarrick J. Wong /* If enabling v2 checksums, turn on v3 instead */ 2333db9ee220SDarrick J. Wong if (incompat & JBD2_FEATURE_INCOMPAT_CSUM_V2) { 2334db9ee220SDarrick J. Wong incompat &= ~JBD2_FEATURE_INCOMPAT_CSUM_V2; 2335db9ee220SDarrick J. Wong incompat |= JBD2_FEATURE_INCOMPAT_CSUM_V3; 2336db9ee220SDarrick J. Wong } 2337db9ee220SDarrick J. Wong 2338db9ee220SDarrick J. Wong /* Asking for checksumming v3 and v1? Only give them v3. */ 2339db9ee220SDarrick J. Wong if (incompat & JBD2_FEATURE_INCOMPAT_CSUM_V3 && 234025ed6e8aSDarrick J. Wong compat & JBD2_FEATURE_COMPAT_CHECKSUM) 234125ed6e8aSDarrick J. Wong compat &= ~JBD2_FEATURE_COMPAT_CHECKSUM; 234225ed6e8aSDarrick J. Wong 2343cb3b3bf2SJan Kara jbd2_debug(1, "Setting new features 0x%lx/0x%lx/0x%lx\n", 2344470decc6SDave Kleikamp compat, ro, incompat); 2345470decc6SDave Kleikamp 2346470decc6SDave Kleikamp sb = journal->j_superblock; 2347470decc6SDave Kleikamp 2348a1e5e465SHarshad Shirwadkar if (incompat & JBD2_FEATURE_INCOMPAT_FAST_COMMIT) { 2349a1e5e465SHarshad Shirwadkar if (jbd2_journal_initialize_fast_commit(journal)) { 2350a1e5e465SHarshad Shirwadkar pr_err("JBD2: Cannot enable fast commits.\n"); 2351a1e5e465SHarshad Shirwadkar return 0; 2352a1e5e465SHarshad Shirwadkar } 2353a1e5e465SHarshad Shirwadkar } 2354a1e5e465SHarshad Shirwadkar 2355538bcaa6STheodore Ts'o /* Load the checksum driver if necessary */ 2356538bcaa6STheodore Ts'o if ((journal->j_chksum_driver == NULL) && 2357538bcaa6STheodore Ts'o INCOMPAT_FEATURE_ON(JBD2_FEATURE_INCOMPAT_CSUM_V3)) { 2358538bcaa6STheodore Ts'o journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0); 2359538bcaa6STheodore Ts'o if (IS_ERR(journal->j_chksum_driver)) { 2360538bcaa6STheodore Ts'o printk(KERN_ERR "JBD2: Cannot load crc32c driver.\n"); 2361538bcaa6STheodore Ts'o journal->j_chksum_driver = NULL; 2362538bcaa6STheodore Ts'o return 0; 2363538bcaa6STheodore Ts'o } 2364538bcaa6STheodore Ts'o /* Precompute checksum seed for all metadata */ 2365538bcaa6STheodore Ts'o journal->j_csum_seed = jbd2_chksum(journal, ~0, sb->s_uuid, 2366538bcaa6STheodore Ts'o sizeof(sb->s_uuid)); 2367538bcaa6STheodore Ts'o } 2368538bcaa6STheodore Ts'o 2369538bcaa6STheodore Ts'o lock_buffer(journal->j_sb_buffer); 2370538bcaa6STheodore Ts'o 2371db9ee220SDarrick J. Wong /* If enabling v3 checksums, update superblock */ 2372db9ee220SDarrick J. Wong if (INCOMPAT_FEATURE_ON(JBD2_FEATURE_INCOMPAT_CSUM_V3)) { 237325ed6e8aSDarrick J. Wong sb->s_checksum_type = JBD2_CRC32C_CHKSUM; 237425ed6e8aSDarrick J. Wong sb->s_feature_compat &= 237525ed6e8aSDarrick J. Wong ~cpu_to_be32(JBD2_FEATURE_COMPAT_CHECKSUM); 237632f38691SDarrick J. Wong } 237725ed6e8aSDarrick J. Wong 237825ed6e8aSDarrick J. Wong /* If enabling v1 checksums, downgrade superblock */ 237925ed6e8aSDarrick J. Wong if (COMPAT_FEATURE_ON(JBD2_FEATURE_COMPAT_CHECKSUM)) 238025ed6e8aSDarrick J. Wong sb->s_feature_incompat &= 2381db9ee220SDarrick J. Wong ~cpu_to_be32(JBD2_FEATURE_INCOMPAT_CSUM_V2 | 2382db9ee220SDarrick J. Wong JBD2_FEATURE_INCOMPAT_CSUM_V3); 238325ed6e8aSDarrick J. Wong 2384470decc6SDave Kleikamp sb->s_feature_compat |= cpu_to_be32(compat); 2385470decc6SDave Kleikamp sb->s_feature_ro_compat |= cpu_to_be32(ro); 2386470decc6SDave Kleikamp sb->s_feature_incompat |= cpu_to_be32(incompat); 2387538bcaa6STheodore Ts'o unlock_buffer(journal->j_sb_buffer); 2388fdc3ef88SJan Kara journal->j_revoke_records_per_block = 2389fdc3ef88SJan Kara journal_revoke_records_per_block(journal); 2390470decc6SDave Kleikamp 2391470decc6SDave Kleikamp return 1; 239225ed6e8aSDarrick J. Wong #undef COMPAT_FEATURE_ON 239325ed6e8aSDarrick J. Wong #undef INCOMPAT_FEATURE_ON 2394470decc6SDave Kleikamp } 2395470decc6SDave Kleikamp 2396818d276cSGirish Shilamkar /* 2397818d276cSGirish Shilamkar * jbd2_journal_clear_features() - Clear a given journal feature in the 2398818d276cSGirish Shilamkar * superblock 2399818d276cSGirish Shilamkar * @journal: Journal to act on. 2400818d276cSGirish Shilamkar * @compat: bitmask of compatible features 2401818d276cSGirish Shilamkar * @ro: bitmask of features that force read-only mount 2402818d276cSGirish Shilamkar * @incompat: bitmask of incompatible features 2403818d276cSGirish Shilamkar * 2404818d276cSGirish Shilamkar * Clear a given journal feature as present on the 2405818d276cSGirish Shilamkar * superblock. 2406818d276cSGirish Shilamkar */ 2407818d276cSGirish Shilamkar void jbd2_journal_clear_features(journal_t *journal, unsigned long compat, 2408818d276cSGirish Shilamkar unsigned long ro, unsigned long incompat) 2409818d276cSGirish Shilamkar { 2410818d276cSGirish Shilamkar journal_superblock_t *sb; 2411818d276cSGirish Shilamkar 2412cb3b3bf2SJan Kara jbd2_debug(1, "Clear features 0x%lx/0x%lx/0x%lx\n", 2413818d276cSGirish Shilamkar compat, ro, incompat); 2414818d276cSGirish Shilamkar 2415818d276cSGirish Shilamkar sb = journal->j_superblock; 2416818d276cSGirish Shilamkar 2417818d276cSGirish Shilamkar sb->s_feature_compat &= ~cpu_to_be32(compat); 2418818d276cSGirish Shilamkar sb->s_feature_ro_compat &= ~cpu_to_be32(ro); 2419818d276cSGirish Shilamkar sb->s_feature_incompat &= ~cpu_to_be32(incompat); 2420fdc3ef88SJan Kara journal->j_revoke_records_per_block = 2421fdc3ef88SJan Kara journal_revoke_records_per_block(journal); 2422818d276cSGirish Shilamkar } 2423818d276cSGirish Shilamkar EXPORT_SYMBOL(jbd2_journal_clear_features); 2424470decc6SDave Kleikamp 2425470decc6SDave Kleikamp /** 24262bf31d94SMauro Carvalho Chehab * jbd2_journal_flush() - Flush journal 2427470decc6SDave Kleikamp * @journal: Journal to act on. 242801d5d965SLeah Rumancik * @flags: optional operation on the journal blocks after the flush (see below) 2429470decc6SDave Kleikamp * 2430470decc6SDave Kleikamp * Flush all data for a given journal to disk and empty the journal. 2431470decc6SDave Kleikamp * Filesystems can use this when remounting readonly to ensure that 243201d5d965SLeah Rumancik * recovery does not need to happen on remount. Optionally, a discard or zeroout 243301d5d965SLeah Rumancik * can be issued on the journal blocks after flushing. 243401d5d965SLeah Rumancik * 243501d5d965SLeah Rumancik * flags: 243601d5d965SLeah Rumancik * JBD2_JOURNAL_FLUSH_DISCARD: issues discards for the journal blocks 243701d5d965SLeah Rumancik * JBD2_JOURNAL_FLUSH_ZEROOUT: issues zeroouts for the journal blocks 2438470decc6SDave Kleikamp */ 243901d5d965SLeah Rumancik int jbd2_journal_flush(journal_t *journal, unsigned int flags) 2440470decc6SDave Kleikamp { 2441470decc6SDave Kleikamp int err = 0; 2442470decc6SDave Kleikamp transaction_t *transaction = NULL; 2443470decc6SDave Kleikamp 2444a931da6aSTheodore Ts'o write_lock(&journal->j_state_lock); 2445470decc6SDave Kleikamp 2446470decc6SDave Kleikamp /* Force everything buffered to the log... */ 2447470decc6SDave Kleikamp if (journal->j_running_transaction) { 2448470decc6SDave Kleikamp transaction = journal->j_running_transaction; 2449f7f4bccbSMingming Cao __jbd2_log_start_commit(journal, transaction->t_tid); 2450470decc6SDave Kleikamp } else if (journal->j_committing_transaction) 2451470decc6SDave Kleikamp transaction = journal->j_committing_transaction; 2452470decc6SDave Kleikamp 2453470decc6SDave Kleikamp /* Wait for the log commit to complete... */ 2454470decc6SDave Kleikamp if (transaction) { 2455470decc6SDave Kleikamp tid_t tid = transaction->t_tid; 2456470decc6SDave Kleikamp 2457a931da6aSTheodore Ts'o write_unlock(&journal->j_state_lock); 2458f7f4bccbSMingming Cao jbd2_log_wait_commit(journal, tid); 2459470decc6SDave Kleikamp } else { 2460a931da6aSTheodore Ts'o write_unlock(&journal->j_state_lock); 2461470decc6SDave Kleikamp } 2462470decc6SDave Kleikamp 2463470decc6SDave Kleikamp /* ...and flush everything in the log out to disk. */ 2464470decc6SDave Kleikamp spin_lock(&journal->j_list_lock); 2465470decc6SDave Kleikamp while (!err && journal->j_checkpoint_transactions != NULL) { 2466470decc6SDave Kleikamp spin_unlock(&journal->j_list_lock); 24676fa7aa50STejun Heo mutex_lock_io(&journal->j_checkpoint_mutex); 2468f7f4bccbSMingming Cao err = jbd2_log_do_checkpoint(journal); 246944519fafSHidehiro Kawai mutex_unlock(&journal->j_checkpoint_mutex); 2470470decc6SDave Kleikamp spin_lock(&journal->j_list_lock); 2471470decc6SDave Kleikamp } 2472470decc6SDave Kleikamp spin_unlock(&journal->j_list_lock); 247344519fafSHidehiro Kawai 247444519fafSHidehiro Kawai if (is_journal_aborted(journal)) 247544519fafSHidehiro Kawai return -EIO; 247644519fafSHidehiro Kawai 24776fa7aa50STejun Heo mutex_lock_io(&journal->j_checkpoint_mutex); 24786f6a6fdaSJoseph Qi if (!err) { 24796f6a6fdaSJoseph Qi err = jbd2_cleanup_journal_tail(journal); 24806f6a6fdaSJoseph Qi if (err < 0) { 24816f6a6fdaSJoseph Qi mutex_unlock(&journal->j_checkpoint_mutex); 24826f6a6fdaSJoseph Qi goto out; 24836f6a6fdaSJoseph Qi } 24846f6a6fdaSJoseph Qi err = 0; 24856f6a6fdaSJoseph Qi } 2486470decc6SDave Kleikamp 2487470decc6SDave Kleikamp /* Finally, mark the journal as really needing no recovery. 2488470decc6SDave Kleikamp * This sets s_start==0 in the underlying superblock, which is 2489470decc6SDave Kleikamp * the magic code for a fully-recovered superblock. Any future 2490470decc6SDave Kleikamp * commits of data to the journal will restore the current 2491470decc6SDave Kleikamp * s_start value. */ 249217f423b5SJan Kara jbd2_mark_journal_empty(journal, REQ_SYNC | REQ_FUA); 249301d5d965SLeah Rumancik 249401d5d965SLeah Rumancik if (flags) 249501d5d965SLeah Rumancik err = __jbd2_journal_erase(journal, flags); 249601d5d965SLeah Rumancik 2497a78bb11dSJan Kara mutex_unlock(&journal->j_checkpoint_mutex); 2498a931da6aSTheodore Ts'o write_lock(&journal->j_state_lock); 2499470decc6SDave Kleikamp J_ASSERT(!journal->j_running_transaction); 2500470decc6SDave Kleikamp J_ASSERT(!journal->j_committing_transaction); 2501470decc6SDave Kleikamp J_ASSERT(!journal->j_checkpoint_transactions); 2502470decc6SDave Kleikamp J_ASSERT(journal->j_head == journal->j_tail); 2503470decc6SDave Kleikamp J_ASSERT(journal->j_tail_sequence == journal->j_transaction_sequence); 2504a931da6aSTheodore Ts'o write_unlock(&journal->j_state_lock); 25056f6a6fdaSJoseph Qi out: 25066f6a6fdaSJoseph Qi return err; 2507470decc6SDave Kleikamp } 2508470decc6SDave Kleikamp 2509470decc6SDave Kleikamp /** 25102bf31d94SMauro Carvalho Chehab * jbd2_journal_wipe() - Wipe journal contents 2511470decc6SDave Kleikamp * @journal: Journal to act on. 2512470decc6SDave Kleikamp * @write: flag (see below) 2513470decc6SDave Kleikamp * 2514470decc6SDave Kleikamp * Wipe out all of the contents of a journal, safely. This will produce 2515470decc6SDave Kleikamp * a warning if the journal contains any valid recovery information. 2516f7f4bccbSMingming Cao * Must be called between journal_init_*() and jbd2_journal_load(). 2517470decc6SDave Kleikamp * 2518470decc6SDave Kleikamp * If 'write' is non-zero, then we wipe out the journal on disk; otherwise 2519470decc6SDave Kleikamp * we merely suppress recovery. 2520470decc6SDave Kleikamp */ 2521470decc6SDave Kleikamp 2522f7f4bccbSMingming Cao int jbd2_journal_wipe(journal_t *journal, int write) 2523470decc6SDave Kleikamp { 2524470decc6SDave Kleikamp int err = 0; 2525470decc6SDave Kleikamp 2526f7f4bccbSMingming Cao J_ASSERT (!(journal->j_flags & JBD2_LOADED)); 2527470decc6SDave Kleikamp 2528470decc6SDave Kleikamp err = load_superblock(journal); 2529470decc6SDave Kleikamp if (err) 2530470decc6SDave Kleikamp return err; 2531470decc6SDave Kleikamp 2532470decc6SDave Kleikamp if (!journal->j_tail) 2533470decc6SDave Kleikamp goto no_recovery; 2534470decc6SDave Kleikamp 2535f2a44523SEryu Guan printk(KERN_WARNING "JBD2: %s recovery information on journal\n", 2536470decc6SDave Kleikamp write ? "Clearing" : "Ignoring"); 2537470decc6SDave Kleikamp 2538f7f4bccbSMingming Cao err = jbd2_journal_skip_recovery(journal); 2539a78bb11dSJan Kara if (write) { 2540a78bb11dSJan Kara /* Lock to make assertions happy... */ 254153cf9784SXiaoguang Wang mutex_lock_io(&journal->j_checkpoint_mutex); 254217f423b5SJan Kara jbd2_mark_journal_empty(journal, REQ_SYNC | REQ_FUA); 2543a78bb11dSJan Kara mutex_unlock(&journal->j_checkpoint_mutex); 2544a78bb11dSJan Kara } 2545470decc6SDave Kleikamp 2546470decc6SDave Kleikamp no_recovery: 2547470decc6SDave Kleikamp return err; 2548470decc6SDave Kleikamp } 2549470decc6SDave Kleikamp 2550470decc6SDave Kleikamp /** 25512bf31d94SMauro Carvalho Chehab * jbd2_journal_abort () - Shutdown the journal immediately. 2552470decc6SDave Kleikamp * @journal: the journal to shutdown. 2553470decc6SDave Kleikamp * @errno: an error number to record in the journal indicating 2554470decc6SDave Kleikamp * the reason for the shutdown. 2555470decc6SDave Kleikamp * 2556470decc6SDave Kleikamp * Perform a complete, immediate shutdown of the ENTIRE 2557470decc6SDave Kleikamp * journal (not of a single transaction). This operation cannot be 2558470decc6SDave Kleikamp * undone without closing and reopening the journal. 2559470decc6SDave Kleikamp * 2560f7f4bccbSMingming Cao * The jbd2_journal_abort function is intended to support higher level error 2561470decc6SDave Kleikamp * recovery mechanisms such as the ext2/ext3 remount-readonly error 2562470decc6SDave Kleikamp * mode. 2563470decc6SDave Kleikamp * 2564470decc6SDave Kleikamp * Journal abort has very specific semantics. Any existing dirty, 2565470decc6SDave Kleikamp * unjournaled buffers in the main filesystem will still be written to 2566470decc6SDave Kleikamp * disk by bdflush, but the journaling mechanism will be suspended 2567470decc6SDave Kleikamp * immediately and no further transaction commits will be honoured. 2568470decc6SDave Kleikamp * 2569470decc6SDave Kleikamp * Any dirty, journaled buffers will be written back to disk without 2570470decc6SDave Kleikamp * hitting the journal. Atomicity cannot be guaranteed on an aborted 2571470decc6SDave Kleikamp * filesystem, but we _do_ attempt to leave as much data as possible 2572470decc6SDave Kleikamp * behind for fsck to use for cleanup. 2573470decc6SDave Kleikamp * 2574470decc6SDave Kleikamp * Any attempt to get a new transaction handle on a journal which is in 2575470decc6SDave Kleikamp * ABORT state will just result in an -EROFS error return. A 2576f7f4bccbSMingming Cao * jbd2_journal_stop on an existing handle will return -EIO if we have 2577470decc6SDave Kleikamp * entered abort state during the update. 2578470decc6SDave Kleikamp * 2579470decc6SDave Kleikamp * Recursive transactions are not disturbed by journal abort until the 2580f7f4bccbSMingming Cao * final jbd2_journal_stop, which will receive the -EIO error. 2581470decc6SDave Kleikamp * 2582f7f4bccbSMingming Cao * Finally, the jbd2_journal_abort call allows the caller to supply an errno 2583470decc6SDave Kleikamp * which will be recorded (if possible) in the journal superblock. This 2584470decc6SDave Kleikamp * allows a client to record failure conditions in the middle of a 2585470decc6SDave Kleikamp * transaction without having to complete the transaction to record the 2586470decc6SDave Kleikamp * failure to disk. ext3_error, for example, now uses this 2587470decc6SDave Kleikamp * functionality. 2588470decc6SDave Kleikamp * 2589470decc6SDave Kleikamp */ 2590470decc6SDave Kleikamp 2591f7f4bccbSMingming Cao void jbd2_journal_abort(journal_t *journal, int errno) 2592470decc6SDave Kleikamp { 25937f6225e4Szhangyi (F) transaction_t *transaction; 25947f6225e4Szhangyi (F) 25957f6225e4Szhangyi (F) /* 25967b97d868Szhangyi (F) * Lock the aborting procedure until everything is done, this avoid 25977b97d868Szhangyi (F) * races between filesystem's error handling flow (e.g. ext4_abort()), 25987b97d868Szhangyi (F) * ensure panic after the error info is written into journal's 25997b97d868Szhangyi (F) * superblock. 26007b97d868Szhangyi (F) */ 26017b97d868Szhangyi (F) mutex_lock(&journal->j_abort_mutex); 26027b97d868Szhangyi (F) /* 26037f6225e4Szhangyi (F) * ESHUTDOWN always takes precedence because a file system check 26047f6225e4Szhangyi (F) * caused by any other journal abort error is not required after 26057f6225e4Szhangyi (F) * a shutdown triggered. 26067f6225e4Szhangyi (F) */ 26077f6225e4Szhangyi (F) write_lock(&journal->j_state_lock); 26087f6225e4Szhangyi (F) if (journal->j_flags & JBD2_ABORT) { 26097f6225e4Szhangyi (F) int old_errno = journal->j_errno; 26107f6225e4Szhangyi (F) 26117f6225e4Szhangyi (F) write_unlock(&journal->j_state_lock); 26127f6225e4Szhangyi (F) if (old_errno != -ESHUTDOWN && errno == -ESHUTDOWN) { 26137f6225e4Szhangyi (F) journal->j_errno = errno; 26147f6225e4Szhangyi (F) jbd2_journal_update_sb_errno(journal); 26157f6225e4Szhangyi (F) } 26167b97d868Szhangyi (F) mutex_unlock(&journal->j_abort_mutex); 26177f6225e4Szhangyi (F) return; 26187f6225e4Szhangyi (F) } 26197f6225e4Szhangyi (F) 26207f6225e4Szhangyi (F) /* 26217f6225e4Szhangyi (F) * Mark the abort as occurred and start current running transaction 26227f6225e4Szhangyi (F) * to release all journaled buffer. 26237f6225e4Szhangyi (F) */ 26247f6225e4Szhangyi (F) pr_err("Aborting journal on device %s.\n", journal->j_devname); 26257f6225e4Szhangyi (F) 26267f6225e4Szhangyi (F) journal->j_flags |= JBD2_ABORT; 26277f6225e4Szhangyi (F) journal->j_errno = errno; 26287f6225e4Szhangyi (F) transaction = journal->j_running_transaction; 26297f6225e4Szhangyi (F) if (transaction) 26307f6225e4Szhangyi (F) __jbd2_log_start_commit(journal, transaction->t_tid); 26317f6225e4Szhangyi (F) write_unlock(&journal->j_state_lock); 26327f6225e4Szhangyi (F) 26337f6225e4Szhangyi (F) /* 26347f6225e4Szhangyi (F) * Record errno to the journal super block, so that fsck and jbd2 26357f6225e4Szhangyi (F) * layer could realise that a filesystem check is needed. 26367f6225e4Szhangyi (F) */ 26377f6225e4Szhangyi (F) jbd2_journal_update_sb_errno(journal); 26387b97d868Szhangyi (F) mutex_unlock(&journal->j_abort_mutex); 2639470decc6SDave Kleikamp } 2640470decc6SDave Kleikamp 2641470decc6SDave Kleikamp /** 26422bf31d94SMauro Carvalho Chehab * jbd2_journal_errno() - returns the journal's error state. 2643470decc6SDave Kleikamp * @journal: journal to examine. 2644470decc6SDave Kleikamp * 2645bfcd3555SAlberto Bertogli * This is the errno number set with jbd2_journal_abort(), the last 2646470decc6SDave Kleikamp * time the journal was mounted - if the journal was stopped 2647470decc6SDave Kleikamp * without calling abort this will be 0. 2648470decc6SDave Kleikamp * 2649470decc6SDave Kleikamp * If the journal has been aborted on this mount time -EROFS will 2650470decc6SDave Kleikamp * be returned. 2651470decc6SDave Kleikamp */ 2652f7f4bccbSMingming Cao int jbd2_journal_errno(journal_t *journal) 2653470decc6SDave Kleikamp { 2654470decc6SDave Kleikamp int err; 2655470decc6SDave Kleikamp 2656a931da6aSTheodore Ts'o read_lock(&journal->j_state_lock); 2657f7f4bccbSMingming Cao if (journal->j_flags & JBD2_ABORT) 2658470decc6SDave Kleikamp err = -EROFS; 2659470decc6SDave Kleikamp else 2660470decc6SDave Kleikamp err = journal->j_errno; 2661a931da6aSTheodore Ts'o read_unlock(&journal->j_state_lock); 2662470decc6SDave Kleikamp return err; 2663470decc6SDave Kleikamp } 2664470decc6SDave Kleikamp 2665470decc6SDave Kleikamp /** 26662bf31d94SMauro Carvalho Chehab * jbd2_journal_clear_err() - clears the journal's error state 2667470decc6SDave Kleikamp * @journal: journal to act on. 2668470decc6SDave Kleikamp * 2669bfcd3555SAlberto Bertogli * An error must be cleared or acked to take a FS out of readonly 2670470decc6SDave Kleikamp * mode. 2671470decc6SDave Kleikamp */ 2672f7f4bccbSMingming Cao int jbd2_journal_clear_err(journal_t *journal) 2673470decc6SDave Kleikamp { 2674470decc6SDave Kleikamp int err = 0; 2675470decc6SDave Kleikamp 2676a931da6aSTheodore Ts'o write_lock(&journal->j_state_lock); 2677f7f4bccbSMingming Cao if (journal->j_flags & JBD2_ABORT) 2678470decc6SDave Kleikamp err = -EROFS; 2679470decc6SDave Kleikamp else 2680470decc6SDave Kleikamp journal->j_errno = 0; 2681a931da6aSTheodore Ts'o write_unlock(&journal->j_state_lock); 2682470decc6SDave Kleikamp return err; 2683470decc6SDave Kleikamp } 2684470decc6SDave Kleikamp 2685470decc6SDave Kleikamp /** 26862bf31d94SMauro Carvalho Chehab * jbd2_journal_ack_err() - Ack journal err. 2687470decc6SDave Kleikamp * @journal: journal to act on. 2688470decc6SDave Kleikamp * 2689bfcd3555SAlberto Bertogli * An error must be cleared or acked to take a FS out of readonly 2690470decc6SDave Kleikamp * mode. 2691470decc6SDave Kleikamp */ 2692f7f4bccbSMingming Cao void jbd2_journal_ack_err(journal_t *journal) 2693470decc6SDave Kleikamp { 2694a931da6aSTheodore Ts'o write_lock(&journal->j_state_lock); 2695470decc6SDave Kleikamp if (journal->j_errno) 2696f7f4bccbSMingming Cao journal->j_flags |= JBD2_ACK_ERR; 2697a931da6aSTheodore Ts'o write_unlock(&journal->j_state_lock); 2698470decc6SDave Kleikamp } 2699470decc6SDave Kleikamp 2700f7f4bccbSMingming Cao int jbd2_journal_blocks_per_page(struct inode *inode) 2701470decc6SDave Kleikamp { 270209cbfeafSKirill A. Shutemov return 1 << (PAGE_SHIFT - inode->i_sb->s_blocksize_bits); 2703470decc6SDave Kleikamp } 2704470decc6SDave Kleikamp 2705470decc6SDave Kleikamp /* 2706b517bea1SZach Brown * helper functions to deal with 32 or 64bit block numbers. 2707b517bea1SZach Brown */ 2708b517bea1SZach Brown size_t journal_tag_bytes(journal_t *journal) 2709b517bea1SZach Brown { 2710db9ee220SDarrick J. Wong size_t sz; 2711db9ee220SDarrick J. Wong 271256316a0dSDarrick J. Wong if (jbd2_has_feature_csum3(journal)) 2713db9ee220SDarrick J. Wong return sizeof(journal_block_tag3_t); 2714db9ee220SDarrick J. Wong 2715db9ee220SDarrick J. Wong sz = sizeof(journal_block_tag_t); 2716c3900875SDarrick J. Wong 271756316a0dSDarrick J. Wong if (jbd2_has_feature_csum2(journal)) 2718db9ee220SDarrick J. Wong sz += sizeof(__u16); 2719c3900875SDarrick J. Wong 272056316a0dSDarrick J. Wong if (jbd2_has_feature_64bit(journal)) 2721db9ee220SDarrick J. Wong return sz; 2722b517bea1SZach Brown else 2723db9ee220SDarrick J. Wong return sz - sizeof(__u32); 2724b517bea1SZach Brown } 2725b517bea1SZach Brown 2726b517bea1SZach Brown /* 2727d2eecb03STheodore Ts'o * JBD memory management 2728d2eecb03STheodore Ts'o * 2729d2eecb03STheodore Ts'o * These functions are used to allocate block-sized chunks of memory 2730d2eecb03STheodore Ts'o * used for making copies of buffer_head data. Very often it will be 2731d2eecb03STheodore Ts'o * page-sized chunks of data, but sometimes it will be in 2732d2eecb03STheodore Ts'o * sub-page-size chunks. (For example, 16k pages on Power systems 2733d2eecb03STheodore Ts'o * with a 4k block file system.) For blocks smaller than a page, we 2734d2eecb03STheodore Ts'o * use a SLAB allocator. There are slab caches for each block size, 2735d2eecb03STheodore Ts'o * which are allocated at mount time, if necessary, and we only free 2736d2eecb03STheodore Ts'o * (all of) the slab caches when/if the jbd2 module is unloaded. For 2737d2eecb03STheodore Ts'o * this reason we don't need to a mutex to protect access to 2738d2eecb03STheodore Ts'o * jbd2_slab[] allocating or releasing memory; only in 2739d2eecb03STheodore Ts'o * jbd2_journal_create_slab(). 2740d2eecb03STheodore Ts'o */ 2741d2eecb03STheodore Ts'o #define JBD2_MAX_SLABS 8 2742d2eecb03STheodore Ts'o static struct kmem_cache *jbd2_slab[JBD2_MAX_SLABS]; 2743d2eecb03STheodore Ts'o 2744d2eecb03STheodore Ts'o static const char *jbd2_slab_names[JBD2_MAX_SLABS] = { 2745d2eecb03STheodore Ts'o "jbd2_1k", "jbd2_2k", "jbd2_4k", "jbd2_8k", 2746d2eecb03STheodore Ts'o "jbd2_16k", "jbd2_32k", "jbd2_64k", "jbd2_128k" 2747d2eecb03STheodore Ts'o }; 2748d2eecb03STheodore Ts'o 2749d2eecb03STheodore Ts'o 2750d2eecb03STheodore Ts'o static void jbd2_journal_destroy_slabs(void) 2751d2eecb03STheodore Ts'o { 2752d2eecb03STheodore Ts'o int i; 2753d2eecb03STheodore Ts'o 2754d2eecb03STheodore Ts'o for (i = 0; i < JBD2_MAX_SLABS; i++) { 2755d2eecb03STheodore Ts'o kmem_cache_destroy(jbd2_slab[i]); 2756d2eecb03STheodore Ts'o jbd2_slab[i] = NULL; 2757d2eecb03STheodore Ts'o } 2758d2eecb03STheodore Ts'o } 2759d2eecb03STheodore Ts'o 2760d2eecb03STheodore Ts'o static int jbd2_journal_create_slab(size_t size) 2761d2eecb03STheodore Ts'o { 276251dfacdeSThomas Gleixner static DEFINE_MUTEX(jbd2_slab_create_mutex); 2763d2eecb03STheodore Ts'o int i = order_base_2(size) - 10; 2764d2eecb03STheodore Ts'o size_t slab_size; 2765d2eecb03STheodore Ts'o 2766d2eecb03STheodore Ts'o if (size == PAGE_SIZE) 2767d2eecb03STheodore Ts'o return 0; 2768d2eecb03STheodore Ts'o 2769d2eecb03STheodore Ts'o if (i >= JBD2_MAX_SLABS) 2770d2eecb03STheodore Ts'o return -EINVAL; 2771d2eecb03STheodore Ts'o 2772d2eecb03STheodore Ts'o if (unlikely(i < 0)) 2773d2eecb03STheodore Ts'o i = 0; 277451dfacdeSThomas Gleixner mutex_lock(&jbd2_slab_create_mutex); 2775d2eecb03STheodore Ts'o if (jbd2_slab[i]) { 277651dfacdeSThomas Gleixner mutex_unlock(&jbd2_slab_create_mutex); 2777d2eecb03STheodore Ts'o return 0; /* Already created */ 2778d2eecb03STheodore Ts'o } 2779d2eecb03STheodore Ts'o 2780d2eecb03STheodore Ts'o slab_size = 1 << (i+10); 2781d2eecb03STheodore Ts'o jbd2_slab[i] = kmem_cache_create(jbd2_slab_names[i], slab_size, 2782d2eecb03STheodore Ts'o slab_size, 0, NULL); 278351dfacdeSThomas Gleixner mutex_unlock(&jbd2_slab_create_mutex); 2784d2eecb03STheodore Ts'o if (!jbd2_slab[i]) { 2785d2eecb03STheodore Ts'o printk(KERN_EMERG "JBD2: no memory for jbd2_slab cache\n"); 2786d2eecb03STheodore Ts'o return -ENOMEM; 2787d2eecb03STheodore Ts'o } 2788d2eecb03STheodore Ts'o return 0; 2789d2eecb03STheodore Ts'o } 2790d2eecb03STheodore Ts'o 2791d2eecb03STheodore Ts'o static struct kmem_cache *get_slab(size_t size) 2792d2eecb03STheodore Ts'o { 2793d2eecb03STheodore Ts'o int i = order_base_2(size) - 10; 2794d2eecb03STheodore Ts'o 2795d2eecb03STheodore Ts'o BUG_ON(i >= JBD2_MAX_SLABS); 2796d2eecb03STheodore Ts'o if (unlikely(i < 0)) 2797d2eecb03STheodore Ts'o i = 0; 27988ac97b74SBill Pemberton BUG_ON(jbd2_slab[i] == NULL); 2799d2eecb03STheodore Ts'o return jbd2_slab[i]; 2800d2eecb03STheodore Ts'o } 2801d2eecb03STheodore Ts'o 2802d2eecb03STheodore Ts'o void *jbd2_alloc(size_t size, gfp_t flags) 2803d2eecb03STheodore Ts'o { 2804d2eecb03STheodore Ts'o void *ptr; 2805d2eecb03STheodore Ts'o 2806d2eecb03STheodore Ts'o BUG_ON(size & (size-1)); /* Must be a power of 2 */ 2807d2eecb03STheodore Ts'o 2808f2db1971SMichal Hocko if (size < PAGE_SIZE) 2809d2eecb03STheodore Ts'o ptr = kmem_cache_alloc(get_slab(size), flags); 2810f2db1971SMichal Hocko else 2811f2db1971SMichal Hocko ptr = (void *)__get_free_pages(flags, get_order(size)); 2812d2eecb03STheodore Ts'o 2813d2eecb03STheodore Ts'o /* Check alignment; SLUB has gotten this wrong in the past, 2814d2eecb03STheodore Ts'o * and this can lead to user data corruption! */ 2815d2eecb03STheodore Ts'o BUG_ON(((unsigned long) ptr) & (size-1)); 2816d2eecb03STheodore Ts'o 2817d2eecb03STheodore Ts'o return ptr; 2818d2eecb03STheodore Ts'o } 2819d2eecb03STheodore Ts'o 2820d2eecb03STheodore Ts'o void jbd2_free(void *ptr, size_t size) 2821d2eecb03STheodore Ts'o { 2822f2db1971SMichal Hocko if (size < PAGE_SIZE) 2823d2eecb03STheodore Ts'o kmem_cache_free(get_slab(size), ptr); 2824f2db1971SMichal Hocko else 2825f2db1971SMichal Hocko free_pages((unsigned long)ptr, get_order(size)); 2826d2eecb03STheodore Ts'o }; 2827d2eecb03STheodore Ts'o 2828d2eecb03STheodore Ts'o /* 2829470decc6SDave Kleikamp * Journal_head storage management 2830470decc6SDave Kleikamp */ 2831e18b890bSChristoph Lameter static struct kmem_cache *jbd2_journal_head_cache; 2832e23291b9SJose R. Santos #ifdef CONFIG_JBD2_DEBUG 2833470decc6SDave Kleikamp static atomic_t nr_journal_heads = ATOMIC_INIT(0); 2834470decc6SDave Kleikamp #endif 2835470decc6SDave Kleikamp 28360d52154bSChengguang Xu static int __init jbd2_journal_init_journal_head_cache(void) 2837470decc6SDave Kleikamp { 28380d52154bSChengguang Xu J_ASSERT(!jbd2_journal_head_cache); 2839a920e941SJohann Lombardi jbd2_journal_head_cache = kmem_cache_create("jbd2_journal_head", 2840470decc6SDave Kleikamp sizeof(struct journal_head), 2841470decc6SDave Kleikamp 0, /* offset */ 28425f0d5a3aSPaul E. McKenney SLAB_TEMPORARY | SLAB_TYPESAFE_BY_RCU, 284320c2df83SPaul Mundt NULL); /* ctor */ 28441076d17aSAl Viro if (!jbd2_journal_head_cache) { 2845f2a44523SEryu Guan printk(KERN_EMERG "JBD2: no memory for journal_head cache\n"); 28460d52154bSChengguang Xu return -ENOMEM; 2847470decc6SDave Kleikamp } 28480d52154bSChengguang Xu return 0; 2849470decc6SDave Kleikamp } 2850470decc6SDave Kleikamp 28514185a2acSYongqiang Yang static void jbd2_journal_destroy_journal_head_cache(void) 2852470decc6SDave Kleikamp { 2853f7f4bccbSMingming Cao kmem_cache_destroy(jbd2_journal_head_cache); 2854f7f4bccbSMingming Cao jbd2_journal_head_cache = NULL; 2855470decc6SDave Kleikamp } 2856470decc6SDave Kleikamp 2857470decc6SDave Kleikamp /* 2858470decc6SDave Kleikamp * journal_head splicing and dicing 2859470decc6SDave Kleikamp */ 2860470decc6SDave Kleikamp static struct journal_head *journal_alloc_journal_head(void) 2861470decc6SDave Kleikamp { 2862470decc6SDave Kleikamp struct journal_head *ret; 2863470decc6SDave Kleikamp 2864e23291b9SJose R. Santos #ifdef CONFIG_JBD2_DEBUG 2865470decc6SDave Kleikamp atomic_inc(&nr_journal_heads); 2866470decc6SDave Kleikamp #endif 28675d9cf9c6SZheng Liu ret = kmem_cache_zalloc(jbd2_journal_head_cache, GFP_NOFS); 28681076d17aSAl Viro if (!ret) { 2869cb3b3bf2SJan Kara jbd2_debug(1, "out of memory for journal_head\n"); 2870670be5a7STheodore Ts'o pr_notice_ratelimited("ENOMEM in %s, retrying.\n", __func__); 28717b506b10SMichal Hocko ret = kmem_cache_zalloc(jbd2_journal_head_cache, 28727b506b10SMichal Hocko GFP_NOFS | __GFP_NOFAIL); 2873470decc6SDave Kleikamp } 287446417064SThomas Gleixner if (ret) 287546417064SThomas Gleixner spin_lock_init(&ret->b_state_lock); 2876470decc6SDave Kleikamp return ret; 2877470decc6SDave Kleikamp } 2878470decc6SDave Kleikamp 2879470decc6SDave Kleikamp static void journal_free_journal_head(struct journal_head *jh) 2880470decc6SDave Kleikamp { 2881e23291b9SJose R. Santos #ifdef CONFIG_JBD2_DEBUG 2882470decc6SDave Kleikamp atomic_dec(&nr_journal_heads); 2883cd02ff0bSMingming Cao memset(jh, JBD2_POISON_FREE, sizeof(*jh)); 2884470decc6SDave Kleikamp #endif 2885f7f4bccbSMingming Cao kmem_cache_free(jbd2_journal_head_cache, jh); 2886470decc6SDave Kleikamp } 2887470decc6SDave Kleikamp 2888470decc6SDave Kleikamp /* 2889470decc6SDave Kleikamp * A journal_head is attached to a buffer_head whenever JBD has an 2890470decc6SDave Kleikamp * interest in the buffer. 2891470decc6SDave Kleikamp * 2892470decc6SDave Kleikamp * Whenever a buffer has an attached journal_head, its ->b_state:BH_JBD bit 2893470decc6SDave Kleikamp * is set. This bit is tested in core kernel code where we need to take 2894470decc6SDave Kleikamp * JBD-specific actions. Testing the zeroness of ->b_private is not reliable 2895470decc6SDave Kleikamp * there. 2896470decc6SDave Kleikamp * 2897470decc6SDave Kleikamp * When a buffer has its BH_JBD bit set, its ->b_count is elevated by one. 2898470decc6SDave Kleikamp * 2899470decc6SDave Kleikamp * When a buffer has its BH_JBD bit set it is immune from being released by 2900470decc6SDave Kleikamp * core kernel code, mainly via ->b_count. 2901470decc6SDave Kleikamp * 2902de1b7941SJan Kara * A journal_head is detached from its buffer_head when the journal_head's 2903de1b7941SJan Kara * b_jcount reaches zero. Running transaction (b_transaction) and checkpoint 2904de1b7941SJan Kara * transaction (b_cp_transaction) hold their references to b_jcount. 2905470decc6SDave Kleikamp * 2906470decc6SDave Kleikamp * Various places in the kernel want to attach a journal_head to a buffer_head 2907470decc6SDave Kleikamp * _before_ attaching the journal_head to a transaction. To protect the 2908f7f4bccbSMingming Cao * journal_head in this situation, jbd2_journal_add_journal_head elevates the 2909470decc6SDave Kleikamp * journal_head's b_jcount refcount by one. The caller must call 2910f7f4bccbSMingming Cao * jbd2_journal_put_journal_head() to undo this. 2911470decc6SDave Kleikamp * 2912470decc6SDave Kleikamp * So the typical usage would be: 2913470decc6SDave Kleikamp * 2914470decc6SDave Kleikamp * (Attach a journal_head if needed. Increments b_jcount) 2915f7f4bccbSMingming Cao * struct journal_head *jh = jbd2_journal_add_journal_head(bh); 2916470decc6SDave Kleikamp * ... 2917de1b7941SJan Kara * (Get another reference for transaction) 2918de1b7941SJan Kara * jbd2_journal_grab_journal_head(bh); 2919470decc6SDave Kleikamp * jh->b_transaction = xxx; 2920de1b7941SJan Kara * (Put original reference) 2921f7f4bccbSMingming Cao * jbd2_journal_put_journal_head(jh); 2922470decc6SDave Kleikamp */ 2923470decc6SDave Kleikamp 2924470decc6SDave Kleikamp /* 2925470decc6SDave Kleikamp * Give a buffer_head a journal_head. 2926470decc6SDave Kleikamp * 2927470decc6SDave Kleikamp * May sleep. 2928470decc6SDave Kleikamp */ 2929f7f4bccbSMingming Cao struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh) 2930470decc6SDave Kleikamp { 2931470decc6SDave Kleikamp struct journal_head *jh; 2932470decc6SDave Kleikamp struct journal_head *new_jh = NULL; 2933470decc6SDave Kleikamp 2934470decc6SDave Kleikamp repeat: 29355d9cf9c6SZheng Liu if (!buffer_jbd(bh)) 2936470decc6SDave Kleikamp new_jh = journal_alloc_journal_head(); 2937470decc6SDave Kleikamp 2938470decc6SDave Kleikamp jbd_lock_bh_journal_head(bh); 2939470decc6SDave Kleikamp if (buffer_jbd(bh)) { 2940470decc6SDave Kleikamp jh = bh2jh(bh); 2941470decc6SDave Kleikamp } else { 2942470decc6SDave Kleikamp J_ASSERT_BH(bh, 2943470decc6SDave Kleikamp (atomic_read(&bh->b_count) > 0) || 29440d22fe2fSMatthew Wilcox (Oracle) (bh->b_folio && bh->b_folio->mapping)); 2945470decc6SDave Kleikamp 2946470decc6SDave Kleikamp if (!new_jh) { 2947470decc6SDave Kleikamp jbd_unlock_bh_journal_head(bh); 2948470decc6SDave Kleikamp goto repeat; 2949470decc6SDave Kleikamp } 2950470decc6SDave Kleikamp 2951470decc6SDave Kleikamp jh = new_jh; 2952470decc6SDave Kleikamp new_jh = NULL; /* We consumed it */ 2953470decc6SDave Kleikamp set_buffer_jbd(bh); 2954470decc6SDave Kleikamp bh->b_private = jh; 2955470decc6SDave Kleikamp jh->b_bh = bh; 2956470decc6SDave Kleikamp get_bh(bh); 2957470decc6SDave Kleikamp BUFFER_TRACE(bh, "added journal_head"); 2958470decc6SDave Kleikamp } 2959470decc6SDave Kleikamp jh->b_jcount++; 2960470decc6SDave Kleikamp jbd_unlock_bh_journal_head(bh); 2961470decc6SDave Kleikamp if (new_jh) 2962470decc6SDave Kleikamp journal_free_journal_head(new_jh); 2963470decc6SDave Kleikamp return bh->b_private; 2964470decc6SDave Kleikamp } 2965470decc6SDave Kleikamp 2966470decc6SDave Kleikamp /* 2967470decc6SDave Kleikamp * Grab a ref against this buffer_head's journal_head. If it ended up not 2968470decc6SDave Kleikamp * having a journal_head, return NULL 2969470decc6SDave Kleikamp */ 2970f7f4bccbSMingming Cao struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh) 2971470decc6SDave Kleikamp { 2972470decc6SDave Kleikamp struct journal_head *jh = NULL; 2973470decc6SDave Kleikamp 2974470decc6SDave Kleikamp jbd_lock_bh_journal_head(bh); 2975470decc6SDave Kleikamp if (buffer_jbd(bh)) { 2976470decc6SDave Kleikamp jh = bh2jh(bh); 2977470decc6SDave Kleikamp jh->b_jcount++; 2978470decc6SDave Kleikamp } 2979470decc6SDave Kleikamp jbd_unlock_bh_journal_head(bh); 2980470decc6SDave Kleikamp return jh; 2981470decc6SDave Kleikamp } 29824cd1103dSJoseph Qi EXPORT_SYMBOL(jbd2_journal_grab_journal_head); 2983470decc6SDave Kleikamp 2984470decc6SDave Kleikamp static void __journal_remove_journal_head(struct buffer_head *bh) 2985470decc6SDave Kleikamp { 2986470decc6SDave Kleikamp struct journal_head *jh = bh2jh(bh); 2987470decc6SDave Kleikamp 2988de1b7941SJan Kara J_ASSERT_JH(jh, jh->b_transaction == NULL); 2989de1b7941SJan Kara J_ASSERT_JH(jh, jh->b_next_transaction == NULL); 2990de1b7941SJan Kara J_ASSERT_JH(jh, jh->b_cp_transaction == NULL); 2991470decc6SDave Kleikamp J_ASSERT_JH(jh, jh->b_jlist == BJ_None); 2992470decc6SDave Kleikamp J_ASSERT_BH(bh, buffer_jbd(bh)); 2993470decc6SDave Kleikamp J_ASSERT_BH(bh, jh2bh(jh) == bh); 2994470decc6SDave Kleikamp BUFFER_TRACE(bh, "remove journal_head"); 29957855a57dSThomas Gleixner 29967855a57dSThomas Gleixner /* Unlink before dropping the lock */ 2997470decc6SDave Kleikamp bh->b_private = NULL; 2998470decc6SDave Kleikamp jh->b_bh = NULL; /* debug, really */ 2999470decc6SDave Kleikamp clear_buffer_jbd(bh); 30007855a57dSThomas Gleixner } 30017855a57dSThomas Gleixner 30027855a57dSThomas Gleixner static void journal_release_journal_head(struct journal_head *jh, size_t b_size) 30037855a57dSThomas Gleixner { 30047855a57dSThomas Gleixner if (jh->b_frozen_data) { 30057855a57dSThomas Gleixner printk(KERN_WARNING "%s: freeing b_frozen_data\n", __func__); 30067855a57dSThomas Gleixner jbd2_free(jh->b_frozen_data, b_size); 30077855a57dSThomas Gleixner } 30087855a57dSThomas Gleixner if (jh->b_committed_data) { 30097855a57dSThomas Gleixner printk(KERN_WARNING "%s: freeing b_committed_data\n", __func__); 30107855a57dSThomas Gleixner jbd2_free(jh->b_committed_data, b_size); 30117855a57dSThomas Gleixner } 3012470decc6SDave Kleikamp journal_free_journal_head(jh); 3013470decc6SDave Kleikamp } 3014470decc6SDave Kleikamp 3015470decc6SDave Kleikamp /* 3016de1b7941SJan Kara * Drop a reference on the passed journal_head. If it fell to zero then 3017470decc6SDave Kleikamp * release the journal_head from the buffer_head. 3018470decc6SDave Kleikamp */ 3019f7f4bccbSMingming Cao void jbd2_journal_put_journal_head(struct journal_head *jh) 3020470decc6SDave Kleikamp { 3021470decc6SDave Kleikamp struct buffer_head *bh = jh2bh(jh); 3022470decc6SDave Kleikamp 3023470decc6SDave Kleikamp jbd_lock_bh_journal_head(bh); 3024470decc6SDave Kleikamp J_ASSERT_JH(jh, jh->b_jcount > 0); 3025470decc6SDave Kleikamp --jh->b_jcount; 3026de1b7941SJan Kara if (!jh->b_jcount) { 3027470decc6SDave Kleikamp __journal_remove_journal_head(bh); 3028de1b7941SJan Kara jbd_unlock_bh_journal_head(bh); 30297855a57dSThomas Gleixner journal_release_journal_head(jh, bh->b_size); 3030470decc6SDave Kleikamp __brelse(bh); 30317855a57dSThomas Gleixner } else { 3032470decc6SDave Kleikamp jbd_unlock_bh_journal_head(bh); 3033470decc6SDave Kleikamp } 30347855a57dSThomas Gleixner } 30354cd1103dSJoseph Qi EXPORT_SYMBOL(jbd2_journal_put_journal_head); 3036470decc6SDave Kleikamp 3037470decc6SDave Kleikamp /* 3038c851ed54SJan Kara * Initialize jbd inode head 3039c851ed54SJan Kara */ 3040c851ed54SJan Kara void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode) 3041c851ed54SJan Kara { 3042c851ed54SJan Kara jinode->i_transaction = NULL; 3043c851ed54SJan Kara jinode->i_next_transaction = NULL; 3044c851ed54SJan Kara jinode->i_vfs_inode = inode; 3045c851ed54SJan Kara jinode->i_flags = 0; 30466ba0e7dcSRoss Zwisler jinode->i_dirty_start = 0; 30476ba0e7dcSRoss Zwisler jinode->i_dirty_end = 0; 3048c851ed54SJan Kara INIT_LIST_HEAD(&jinode->i_list); 3049c851ed54SJan Kara } 3050c851ed54SJan Kara 3051c851ed54SJan Kara /* 3052c851ed54SJan Kara * Function to be called before we start removing inode from memory (i.e., 3053c851ed54SJan Kara * clear_inode() is a fine place to be called from). It removes inode from 3054c851ed54SJan Kara * transaction's lists. 3055c851ed54SJan Kara */ 3056c851ed54SJan Kara void jbd2_journal_release_jbd_inode(journal_t *journal, 3057c851ed54SJan Kara struct jbd2_inode *jinode) 3058c851ed54SJan Kara { 3059c851ed54SJan Kara if (!journal) 3060c851ed54SJan Kara return; 3061c851ed54SJan Kara restart: 3062c851ed54SJan Kara spin_lock(&journal->j_list_lock); 3063c851ed54SJan Kara /* Is commit writing out inode - we have to wait */ 3064cb0d9d47SJan Kara if (jinode->i_flags & JI_COMMIT_RUNNING) { 3065c851ed54SJan Kara wait_queue_head_t *wq; 3066c851ed54SJan Kara DEFINE_WAIT_BIT(wait, &jinode->i_flags, __JI_COMMIT_RUNNING); 3067c851ed54SJan Kara wq = bit_waitqueue(&jinode->i_flags, __JI_COMMIT_RUNNING); 306821417136SIngo Molnar prepare_to_wait(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE); 3069c851ed54SJan Kara spin_unlock(&journal->j_list_lock); 3070c851ed54SJan Kara schedule(); 307121417136SIngo Molnar finish_wait(wq, &wait.wq_entry); 3072c851ed54SJan Kara goto restart; 3073c851ed54SJan Kara } 3074c851ed54SJan Kara 3075c851ed54SJan Kara if (jinode->i_transaction) { 3076c851ed54SJan Kara list_del(&jinode->i_list); 3077c851ed54SJan Kara jinode->i_transaction = NULL; 3078c851ed54SJan Kara } 3079c851ed54SJan Kara spin_unlock(&journal->j_list_lock); 3080c851ed54SJan Kara } 3081c851ed54SJan Kara 3082470decc6SDave Kleikamp 30838e85fb3fSJohann Lombardi #ifdef CONFIG_PROC_FS 30848e85fb3fSJohann Lombardi 30858e85fb3fSJohann Lombardi #define JBD2_STATS_PROC_NAME "fs/jbd2" 30868e85fb3fSJohann Lombardi 30878e85fb3fSJohann Lombardi static void __init jbd2_create_jbd_stats_proc_entry(void) 30888e85fb3fSJohann Lombardi { 30898e85fb3fSJohann Lombardi proc_jbd2_stats = proc_mkdir(JBD2_STATS_PROC_NAME, NULL); 30908e85fb3fSJohann Lombardi } 30918e85fb3fSJohann Lombardi 30928e85fb3fSJohann Lombardi static void __exit jbd2_remove_jbd_stats_proc_entry(void) 30938e85fb3fSJohann Lombardi { 30948e85fb3fSJohann Lombardi if (proc_jbd2_stats) 30958e85fb3fSJohann Lombardi remove_proc_entry(JBD2_STATS_PROC_NAME, NULL); 30968e85fb3fSJohann Lombardi } 30978e85fb3fSJohann Lombardi 30988e85fb3fSJohann Lombardi #else 30998e85fb3fSJohann Lombardi 31008e85fb3fSJohann Lombardi #define jbd2_create_jbd_stats_proc_entry() do {} while (0) 31018e85fb3fSJohann Lombardi #define jbd2_remove_jbd_stats_proc_entry() do {} while (0) 31028e85fb3fSJohann Lombardi 31038e85fb3fSJohann Lombardi #endif 31048e85fb3fSJohann Lombardi 31058aefcd55STheodore Ts'o struct kmem_cache *jbd2_handle_cache, *jbd2_inode_cache; 3106470decc6SDave Kleikamp 31070d52154bSChengguang Xu static int __init jbd2_journal_init_inode_cache(void) 3108470decc6SDave Kleikamp { 31090d52154bSChengguang Xu J_ASSERT(!jbd2_inode_cache); 31108aefcd55STheodore Ts'o jbd2_inode_cache = KMEM_CACHE(jbd2_inode, 0); 31110d52154bSChengguang Xu if (!jbd2_inode_cache) { 31120d52154bSChengguang Xu pr_emerg("JBD2: failed to create inode cache\n"); 3113470decc6SDave Kleikamp return -ENOMEM; 3114470decc6SDave Kleikamp } 3115470decc6SDave Kleikamp return 0; 3116470decc6SDave Kleikamp } 3117470decc6SDave Kleikamp 31180d52154bSChengguang Xu static int __init jbd2_journal_init_handle_cache(void) 31190d52154bSChengguang Xu { 31200d52154bSChengguang Xu J_ASSERT(!jbd2_handle_cache); 31210d52154bSChengguang Xu jbd2_handle_cache = KMEM_CACHE(jbd2_journal_handle, SLAB_TEMPORARY); 31220d52154bSChengguang Xu if (!jbd2_handle_cache) { 31230d52154bSChengguang Xu printk(KERN_EMERG "JBD2: failed to create handle cache\n"); 31240d52154bSChengguang Xu return -ENOMEM; 31250d52154bSChengguang Xu } 31260d52154bSChengguang Xu return 0; 31270d52154bSChengguang Xu } 31280d52154bSChengguang Xu 31290d52154bSChengguang Xu static void jbd2_journal_destroy_inode_cache(void) 31300d52154bSChengguang Xu { 31310d52154bSChengguang Xu kmem_cache_destroy(jbd2_inode_cache); 31320d52154bSChengguang Xu jbd2_inode_cache = NULL; 31330d52154bSChengguang Xu } 31340d52154bSChengguang Xu 3135f7f4bccbSMingming Cao static void jbd2_journal_destroy_handle_cache(void) 3136470decc6SDave Kleikamp { 3137f7f4bccbSMingming Cao kmem_cache_destroy(jbd2_handle_cache); 31388bdd5b60SWang Long jbd2_handle_cache = NULL; 3139470decc6SDave Kleikamp } 3140470decc6SDave Kleikamp 3141470decc6SDave Kleikamp /* 3142470decc6SDave Kleikamp * Module startup and shutdown 3143470decc6SDave Kleikamp */ 3144470decc6SDave Kleikamp 3145470decc6SDave Kleikamp static int __init journal_init_caches(void) 3146470decc6SDave Kleikamp { 3147470decc6SDave Kleikamp int ret; 3148470decc6SDave Kleikamp 31490d52154bSChengguang Xu ret = jbd2_journal_init_revoke_record_cache(); 31500d52154bSChengguang Xu if (ret == 0) 31510d52154bSChengguang Xu ret = jbd2_journal_init_revoke_table_cache(); 3152470decc6SDave Kleikamp if (ret == 0) 31534185a2acSYongqiang Yang ret = jbd2_journal_init_journal_head_cache(); 3154470decc6SDave Kleikamp if (ret == 0) 31554185a2acSYongqiang Yang ret = jbd2_journal_init_handle_cache(); 31560c2022ecSYongqiang Yang if (ret == 0) 31570d52154bSChengguang Xu ret = jbd2_journal_init_inode_cache(); 31580d52154bSChengguang Xu if (ret == 0) 31590c2022ecSYongqiang Yang ret = jbd2_journal_init_transaction_cache(); 3160470decc6SDave Kleikamp return ret; 3161470decc6SDave Kleikamp } 3162470decc6SDave Kleikamp 3163f7f4bccbSMingming Cao static void jbd2_journal_destroy_caches(void) 3164470decc6SDave Kleikamp { 31650d52154bSChengguang Xu jbd2_journal_destroy_revoke_record_cache(); 31660d52154bSChengguang Xu jbd2_journal_destroy_revoke_table_cache(); 31674185a2acSYongqiang Yang jbd2_journal_destroy_journal_head_cache(); 3168f7f4bccbSMingming Cao jbd2_journal_destroy_handle_cache(); 31690d52154bSChengguang Xu jbd2_journal_destroy_inode_cache(); 31700c2022ecSYongqiang Yang jbd2_journal_destroy_transaction_cache(); 3171d2eecb03STheodore Ts'o jbd2_journal_destroy_slabs(); 3172470decc6SDave Kleikamp } 3173470decc6SDave Kleikamp 3174470decc6SDave Kleikamp static int __init journal_init(void) 3175470decc6SDave Kleikamp { 3176470decc6SDave Kleikamp int ret; 3177470decc6SDave Kleikamp 3178470decc6SDave Kleikamp BUILD_BUG_ON(sizeof(struct journal_superblock_s) != 1024); 3179470decc6SDave Kleikamp 3180470decc6SDave Kleikamp ret = journal_init_caches(); 3181620de4e1SDuane Griffin if (ret == 0) { 31828e85fb3fSJohann Lombardi jbd2_create_jbd_stats_proc_entry(); 3183620de4e1SDuane Griffin } else { 3184620de4e1SDuane Griffin jbd2_journal_destroy_caches(); 3185620de4e1SDuane Griffin } 3186470decc6SDave Kleikamp return ret; 3187470decc6SDave Kleikamp } 3188470decc6SDave Kleikamp 3189470decc6SDave Kleikamp static void __exit journal_exit(void) 3190470decc6SDave Kleikamp { 3191e23291b9SJose R. Santos #ifdef CONFIG_JBD2_DEBUG 3192470decc6SDave Kleikamp int n = atomic_read(&nr_journal_heads); 3193470decc6SDave Kleikamp if (n) 319475685071SJan Kara printk(KERN_ERR "JBD2: leaked %d journal_heads!\n", n); 3195470decc6SDave Kleikamp #endif 31968e85fb3fSJohann Lombardi jbd2_remove_jbd_stats_proc_entry(); 3197f7f4bccbSMingming Cao jbd2_journal_destroy_caches(); 3198470decc6SDave Kleikamp } 3199470decc6SDave Kleikamp 3200470decc6SDave Kleikamp MODULE_LICENSE("GPL"); 3201470decc6SDave Kleikamp module_init(journal_init); 3202470decc6SDave Kleikamp module_exit(journal_exit); 3203470decc6SDave Kleikamp 3204