1f5166768STheodore Ts'o // SPDX-License-Identifier: GPL-2.0+ 2470decc6SDave Kleikamp /* 358862699SUwe Kleine-König * linux/fs/jbd2/transaction.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 transaction handling code; part of the ext2fs 10470decc6SDave Kleikamp * journaling system. 11470decc6SDave Kleikamp * 12470decc6SDave Kleikamp * This file manages transactions (compound commits managed by the 13470decc6SDave Kleikamp * journaling code) and handles (individual atomic operations by the 14470decc6SDave Kleikamp * filesystem). 15470decc6SDave Kleikamp */ 16470decc6SDave Kleikamp 17470decc6SDave Kleikamp #include <linux/time.h> 18470decc6SDave Kleikamp #include <linux/fs.h> 19f7f4bccbSMingming Cao #include <linux/jbd2.h> 20470decc6SDave Kleikamp #include <linux/errno.h> 21470decc6SDave Kleikamp #include <linux/slab.h> 22470decc6SDave Kleikamp #include <linux/timer.h> 23470decc6SDave Kleikamp #include <linux/mm.h> 24470decc6SDave Kleikamp #include <linux/highmem.h> 25e07f7183SJosef Bacik #include <linux/hrtimer.h> 2647def826STheodore Ts'o #include <linux/backing-dev.h> 2744705754SRandy Dunlap #include <linux/bug.h> 2847def826STheodore Ts'o #include <linux/module.h> 2981378da6SMichal Hocko #include <linux/sched/mm.h> 30470decc6SDave Kleikamp 31343d9c28STheodore Ts'o #include <trace/events/jbd2.h> 32343d9c28STheodore Ts'o 337ddae860SAdrian Bunk static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh); 34de1b7941SJan Kara static void __jbd2_journal_unfile_buffer(struct journal_head *jh); 357ddae860SAdrian Bunk 360c2022ecSYongqiang Yang static struct kmem_cache *transaction_cache; 370c2022ecSYongqiang Yang int __init jbd2_journal_init_transaction_cache(void) 380c2022ecSYongqiang Yang { 390c2022ecSYongqiang Yang J_ASSERT(!transaction_cache); 400c2022ecSYongqiang Yang transaction_cache = kmem_cache_create("jbd2_transaction_s", 410c2022ecSYongqiang Yang sizeof(transaction_t), 420c2022ecSYongqiang Yang 0, 430c2022ecSYongqiang Yang SLAB_HWCACHE_ALIGN|SLAB_TEMPORARY, 440c2022ecSYongqiang Yang NULL); 450d52154bSChengguang Xu if (!transaction_cache) { 460d52154bSChengguang Xu pr_emerg("JBD2: failed to create transaction cache\n"); 470c2022ecSYongqiang Yang return -ENOMEM; 480c2022ecSYongqiang Yang } 490d52154bSChengguang Xu return 0; 500d52154bSChengguang Xu } 510c2022ecSYongqiang Yang 520c2022ecSYongqiang Yang void jbd2_journal_destroy_transaction_cache(void) 530c2022ecSYongqiang Yang { 540c2022ecSYongqiang Yang kmem_cache_destroy(transaction_cache); 550c2022ecSYongqiang Yang transaction_cache = NULL; 560c2022ecSYongqiang Yang } 570c2022ecSYongqiang Yang 580c2022ecSYongqiang Yang void jbd2_journal_free_transaction(transaction_t *transaction) 590c2022ecSYongqiang Yang { 600c2022ecSYongqiang Yang if (unlikely(ZERO_OR_NULL_PTR(transaction))) 610c2022ecSYongqiang Yang return; 620c2022ecSYongqiang Yang kmem_cache_free(transaction_cache, transaction); 630c2022ecSYongqiang Yang } 640c2022ecSYongqiang Yang 65470decc6SDave Kleikamp /* 6619014d69SJan Kara * Base amount of descriptor blocks we reserve for each transaction. 679f356e5aSJan Kara */ 689f356e5aSJan Kara static int jbd2_descriptor_blocks_per_trans(journal_t *journal) 699f356e5aSJan Kara { 7019014d69SJan Kara int tag_space = journal->j_blocksize - sizeof(journal_header_t); 7119014d69SJan Kara int tags_per_block; 7219014d69SJan Kara 7319014d69SJan Kara /* Subtract UUID */ 7419014d69SJan Kara tag_space -= 16; 7519014d69SJan Kara if (jbd2_journal_has_csum_v2or3(journal)) 7619014d69SJan Kara tag_space -= sizeof(struct jbd2_journal_block_tail); 7719014d69SJan Kara /* Commit code leaves a slack space of 16 bytes at the end of block */ 7819014d69SJan Kara tags_per_block = (tag_space - 16) / journal_tag_bytes(journal); 7919014d69SJan Kara /* 8019014d69SJan Kara * Revoke descriptors are accounted separately so we need to reserve 8119014d69SJan Kara * space for commit block and normal transaction descriptor blocks. 8219014d69SJan Kara */ 8319014d69SJan Kara return 1 + DIV_ROUND_UP(journal->j_max_transaction_buffers, 8419014d69SJan Kara tags_per_block); 859f356e5aSJan Kara } 869f356e5aSJan Kara 879f356e5aSJan Kara /* 88f7f4bccbSMingming Cao * jbd2_get_transaction: obtain a new transaction_t object. 89470decc6SDave Kleikamp * 900df6f469SLiu Song * Simply initialise a new transaction. Initialize it in 91470decc6SDave Kleikamp * RUNNING state and add it to the current journal (which should not 92470decc6SDave Kleikamp * have an existing running transaction: we only make a new transaction 93470decc6SDave Kleikamp * once we have started to commit the old one). 94470decc6SDave Kleikamp * 95470decc6SDave Kleikamp * Preconditions: 96470decc6SDave Kleikamp * The journal MUST be locked. We don't perform atomic mallocs on the 97470decc6SDave Kleikamp * new transaction and we can't block without protecting against other 98470decc6SDave Kleikamp * processes trying to touch the journal while it is in transition. 99470decc6SDave Kleikamp * 100470decc6SDave Kleikamp */ 101470decc6SDave Kleikamp 1020df6f469SLiu Song static void jbd2_get_transaction(journal_t *journal, 1030df6f469SLiu Song transaction_t *transaction) 104470decc6SDave Kleikamp { 105470decc6SDave Kleikamp transaction->t_journal = journal; 106470decc6SDave Kleikamp transaction->t_state = T_RUNNING; 107e07f7183SJosef Bacik transaction->t_start_time = ktime_get(); 108470decc6SDave Kleikamp transaction->t_tid = journal->j_transaction_sequence++; 109470decc6SDave Kleikamp transaction->t_expires = jiffies + journal->j_commit_interval; 110470decc6SDave Kleikamp spin_lock_init(&transaction->t_handle_lock); 111a51dca9cSTheodore Ts'o atomic_set(&transaction->t_updates, 0); 1128f7d89f3SJan Kara atomic_set(&transaction->t_outstanding_credits, 1139f356e5aSJan Kara jbd2_descriptor_blocks_per_trans(journal) + 1148f7d89f3SJan Kara atomic_read(&journal->j_reserved_credits)); 115fdc3ef88SJan Kara atomic_set(&transaction->t_outstanding_revokes, 0); 1168dd42046STheodore Ts'o atomic_set(&transaction->t_handle_count, 0); 117c851ed54SJan Kara INIT_LIST_HEAD(&transaction->t_inode_list); 1183e624fc7STheodore Ts'o INIT_LIST_HEAD(&transaction->t_private_list); 119470decc6SDave Kleikamp 120470decc6SDave Kleikamp /* Set up the commit timer for the new transaction. */ 121b1f485f2SAndreas Dilger journal->j_commit_timer.expires = round_jiffies_up(transaction->t_expires); 122470decc6SDave Kleikamp add_timer(&journal->j_commit_timer); 123470decc6SDave Kleikamp 124470decc6SDave Kleikamp J_ASSERT(journal->j_running_transaction == NULL); 125470decc6SDave Kleikamp journal->j_running_transaction = transaction; 1268e85fb3fSJohann Lombardi transaction->t_max_wait = 0; 1278e85fb3fSJohann Lombardi transaction->t_start = jiffies; 1289fff24aaSTheodore Ts'o transaction->t_requested = 0; 129470decc6SDave Kleikamp } 130470decc6SDave Kleikamp 131470decc6SDave Kleikamp /* 132470decc6SDave Kleikamp * Handle management. 133470decc6SDave Kleikamp * 134470decc6SDave Kleikamp * A handle_t is an object which represents a single atomic update to a 135470decc6SDave Kleikamp * filesystem, and which tracks all of the modifications which form part 136470decc6SDave Kleikamp * of that one update. 137470decc6SDave Kleikamp */ 138470decc6SDave Kleikamp 139470decc6SDave Kleikamp /* 14028e35e42STao Ma * Update transaction's maximum wait time, if debugging is enabled. 1416d0bf005STheodore Ts'o * 1426d0bf005STheodore Ts'o * In order for t_max_wait to be reliable, it must be protected by a 1436d0bf005STheodore Ts'o * lock. But doing so will mean that start_this_handle() can not be 1446d0bf005STheodore Ts'o * run in parallel on SMP systems, which limits our scalability. So 1456d0bf005STheodore Ts'o * unless debugging is enabled, we no longer update t_max_wait, which 1466d0bf005STheodore Ts'o * means that maximum wait time reported by the jbd2_run_stats 1476d0bf005STheodore Ts'o * tracepoint will always be zero. 1486d0bf005STheodore Ts'o */ 14928e35e42STao Ma static inline void update_t_max_wait(transaction_t *transaction, 15028e35e42STao Ma unsigned long ts) 1516d0bf005STheodore Ts'o { 1526d0bf005STheodore Ts'o #ifdef CONFIG_JBD2_DEBUG 1536d0bf005STheodore Ts'o if (jbd2_journal_enable_debug && 1546d0bf005STheodore Ts'o time_after(transaction->t_start, ts)) { 1556d0bf005STheodore Ts'o ts = jbd2_time_diff(ts, transaction->t_start); 1566d0bf005STheodore Ts'o spin_lock(&transaction->t_handle_lock); 1576d0bf005STheodore Ts'o if (ts > transaction->t_max_wait) 1586d0bf005STheodore Ts'o transaction->t_max_wait = ts; 1596d0bf005STheodore Ts'o spin_unlock(&transaction->t_handle_lock); 1606d0bf005STheodore Ts'o } 1616d0bf005STheodore Ts'o #endif 1626d0bf005STheodore Ts'o } 1636d0bf005STheodore Ts'o 1646d0bf005STheodore Ts'o /* 16596f1e097SJan Kara * Wait until running transaction passes to T_FLUSH state and new transaction 16696f1e097SJan Kara * can thus be started. Also starts the commit if needed. The function expects 16796f1e097SJan Kara * running transaction to exist and releases j_state_lock. 1688f7d89f3SJan Kara */ 1698f7d89f3SJan Kara static void wait_transaction_locked(journal_t *journal) 1708f7d89f3SJan Kara __releases(journal->j_state_lock) 1718f7d89f3SJan Kara { 1728f7d89f3SJan Kara DEFINE_WAIT(wait); 1738f7d89f3SJan Kara int need_to_start; 1748f7d89f3SJan Kara tid_t tid = journal->j_running_transaction->t_tid; 1758f7d89f3SJan Kara 1768f7d89f3SJan Kara prepare_to_wait(&journal->j_wait_transaction_locked, &wait, 1778f7d89f3SJan Kara TASK_UNINTERRUPTIBLE); 1788f7d89f3SJan Kara need_to_start = !tid_geq(journal->j_commit_request, tid); 1798f7d89f3SJan Kara read_unlock(&journal->j_state_lock); 1808f7d89f3SJan Kara if (need_to_start) 1818f7d89f3SJan Kara jbd2_log_start_commit(journal, tid); 182e03a9976SJan Kara jbd2_might_wait_for_commit(journal); 1838f7d89f3SJan Kara schedule(); 1848f7d89f3SJan Kara finish_wait(&journal->j_wait_transaction_locked, &wait); 1858f7d89f3SJan Kara } 1868f7d89f3SJan Kara 18796f1e097SJan Kara /* 18896f1e097SJan Kara * Wait until running transaction transitions from T_SWITCH to T_FLUSH 18996f1e097SJan Kara * state and new transaction can thus be started. The function releases 19096f1e097SJan Kara * j_state_lock. 19196f1e097SJan Kara */ 19296f1e097SJan Kara static void wait_transaction_switching(journal_t *journal) 19396f1e097SJan Kara __releases(journal->j_state_lock) 19496f1e097SJan Kara { 19596f1e097SJan Kara DEFINE_WAIT(wait); 19696f1e097SJan Kara 19796f1e097SJan Kara if (WARN_ON(!journal->j_running_transaction || 19896f1e097SJan Kara journal->j_running_transaction->t_state != T_SWITCH)) 19996f1e097SJan Kara return; 20096f1e097SJan Kara prepare_to_wait(&journal->j_wait_transaction_locked, &wait, 20196f1e097SJan Kara TASK_UNINTERRUPTIBLE); 20296f1e097SJan Kara read_unlock(&journal->j_state_lock); 20396f1e097SJan Kara /* 20496f1e097SJan Kara * We don't call jbd2_might_wait_for_commit() here as there's no 20596f1e097SJan Kara * waiting for outstanding handles happening anymore in T_SWITCH state 20696f1e097SJan Kara * and handling of reserved handles actually relies on that for 20796f1e097SJan Kara * correctness. 20896f1e097SJan Kara */ 20996f1e097SJan Kara schedule(); 21096f1e097SJan Kara finish_wait(&journal->j_wait_transaction_locked, &wait); 21196f1e097SJan Kara } 21296f1e097SJan Kara 2138f7d89f3SJan Kara static void sub_reserved_credits(journal_t *journal, int blocks) 2148f7d89f3SJan Kara { 2158f7d89f3SJan Kara atomic_sub(blocks, &journal->j_reserved_credits); 2168f7d89f3SJan Kara wake_up(&journal->j_wait_reserved); 2178f7d89f3SJan Kara } 2188f7d89f3SJan Kara 2198f7d89f3SJan Kara /* 2208f7d89f3SJan Kara * Wait until we can add credits for handle to the running transaction. Called 2218f7d89f3SJan Kara * with j_state_lock held for reading. Returns 0 if handle joined the running 2228f7d89f3SJan Kara * transaction. Returns 1 if we had to wait, j_state_lock is dropped, and 2238f7d89f3SJan Kara * caller must retry. 2248f7d89f3SJan Kara */ 2258f7d89f3SJan Kara static int add_transaction_credits(journal_t *journal, int blocks, 2268f7d89f3SJan Kara int rsv_blocks) 2278f7d89f3SJan Kara { 2288f7d89f3SJan Kara transaction_t *t = journal->j_running_transaction; 2298f7d89f3SJan Kara int needed; 2308f7d89f3SJan Kara int total = blocks + rsv_blocks; 2318f7d89f3SJan Kara 2328f7d89f3SJan Kara /* 2338f7d89f3SJan Kara * If the current transaction is locked down for commit, wait 2348f7d89f3SJan Kara * for the lock to be released. 2358f7d89f3SJan Kara */ 23696f1e097SJan Kara if (t->t_state != T_RUNNING) { 23796f1e097SJan Kara WARN_ON_ONCE(t->t_state >= T_FLUSH); 2388f7d89f3SJan Kara wait_transaction_locked(journal); 2398f7d89f3SJan Kara return 1; 2408f7d89f3SJan Kara } 2418f7d89f3SJan Kara 2428f7d89f3SJan Kara /* 2438f7d89f3SJan Kara * If there is not enough space left in the log to write all 2448f7d89f3SJan Kara * potential buffers requested by this operation, we need to 2458f7d89f3SJan Kara * stall pending a log checkpoint to free some more log space. 2468f7d89f3SJan Kara */ 2478f7d89f3SJan Kara needed = atomic_add_return(total, &t->t_outstanding_credits); 2488f7d89f3SJan Kara if (needed > journal->j_max_transaction_buffers) { 2498f7d89f3SJan Kara /* 2508f7d89f3SJan Kara * If the current transaction is already too large, 2518f7d89f3SJan Kara * then start to commit it: we can then go back and 2528f7d89f3SJan Kara * attach this handle to a new transaction. 2538f7d89f3SJan Kara */ 2548f7d89f3SJan Kara atomic_sub(total, &t->t_outstanding_credits); 2556d3ec14dSLukas Czerner 2566d3ec14dSLukas Czerner /* 2576d3ec14dSLukas Czerner * Is the number of reserved credits in the current transaction too 2586d3ec14dSLukas Czerner * big to fit this handle? Wait until reserved credits are freed. 2596d3ec14dSLukas Czerner */ 2606d3ec14dSLukas Czerner if (atomic_read(&journal->j_reserved_credits) + total > 2616d3ec14dSLukas Czerner journal->j_max_transaction_buffers) { 2626d3ec14dSLukas Czerner read_unlock(&journal->j_state_lock); 263e03a9976SJan Kara jbd2_might_wait_for_commit(journal); 2646d3ec14dSLukas Czerner wait_event(journal->j_wait_reserved, 2656d3ec14dSLukas Czerner atomic_read(&journal->j_reserved_credits) + total <= 2666d3ec14dSLukas Czerner journal->j_max_transaction_buffers); 2676d3ec14dSLukas Czerner return 1; 2686d3ec14dSLukas Czerner } 2696d3ec14dSLukas Czerner 2708f7d89f3SJan Kara wait_transaction_locked(journal); 2718f7d89f3SJan Kara return 1; 2728f7d89f3SJan Kara } 2738f7d89f3SJan Kara 2748f7d89f3SJan Kara /* 2758f7d89f3SJan Kara * The commit code assumes that it can get enough log space 2768f7d89f3SJan Kara * without forcing a checkpoint. This is *critical* for 2778f7d89f3SJan Kara * correctness: a checkpoint of a buffer which is also 2788f7d89f3SJan Kara * associated with a committing transaction creates a deadlock, 2798f7d89f3SJan Kara * so commit simply cannot force through checkpoints. 2808f7d89f3SJan Kara * 2818f7d89f3SJan Kara * We must therefore ensure the necessary space in the journal 2828f7d89f3SJan Kara * *before* starting to dirty potentially checkpointed buffers 2838f7d89f3SJan Kara * in the new transaction. 2848f7d89f3SJan Kara */ 28577444ac4SJan Kara if (jbd2_log_space_left(journal) < journal->j_max_transaction_buffers) { 2868f7d89f3SJan Kara atomic_sub(total, &t->t_outstanding_credits); 2878f7d89f3SJan Kara read_unlock(&journal->j_state_lock); 288e03a9976SJan Kara jbd2_might_wait_for_commit(journal); 2898f7d89f3SJan Kara write_lock(&journal->j_state_lock); 29077444ac4SJan Kara if (jbd2_log_space_left(journal) < 29177444ac4SJan Kara journal->j_max_transaction_buffers) 2928f7d89f3SJan Kara __jbd2_log_wait_for_space(journal); 2938f7d89f3SJan Kara write_unlock(&journal->j_state_lock); 2948f7d89f3SJan Kara return 1; 2958f7d89f3SJan Kara } 2968f7d89f3SJan Kara 2978f7d89f3SJan Kara /* No reservation? We are done... */ 2988f7d89f3SJan Kara if (!rsv_blocks) 2998f7d89f3SJan Kara return 0; 3008f7d89f3SJan Kara 3018f7d89f3SJan Kara needed = atomic_add_return(rsv_blocks, &journal->j_reserved_credits); 3028f7d89f3SJan Kara /* We allow at most half of a transaction to be reserved */ 3038f7d89f3SJan Kara if (needed > journal->j_max_transaction_buffers / 2) { 3048f7d89f3SJan Kara sub_reserved_credits(journal, rsv_blocks); 3058f7d89f3SJan Kara atomic_sub(total, &t->t_outstanding_credits); 3068f7d89f3SJan Kara read_unlock(&journal->j_state_lock); 307e03a9976SJan Kara jbd2_might_wait_for_commit(journal); 3088f7d89f3SJan Kara wait_event(journal->j_wait_reserved, 3098f7d89f3SJan Kara atomic_read(&journal->j_reserved_credits) + rsv_blocks 3108f7d89f3SJan Kara <= journal->j_max_transaction_buffers / 2); 3118f7d89f3SJan Kara return 1; 3128f7d89f3SJan Kara } 3138f7d89f3SJan Kara return 0; 3148f7d89f3SJan Kara } 3158f7d89f3SJan Kara 3168f7d89f3SJan Kara /* 317470decc6SDave Kleikamp * start_this_handle: Given a handle, deal with any locking or stalling 318470decc6SDave Kleikamp * needed to make sure that there is enough journal space for the handle 319470decc6SDave Kleikamp * to begin. Attach the handle to a transaction and set up the 320470decc6SDave Kleikamp * transaction's buffer credits. 321470decc6SDave Kleikamp */ 322470decc6SDave Kleikamp 32347def826STheodore Ts'o static int start_this_handle(journal_t *journal, handle_t *handle, 324d2159fb7SDan Carpenter gfp_t gfp_mask) 325470decc6SDave Kleikamp { 326e4471831STheodore Ts'o transaction_t *transaction, *new_transaction = NULL; 327933f1c1eSJan Kara int blocks = handle->h_total_credits; 3288f7d89f3SJan Kara int rsv_blocks = 0; 32928e35e42STao Ma unsigned long ts = jiffies; 330470decc6SDave Kleikamp 3318f7d89f3SJan Kara if (handle->h_rsv_handle) 332933f1c1eSJan Kara rsv_blocks = handle->h_rsv_handle->h_total_credits; 3338f7d89f3SJan Kara 3346d3ec14dSLukas Czerner /* 3356d3ec14dSLukas Czerner * Limit the number of reserved credits to 1/2 of maximum transaction 3366d3ec14dSLukas Czerner * size and limit the number of total credits to not exceed maximum 3376d3ec14dSLukas Czerner * transaction size per operation. 3386d3ec14dSLukas Czerner */ 3396d3ec14dSLukas Czerner if ((rsv_blocks > journal->j_max_transaction_buffers / 2) || 3406d3ec14dSLukas Czerner (rsv_blocks + blocks > journal->j_max_transaction_buffers)) { 3416d3ec14dSLukas Czerner printk(KERN_ERR "JBD2: %s wants too many credits " 3426d3ec14dSLukas Czerner "credits:%d rsv_credits:%d max:%d\n", 3436d3ec14dSLukas Czerner current->comm, blocks, rsv_blocks, 3446d3ec14dSLukas Czerner journal->j_max_transaction_buffers); 3456d3ec14dSLukas Czerner WARN_ON(1); 3466d3ec14dSLukas Czerner return -ENOSPC; 3476d3ec14dSLukas Czerner } 3486d3ec14dSLukas Czerner 349470decc6SDave Kleikamp alloc_transaction: 350470decc6SDave Kleikamp if (!journal->j_running_transaction) { 3516ccaf3e2SMichal Hocko /* 3526ccaf3e2SMichal Hocko * If __GFP_FS is not present, then we may be being called from 3536ccaf3e2SMichal Hocko * inside the fs writeback layer, so we MUST NOT fail. 3546ccaf3e2SMichal Hocko */ 3556ccaf3e2SMichal Hocko if ((gfp_mask & __GFP_FS) == 0) 3566ccaf3e2SMichal Hocko gfp_mask |= __GFP_NOFAIL; 357b2f4edb3SWanlong Gao new_transaction = kmem_cache_zalloc(transaction_cache, 358b2f4edb3SWanlong Gao gfp_mask); 3596ccaf3e2SMichal Hocko if (!new_transaction) 36047def826STheodore Ts'o return -ENOMEM; 361470decc6SDave Kleikamp } 362470decc6SDave Kleikamp 363470decc6SDave Kleikamp jbd_debug(3, "New handle %p going live.\n", handle); 364470decc6SDave Kleikamp 365470decc6SDave Kleikamp /* 366470decc6SDave Kleikamp * We need to hold j_state_lock until t_updates has been incremented, 367470decc6SDave Kleikamp * for proper journal barrier handling 368470decc6SDave Kleikamp */ 369a931da6aSTheodore Ts'o repeat: 370a931da6aSTheodore Ts'o read_lock(&journal->j_state_lock); 3715c2178e7STheodore Ts'o BUG_ON(journal->j_flags & JBD2_UNMOUNT); 372470decc6SDave Kleikamp if (is_journal_aborted(journal) || 373f7f4bccbSMingming Cao (journal->j_errno != 0 && !(journal->j_flags & JBD2_ACK_ERR))) { 374a931da6aSTheodore Ts'o read_unlock(&journal->j_state_lock); 3750c2022ecSYongqiang Yang jbd2_journal_free_transaction(new_transaction); 37647def826STheodore Ts'o return -EROFS; 377470decc6SDave Kleikamp } 378470decc6SDave Kleikamp 3798f7d89f3SJan Kara /* 3808f7d89f3SJan Kara * Wait on the journal's transaction barrier if necessary. Specifically 3818f7d89f3SJan Kara * we allow reserved handles to proceed because otherwise commit could 3828f7d89f3SJan Kara * deadlock on page writeback not being able to complete. 3838f7d89f3SJan Kara */ 3848f7d89f3SJan Kara if (!handle->h_reserved && journal->j_barrier_count) { 385a931da6aSTheodore Ts'o read_unlock(&journal->j_state_lock); 386470decc6SDave Kleikamp wait_event(journal->j_wait_transaction_locked, 387470decc6SDave Kleikamp journal->j_barrier_count == 0); 388470decc6SDave Kleikamp goto repeat; 389470decc6SDave Kleikamp } 390470decc6SDave Kleikamp 391470decc6SDave Kleikamp if (!journal->j_running_transaction) { 392a931da6aSTheodore Ts'o read_unlock(&journal->j_state_lock); 393a931da6aSTheodore Ts'o if (!new_transaction) 394470decc6SDave Kleikamp goto alloc_transaction; 395a931da6aSTheodore Ts'o write_lock(&journal->j_state_lock); 396d7961c7fSJan Kara if (!journal->j_running_transaction && 3978f7d89f3SJan Kara (handle->h_reserved || !journal->j_barrier_count)) { 398f7f4bccbSMingming Cao jbd2_get_transaction(journal, new_transaction); 399470decc6SDave Kleikamp new_transaction = NULL; 400470decc6SDave Kleikamp } 401a931da6aSTheodore Ts'o write_unlock(&journal->j_state_lock); 402a931da6aSTheodore Ts'o goto repeat; 403a931da6aSTheodore Ts'o } 404470decc6SDave Kleikamp 405470decc6SDave Kleikamp transaction = journal->j_running_transaction; 406470decc6SDave Kleikamp 4078f7d89f3SJan Kara if (!handle->h_reserved) { 4088f7d89f3SJan Kara /* We may have dropped j_state_lock - restart in that case */ 4098f7d89f3SJan Kara if (add_transaction_credits(journal, blocks, rsv_blocks)) 410470decc6SDave Kleikamp goto repeat; 4118f7d89f3SJan Kara } else { 412470decc6SDave Kleikamp /* 4138f7d89f3SJan Kara * We have handle reserved so we are allowed to join T_LOCKED 4148f7d89f3SJan Kara * transaction and we don't have to check for transaction size 41596f1e097SJan Kara * and journal space. But we still have to wait while running 41696f1e097SJan Kara * transaction is being switched to a committing one as it 41796f1e097SJan Kara * won't wait for any handles anymore. 418470decc6SDave Kleikamp */ 41996f1e097SJan Kara if (transaction->t_state == T_SWITCH) { 42096f1e097SJan Kara wait_transaction_switching(journal); 42196f1e097SJan Kara goto repeat; 42296f1e097SJan Kara } 4238f7d89f3SJan Kara sub_reserved_credits(journal, blocks); 4248f7d89f3SJan Kara handle->h_reserved = 0; 425470decc6SDave Kleikamp } 426470decc6SDave Kleikamp 427470decc6SDave Kleikamp /* OK, account for the buffers that this operation expects to 4288dd42046STheodore Ts'o * use and add the handle to the running transaction. 4298dd42046STheodore Ts'o */ 43028e35e42STao Ma update_t_max_wait(transaction, ts); 431470decc6SDave Kleikamp handle->h_transaction = transaction; 4328f7d89f3SJan Kara handle->h_requested_credits = blocks; 433fdc3ef88SJan Kara handle->h_revoke_credits_requested = handle->h_revoke_credits; 434343d9c28STheodore Ts'o handle->h_start_jiffies = jiffies; 435a51dca9cSTheodore Ts'o atomic_inc(&transaction->t_updates); 4368dd42046STheodore Ts'o atomic_inc(&transaction->t_handle_count); 4378f7d89f3SJan Kara jbd_debug(4, "Handle %p given %d credits (total %d, free %lu)\n", 4388f7d89f3SJan Kara handle, blocks, 439a51dca9cSTheodore Ts'o atomic_read(&transaction->t_outstanding_credits), 44076c39904SJan Kara jbd2_log_space_left(journal)); 441a931da6aSTheodore Ts'o read_unlock(&journal->j_state_lock); 44241a5b913STheodore Ts'o current->journal_info = handle; 4439599b0e5SJan Kara 444ab714affSJan Kara rwsem_acquire_read(&journal->j_trans_commit_map, 0, 0, _THIS_IP_); 4450c2022ecSYongqiang Yang jbd2_journal_free_transaction(new_transaction); 44681378da6SMichal Hocko /* 44781378da6SMichal Hocko * Ensure that no allocations done while the transaction is open are 44881378da6SMichal Hocko * going to recurse back to the fs layer. 44981378da6SMichal Hocko */ 45081378da6SMichal Hocko handle->saved_alloc_context = memalloc_nofs_save(); 45147def826STheodore Ts'o return 0; 452470decc6SDave Kleikamp } 453470decc6SDave Kleikamp 454470decc6SDave Kleikamp /* Allocate a new handle. This should probably be in a slab... */ 455470decc6SDave Kleikamp static handle_t *new_handle(int nblocks) 456470decc6SDave Kleikamp { 457af1e76d6SMingming Cao handle_t *handle = jbd2_alloc_handle(GFP_NOFS); 458470decc6SDave Kleikamp if (!handle) 459470decc6SDave Kleikamp return NULL; 460933f1c1eSJan Kara handle->h_total_credits = nblocks; 461470decc6SDave Kleikamp handle->h_ref = 1; 462470decc6SDave Kleikamp 463470decc6SDave Kleikamp return handle; 464470decc6SDave Kleikamp } 465470decc6SDave Kleikamp 4668f7d89f3SJan Kara handle_t *jbd2__journal_start(journal_t *journal, int nblocks, int rsv_blocks, 467fdc3ef88SJan Kara int revoke_records, gfp_t gfp_mask, 468fdc3ef88SJan Kara unsigned int type, unsigned int line_no) 469470decc6SDave Kleikamp { 470470decc6SDave Kleikamp handle_t *handle = journal_current_handle(); 471470decc6SDave Kleikamp int err; 472470decc6SDave Kleikamp 473470decc6SDave Kleikamp if (!journal) 474470decc6SDave Kleikamp return ERR_PTR(-EROFS); 475470decc6SDave Kleikamp 476470decc6SDave Kleikamp if (handle) { 477470decc6SDave Kleikamp J_ASSERT(handle->h_transaction->t_journal == journal); 478470decc6SDave Kleikamp handle->h_ref++; 479470decc6SDave Kleikamp return handle; 480470decc6SDave Kleikamp } 481470decc6SDave Kleikamp 482fdc3ef88SJan Kara nblocks += DIV_ROUND_UP(revoke_records, 483fdc3ef88SJan Kara journal->j_revoke_records_per_block); 484470decc6SDave Kleikamp handle = new_handle(nblocks); 485470decc6SDave Kleikamp if (!handle) 486470decc6SDave Kleikamp return ERR_PTR(-ENOMEM); 4878f7d89f3SJan Kara if (rsv_blocks) { 4888f7d89f3SJan Kara handle_t *rsv_handle; 4898f7d89f3SJan Kara 4908f7d89f3SJan Kara rsv_handle = new_handle(rsv_blocks); 4918f7d89f3SJan Kara if (!rsv_handle) { 4928f7d89f3SJan Kara jbd2_free_handle(handle); 4938f7d89f3SJan Kara return ERR_PTR(-ENOMEM); 4948f7d89f3SJan Kara } 4958f7d89f3SJan Kara rsv_handle->h_reserved = 1; 4968f7d89f3SJan Kara rsv_handle->h_journal = journal; 4978f7d89f3SJan Kara handle->h_rsv_handle = rsv_handle; 4988f7d89f3SJan Kara } 499fdc3ef88SJan Kara handle->h_revoke_credits = revoke_records; 500470decc6SDave Kleikamp 50147def826STheodore Ts'o err = start_this_handle(journal, handle, gfp_mask); 502470decc6SDave Kleikamp if (err < 0) { 5038f7d89f3SJan Kara if (handle->h_rsv_handle) 5048f7d89f3SJan Kara jbd2_free_handle(handle->h_rsv_handle); 505af1e76d6SMingming Cao jbd2_free_handle(handle); 506df05c1b8SDmitry Monakhov return ERR_PTR(err); 507470decc6SDave Kleikamp } 508343d9c28STheodore Ts'o handle->h_type = type; 509343d9c28STheodore Ts'o handle->h_line_no = line_no; 510343d9c28STheodore Ts'o trace_jbd2_handle_start(journal->j_fs_dev->bd_dev, 511343d9c28STheodore Ts'o handle->h_transaction->t_tid, type, 512343d9c28STheodore Ts'o line_no, nblocks); 51381378da6SMichal Hocko 514470decc6SDave Kleikamp return handle; 515470decc6SDave Kleikamp } 51647def826STheodore Ts'o EXPORT_SYMBOL(jbd2__journal_start); 51747def826STheodore Ts'o 51847def826STheodore Ts'o 51991e4775dSMauro Carvalho Chehab /** 52091e4775dSMauro Carvalho Chehab * handle_t *jbd2_journal_start() - Obtain a new handle. 52191e4775dSMauro Carvalho Chehab * @journal: Journal to start transaction on. 52291e4775dSMauro Carvalho Chehab * @nblocks: number of block buffer we might modify 52391e4775dSMauro Carvalho Chehab * 52491e4775dSMauro Carvalho Chehab * We make sure that the transaction can guarantee at least nblocks of 52591e4775dSMauro Carvalho Chehab * modified buffers in the log. We block until the log can guarantee 52691e4775dSMauro Carvalho Chehab * that much space. Additionally, if rsv_blocks > 0, we also create another 52791e4775dSMauro Carvalho Chehab * handle with rsv_blocks reserved blocks in the journal. This handle is 52891e4775dSMauro Carvalho Chehab * is stored in h_rsv_handle. It is not attached to any particular transaction 52991e4775dSMauro Carvalho Chehab * and thus doesn't block transaction commit. If the caller uses this reserved 53091e4775dSMauro Carvalho Chehab * handle, it has to set h_rsv_handle to NULL as otherwise jbd2_journal_stop() 53191e4775dSMauro Carvalho Chehab * on the parent handle will dispose the reserved one. Reserved handle has to 53291e4775dSMauro Carvalho Chehab * be converted to a normal handle using jbd2_journal_start_reserved() before 53391e4775dSMauro Carvalho Chehab * it can be used. 53491e4775dSMauro Carvalho Chehab * 53591e4775dSMauro Carvalho Chehab * Return a pointer to a newly allocated handle, or an ERR_PTR() value 53691e4775dSMauro Carvalho Chehab * on failure. 53791e4775dSMauro Carvalho Chehab */ 53847def826STheodore Ts'o handle_t *jbd2_journal_start(journal_t *journal, int nblocks) 53947def826STheodore Ts'o { 540fdc3ef88SJan Kara return jbd2__journal_start(journal, nblocks, 0, 0, GFP_NOFS, 0, 0); 54147def826STheodore Ts'o } 54247def826STheodore Ts'o EXPORT_SYMBOL(jbd2_journal_start); 54347def826STheodore Ts'o 544ec8b6f60SJan Kara static void __jbd2_journal_unreserve_handle(handle_t *handle) 5458f7d89f3SJan Kara { 5468f7d89f3SJan Kara journal_t *journal = handle->h_journal; 5478f7d89f3SJan Kara 5488f7d89f3SJan Kara WARN_ON(!handle->h_reserved); 549933f1c1eSJan Kara sub_reserved_credits(journal, handle->h_total_credits); 550ec8b6f60SJan Kara } 551ec8b6f60SJan Kara 552ec8b6f60SJan Kara void jbd2_journal_free_reserved(handle_t *handle) 553ec8b6f60SJan Kara { 554ec8b6f60SJan Kara __jbd2_journal_unreserve_handle(handle); 5558f7d89f3SJan Kara jbd2_free_handle(handle); 5568f7d89f3SJan Kara } 5578f7d89f3SJan Kara EXPORT_SYMBOL(jbd2_journal_free_reserved); 5588f7d89f3SJan Kara 5598f7d89f3SJan Kara /** 560f69120ceSTobin C. Harding * int jbd2_journal_start_reserved() - start reserved handle 5618f7d89f3SJan Kara * @handle: handle to start 562f69120ceSTobin C. Harding * @type: for handle statistics 563f69120ceSTobin C. Harding * @line_no: for handle statistics 5648f7d89f3SJan Kara * 5658f7d89f3SJan Kara * Start handle that has been previously reserved with jbd2_journal_reserve(). 5668f7d89f3SJan Kara * This attaches @handle to the running transaction (or creates one if there's 5678f7d89f3SJan Kara * not transaction running). Unlike jbd2_journal_start() this function cannot 5688f7d89f3SJan Kara * block on journal commit, checkpointing, or similar stuff. It can block on 5698f7d89f3SJan Kara * memory allocation or frozen journal though. 5708f7d89f3SJan Kara * 5718f7d89f3SJan Kara * Return 0 on success, non-zero on error - handle is freed in that case. 5728f7d89f3SJan Kara */ 5738f7d89f3SJan Kara int jbd2_journal_start_reserved(handle_t *handle, unsigned int type, 5748f7d89f3SJan Kara unsigned int line_no) 5758f7d89f3SJan Kara { 5768f7d89f3SJan Kara journal_t *journal = handle->h_journal; 5778f7d89f3SJan Kara int ret = -EIO; 5788f7d89f3SJan Kara 5798f7d89f3SJan Kara if (WARN_ON(!handle->h_reserved)) { 5808f7d89f3SJan Kara /* Someone passed in normal handle? Just stop it. */ 5818f7d89f3SJan Kara jbd2_journal_stop(handle); 5828f7d89f3SJan Kara return ret; 5838f7d89f3SJan Kara } 5848f7d89f3SJan Kara /* 5858f7d89f3SJan Kara * Usefulness of mixing of reserved and unreserved handles is 5868f7d89f3SJan Kara * questionable. So far nobody seems to need it so just error out. 5878f7d89f3SJan Kara */ 5888f7d89f3SJan Kara if (WARN_ON(current->journal_info)) { 5898f7d89f3SJan Kara jbd2_journal_free_reserved(handle); 5908f7d89f3SJan Kara return ret; 5918f7d89f3SJan Kara } 5928f7d89f3SJan Kara 5938f7d89f3SJan Kara handle->h_journal = NULL; 5948f7d89f3SJan Kara /* 5958f7d89f3SJan Kara * GFP_NOFS is here because callers are likely from writeback or 5968f7d89f3SJan Kara * similarly constrained call sites 5978f7d89f3SJan Kara */ 5988f7d89f3SJan Kara ret = start_this_handle(journal, handle, GFP_NOFS); 59992e3b405SDan Carpenter if (ret < 0) { 600b2569260STheodore Ts'o handle->h_journal = journal; 6018f7d89f3SJan Kara jbd2_journal_free_reserved(handle); 60292e3b405SDan Carpenter return ret; 60392e3b405SDan Carpenter } 6048f7d89f3SJan Kara handle->h_type = type; 6058f7d89f3SJan Kara handle->h_line_no = line_no; 6064c273352SXiaoguang Wang trace_jbd2_handle_start(journal->j_fs_dev->bd_dev, 6074c273352SXiaoguang Wang handle->h_transaction->t_tid, type, 608933f1c1eSJan Kara line_no, handle->h_total_credits); 60992e3b405SDan Carpenter return 0; 6108f7d89f3SJan Kara } 6118f7d89f3SJan Kara EXPORT_SYMBOL(jbd2_journal_start_reserved); 612470decc6SDave Kleikamp 613470decc6SDave Kleikamp /** 614f7f4bccbSMingming Cao * int jbd2_journal_extend() - extend buffer credits. 615470decc6SDave Kleikamp * @handle: handle to 'extend' 616470decc6SDave Kleikamp * @nblocks: nr blocks to try to extend by. 617fdc3ef88SJan Kara * @revoke_records: number of revoke records to try to extend by. 618470decc6SDave Kleikamp * 619470decc6SDave Kleikamp * Some transactions, such as large extends and truncates, can be done 620470decc6SDave Kleikamp * atomically all at once or in several stages. The operation requests 621bd7ced98SMasanari Iida * a credit for a number of buffer modifications in advance, but can 622470decc6SDave Kleikamp * extend its credit if it needs more. 623470decc6SDave Kleikamp * 624f7f4bccbSMingming Cao * jbd2_journal_extend tries to give the running handle more buffer credits. 625470decc6SDave Kleikamp * It does not guarantee that allocation - this is a best-effort only. 626470decc6SDave Kleikamp * The calling process MUST be able to deal cleanly with a failure to 627470decc6SDave Kleikamp * extend here. 628470decc6SDave Kleikamp * 629470decc6SDave Kleikamp * Return 0 on success, non-zero on failure. 630470decc6SDave Kleikamp * 631470decc6SDave Kleikamp * return code < 0 implies an error 632470decc6SDave Kleikamp * return code > 0 implies normal transaction-full status. 633470decc6SDave Kleikamp */ 634fdc3ef88SJan Kara int jbd2_journal_extend(handle_t *handle, int nblocks, int revoke_records) 635470decc6SDave Kleikamp { 636470decc6SDave Kleikamp transaction_t *transaction = handle->h_transaction; 63741a5b913STheodore Ts'o journal_t *journal; 638470decc6SDave Kleikamp int result; 639470decc6SDave Kleikamp int wanted; 640470decc6SDave Kleikamp 641470decc6SDave Kleikamp if (is_handle_aborted(handle)) 64241a5b913STheodore Ts'o return -EROFS; 64341a5b913STheodore Ts'o journal = transaction->t_journal; 644470decc6SDave Kleikamp 645470decc6SDave Kleikamp result = 1; 646470decc6SDave Kleikamp 647a931da6aSTheodore Ts'o read_lock(&journal->j_state_lock); 648470decc6SDave Kleikamp 649470decc6SDave Kleikamp /* Don't extend a locked-down transaction! */ 65041a5b913STheodore Ts'o if (transaction->t_state != T_RUNNING) { 651470decc6SDave Kleikamp jbd_debug(3, "denied handle %p %d blocks: " 652470decc6SDave Kleikamp "transaction not running\n", handle, nblocks); 653470decc6SDave Kleikamp goto error_out; 654470decc6SDave Kleikamp } 655470decc6SDave Kleikamp 656fdc3ef88SJan Kara nblocks += DIV_ROUND_UP( 657fdc3ef88SJan Kara handle->h_revoke_credits_requested + revoke_records, 658fdc3ef88SJan Kara journal->j_revoke_records_per_block) - 659fdc3ef88SJan Kara DIV_ROUND_UP( 660fdc3ef88SJan Kara handle->h_revoke_credits_requested, 661fdc3ef88SJan Kara journal->j_revoke_records_per_block); 662470decc6SDave Kleikamp spin_lock(&transaction->t_handle_lock); 663fe1e8db5SJan Kara wanted = atomic_add_return(nblocks, 664fe1e8db5SJan Kara &transaction->t_outstanding_credits); 665470decc6SDave Kleikamp 666470decc6SDave Kleikamp if (wanted > journal->j_max_transaction_buffers) { 667470decc6SDave Kleikamp jbd_debug(3, "denied handle %p %d blocks: " 668470decc6SDave Kleikamp "transaction too large\n", handle, nblocks); 669fe1e8db5SJan Kara atomic_sub(nblocks, &transaction->t_outstanding_credits); 670470decc6SDave Kleikamp goto unlock; 671470decc6SDave Kleikamp } 672470decc6SDave Kleikamp 673343d9c28STheodore Ts'o trace_jbd2_handle_extend(journal->j_fs_dev->bd_dev, 67441a5b913STheodore Ts'o transaction->t_tid, 675343d9c28STheodore Ts'o handle->h_type, handle->h_line_no, 676933f1c1eSJan Kara handle->h_total_credits, 677343d9c28STheodore Ts'o nblocks); 678343d9c28STheodore Ts'o 679933f1c1eSJan Kara handle->h_total_credits += nblocks; 680343d9c28STheodore Ts'o handle->h_requested_credits += nblocks; 681fdc3ef88SJan Kara handle->h_revoke_credits += revoke_records; 682fdc3ef88SJan Kara handle->h_revoke_credits_requested += revoke_records; 683470decc6SDave Kleikamp result = 0; 684470decc6SDave Kleikamp 685470decc6SDave Kleikamp jbd_debug(3, "extended handle %p by %d\n", handle, nblocks); 686470decc6SDave Kleikamp unlock: 687470decc6SDave Kleikamp spin_unlock(&transaction->t_handle_lock); 688470decc6SDave Kleikamp error_out: 689a931da6aSTheodore Ts'o read_unlock(&journal->j_state_lock); 690470decc6SDave Kleikamp return result; 691470decc6SDave Kleikamp } 692470decc6SDave Kleikamp 693ec8b6f60SJan Kara static void stop_this_handle(handle_t *handle) 694ec8b6f60SJan Kara { 695ec8b6f60SJan Kara transaction_t *transaction = handle->h_transaction; 696ec8b6f60SJan Kara journal_t *journal = transaction->t_journal; 697fdc3ef88SJan Kara int revokes; 698ec8b6f60SJan Kara 699ec8b6f60SJan Kara J_ASSERT(journal_current_handle() == handle); 700ec8b6f60SJan Kara J_ASSERT(atomic_read(&transaction->t_updates) > 0); 701ec8b6f60SJan Kara current->journal_info = NULL; 702fdc3ef88SJan Kara /* 703fdc3ef88SJan Kara * Subtract necessary revoke descriptor blocks from handle credits. We 704fdc3ef88SJan Kara * take care to account only for revoke descriptor blocks the 705fdc3ef88SJan Kara * transaction will really need as large sequences of transactions with 706fdc3ef88SJan Kara * small numbers of revokes are relatively common. 707fdc3ef88SJan Kara */ 708fdc3ef88SJan Kara revokes = handle->h_revoke_credits_requested - handle->h_revoke_credits; 709fdc3ef88SJan Kara if (revokes) { 710fdc3ef88SJan Kara int t_revokes, revoke_descriptors; 711fdc3ef88SJan Kara int rr_per_blk = journal->j_revoke_records_per_block; 712fdc3ef88SJan Kara 713fdc3ef88SJan Kara WARN_ON_ONCE(DIV_ROUND_UP(revokes, rr_per_blk) 714933f1c1eSJan Kara > handle->h_total_credits); 715fdc3ef88SJan Kara t_revokes = atomic_add_return(revokes, 716fdc3ef88SJan Kara &transaction->t_outstanding_revokes); 717fdc3ef88SJan Kara revoke_descriptors = 718fdc3ef88SJan Kara DIV_ROUND_UP(t_revokes, rr_per_blk) - 719fdc3ef88SJan Kara DIV_ROUND_UP(t_revokes - revokes, rr_per_blk); 720933f1c1eSJan Kara handle->h_total_credits -= revoke_descriptors; 721fdc3ef88SJan Kara } 722933f1c1eSJan Kara atomic_sub(handle->h_total_credits, 723ec8b6f60SJan Kara &transaction->t_outstanding_credits); 724ec8b6f60SJan Kara if (handle->h_rsv_handle) 725ec8b6f60SJan Kara __jbd2_journal_unreserve_handle(handle->h_rsv_handle); 726ec8b6f60SJan Kara if (atomic_dec_and_test(&transaction->t_updates)) 727ec8b6f60SJan Kara wake_up(&journal->j_wait_updates); 728ec8b6f60SJan Kara 729ec8b6f60SJan Kara rwsem_release(&journal->j_trans_commit_map, 1, _THIS_IP_); 730ec8b6f60SJan Kara /* 731ec8b6f60SJan Kara * Scope of the GFP_NOFS context is over here and so we can restore the 732ec8b6f60SJan Kara * original alloc context. 733ec8b6f60SJan Kara */ 734ec8b6f60SJan Kara memalloc_nofs_restore(handle->saved_alloc_context); 735ec8b6f60SJan Kara } 736470decc6SDave Kleikamp 737470decc6SDave Kleikamp /** 738f7f4bccbSMingming Cao * int jbd2_journal_restart() - restart a handle . 739470decc6SDave Kleikamp * @handle: handle to restart 740470decc6SDave Kleikamp * @nblocks: nr credits requested 741fdc3ef88SJan Kara * @revoke_records: number of revoke record credits requested 742f69120ceSTobin C. Harding * @gfp_mask: memory allocation flags (for start_this_handle) 743470decc6SDave Kleikamp * 744470decc6SDave Kleikamp * Restart a handle for a multi-transaction filesystem 745470decc6SDave Kleikamp * operation. 746470decc6SDave Kleikamp * 747f7f4bccbSMingming Cao * If the jbd2_journal_extend() call above fails to grant new buffer credits 748f7f4bccbSMingming Cao * to a running handle, a call to jbd2_journal_restart will commit the 749470decc6SDave Kleikamp * handle's transaction so far and reattach the handle to a new 750bd7ced98SMasanari Iida * transaction capable of guaranteeing the requested number of 7518f7d89f3SJan Kara * credits. We preserve reserved handle if there's any attached to the 7528f7d89f3SJan Kara * passed in handle. 753470decc6SDave Kleikamp */ 754fdc3ef88SJan Kara int jbd2__journal_restart(handle_t *handle, int nblocks, int revoke_records, 755fdc3ef88SJan Kara gfp_t gfp_mask) 756470decc6SDave Kleikamp { 757470decc6SDave Kleikamp transaction_t *transaction = handle->h_transaction; 75841a5b913STheodore Ts'o journal_t *journal; 759e4471831STheodore Ts'o tid_t tid; 760ec8b6f60SJan Kara int need_to_start; 7610094f981SJan Kara int ret; 762470decc6SDave Kleikamp 763470decc6SDave Kleikamp /* If we've had an abort of any type, don't even think about 764470decc6SDave Kleikamp * actually doing the restart! */ 765470decc6SDave Kleikamp if (is_handle_aborted(handle)) 766470decc6SDave Kleikamp return 0; 76741a5b913STheodore Ts'o journal = transaction->t_journal; 768ec8b6f60SJan Kara tid = transaction->t_tid; 769470decc6SDave Kleikamp 770470decc6SDave Kleikamp /* 771470decc6SDave Kleikamp * First unlink the handle from its current transaction, and start the 772470decc6SDave Kleikamp * commit on that. 773470decc6SDave Kleikamp */ 774470decc6SDave Kleikamp jbd_debug(2, "restarting handle %p\n", handle); 775ec8b6f60SJan Kara stop_this_handle(handle); 776ec8b6f60SJan Kara handle->h_transaction = NULL; 777ec8b6f60SJan Kara 778ec8b6f60SJan Kara /* 779ec8b6f60SJan Kara * TODO: If we use READ_ONCE / WRITE_ONCE for j_commit_request we can 780ec8b6f60SJan Kara * get rid of pointless j_state_lock traffic like this. 781ec8b6f60SJan Kara */ 782ec8b6f60SJan Kara read_lock(&journal->j_state_lock); 783e4471831STheodore Ts'o need_to_start = !tid_geq(journal->j_commit_request, tid); 784a931da6aSTheodore Ts'o read_unlock(&journal->j_state_lock); 785e4471831STheodore Ts'o if (need_to_start) 786e4471831STheodore Ts'o jbd2_log_start_commit(journal, tid); 787933f1c1eSJan Kara handle->h_total_credits = nblocks + 788fdc3ef88SJan Kara DIV_ROUND_UP(revoke_records, 789fdc3ef88SJan Kara journal->j_revoke_records_per_block); 790fdc3ef88SJan Kara handle->h_revoke_credits = revoke_records; 7910094f981SJan Kara ret = start_this_handle(journal, handle, gfp_mask); 7920094f981SJan Kara trace_jbd2_handle_restart(journal->j_fs_dev->bd_dev, 7930094f981SJan Kara ret ? 0 : handle->h_transaction->t_tid, 7940094f981SJan Kara handle->h_type, handle->h_line_no, 7950094f981SJan Kara handle->h_total_credits); 7960094f981SJan Kara return ret; 797470decc6SDave Kleikamp } 79847def826STheodore Ts'o EXPORT_SYMBOL(jbd2__journal_restart); 799470decc6SDave Kleikamp 800470decc6SDave Kleikamp 80147def826STheodore Ts'o int jbd2_journal_restart(handle_t *handle, int nblocks) 80247def826STheodore Ts'o { 803fdc3ef88SJan Kara return jbd2__journal_restart(handle, nblocks, 0, GFP_NOFS); 80447def826STheodore Ts'o } 80547def826STheodore Ts'o EXPORT_SYMBOL(jbd2_journal_restart); 80647def826STheodore Ts'o 807470decc6SDave Kleikamp /** 808f7f4bccbSMingming Cao * void jbd2_journal_lock_updates () - establish a transaction barrier. 809470decc6SDave Kleikamp * @journal: Journal to establish a barrier on. 810470decc6SDave Kleikamp * 811470decc6SDave Kleikamp * This locks out any further updates from being started, and blocks 812470decc6SDave Kleikamp * until all existing updates have completed, returning only once the 813470decc6SDave Kleikamp * journal is in a quiescent state with no updates running. 814470decc6SDave Kleikamp * 815470decc6SDave Kleikamp * The journal lock should not be held on entry. 816470decc6SDave Kleikamp */ 817f7f4bccbSMingming Cao void jbd2_journal_lock_updates(journal_t *journal) 818470decc6SDave Kleikamp { 819470decc6SDave Kleikamp DEFINE_WAIT(wait); 820470decc6SDave Kleikamp 8211eaa566dSJan Kara jbd2_might_wait_for_commit(journal); 8221eaa566dSJan Kara 823a931da6aSTheodore Ts'o write_lock(&journal->j_state_lock); 824470decc6SDave Kleikamp ++journal->j_barrier_count; 825470decc6SDave Kleikamp 8268f7d89f3SJan Kara /* Wait until there are no reserved handles */ 8278f7d89f3SJan Kara if (atomic_read(&journal->j_reserved_credits)) { 8288f7d89f3SJan Kara write_unlock(&journal->j_state_lock); 8298f7d89f3SJan Kara wait_event(journal->j_wait_reserved, 8308f7d89f3SJan Kara atomic_read(&journal->j_reserved_credits) == 0); 8318f7d89f3SJan Kara write_lock(&journal->j_state_lock); 8328f7d89f3SJan Kara } 8338f7d89f3SJan Kara 834470decc6SDave Kleikamp /* Wait until there are no running updates */ 835470decc6SDave Kleikamp while (1) { 836470decc6SDave Kleikamp transaction_t *transaction = journal->j_running_transaction; 837470decc6SDave Kleikamp 838470decc6SDave Kleikamp if (!transaction) 839470decc6SDave Kleikamp break; 840470decc6SDave Kleikamp 841470decc6SDave Kleikamp spin_lock(&transaction->t_handle_lock); 842470decc6SDave Kleikamp prepare_to_wait(&journal->j_wait_updates, &wait, 843470decc6SDave Kleikamp TASK_UNINTERRUPTIBLE); 8449837d8e9SJan Kara if (!atomic_read(&transaction->t_updates)) { 8459837d8e9SJan Kara spin_unlock(&transaction->t_handle_lock); 8469837d8e9SJan Kara finish_wait(&journal->j_wait_updates, &wait); 8479837d8e9SJan Kara break; 8489837d8e9SJan Kara } 849470decc6SDave Kleikamp spin_unlock(&transaction->t_handle_lock); 850a931da6aSTheodore Ts'o write_unlock(&journal->j_state_lock); 851470decc6SDave Kleikamp schedule(); 852470decc6SDave Kleikamp finish_wait(&journal->j_wait_updates, &wait); 853a931da6aSTheodore Ts'o write_lock(&journal->j_state_lock); 854470decc6SDave Kleikamp } 855a931da6aSTheodore Ts'o write_unlock(&journal->j_state_lock); 856470decc6SDave Kleikamp 857470decc6SDave Kleikamp /* 858470decc6SDave Kleikamp * We have now established a barrier against other normal updates, but 859f7f4bccbSMingming Cao * we also need to barrier against other jbd2_journal_lock_updates() calls 860470decc6SDave Kleikamp * to make sure that we serialise special journal-locked operations 861470decc6SDave Kleikamp * too. 862470decc6SDave Kleikamp */ 863470decc6SDave Kleikamp mutex_lock(&journal->j_barrier); 864470decc6SDave Kleikamp } 865470decc6SDave Kleikamp 866470decc6SDave Kleikamp /** 867f7f4bccbSMingming Cao * void jbd2_journal_unlock_updates (journal_t* journal) - release barrier 868470decc6SDave Kleikamp * @journal: Journal to release the barrier on. 869470decc6SDave Kleikamp * 870f7f4bccbSMingming Cao * Release a transaction barrier obtained with jbd2_journal_lock_updates(). 871470decc6SDave Kleikamp * 872470decc6SDave Kleikamp * Should be called without the journal lock held. 873470decc6SDave Kleikamp */ 874f7f4bccbSMingming Cao void jbd2_journal_unlock_updates (journal_t *journal) 875470decc6SDave Kleikamp { 876470decc6SDave Kleikamp J_ASSERT(journal->j_barrier_count != 0); 877470decc6SDave Kleikamp 878470decc6SDave Kleikamp mutex_unlock(&journal->j_barrier); 879a931da6aSTheodore Ts'o write_lock(&journal->j_state_lock); 880470decc6SDave Kleikamp --journal->j_barrier_count; 881a931da6aSTheodore Ts'o write_unlock(&journal->j_state_lock); 882470decc6SDave Kleikamp wake_up(&journal->j_wait_transaction_locked); 883470decc6SDave Kleikamp } 884470decc6SDave Kleikamp 885f91d1d04SJan Kara static void warn_dirty_buffer(struct buffer_head *bh) 886470decc6SDave Kleikamp { 887f91d1d04SJan Kara printk(KERN_WARNING 888a1c6f057SDmitry Monakhov "JBD2: Spotted dirty metadata buffer (dev = %pg, blocknr = %llu). " 889f91d1d04SJan Kara "There's a risk of filesystem corruption in case of system " 890f91d1d04SJan Kara "crash.\n", 891a1c6f057SDmitry Monakhov bh->b_bdev, (unsigned long long)bh->b_blocknr); 892470decc6SDave Kleikamp } 893470decc6SDave Kleikamp 894ee57aba1SJan Kara /* Call t_frozen trigger and copy buffer data into jh->b_frozen_data. */ 895ee57aba1SJan Kara static void jbd2_freeze_jh_data(struct journal_head *jh) 896ee57aba1SJan Kara { 897ee57aba1SJan Kara struct page *page; 898ee57aba1SJan Kara int offset; 899ee57aba1SJan Kara char *source; 900ee57aba1SJan Kara struct buffer_head *bh = jh2bh(jh); 901ee57aba1SJan Kara 902ee57aba1SJan Kara J_EXPECT_JH(jh, buffer_uptodate(bh), "Possible IO failure.\n"); 903ee57aba1SJan Kara page = bh->b_page; 904ee57aba1SJan Kara offset = offset_in_page(bh->b_data); 905ee57aba1SJan Kara source = kmap_atomic(page); 906ee57aba1SJan Kara /* Fire data frozen trigger just before we copy the data */ 907ee57aba1SJan Kara jbd2_buffer_frozen_trigger(jh, source + offset, jh->b_triggers); 908ee57aba1SJan Kara memcpy(jh->b_frozen_data, source + offset, bh->b_size); 909ee57aba1SJan Kara kunmap_atomic(source); 910ee57aba1SJan Kara 911ee57aba1SJan Kara /* 912ee57aba1SJan Kara * Now that the frozen data is saved off, we need to store any matching 913ee57aba1SJan Kara * triggers. 914ee57aba1SJan Kara */ 915ee57aba1SJan Kara jh->b_frozen_triggers = jh->b_triggers; 916ee57aba1SJan Kara } 917ee57aba1SJan Kara 918470decc6SDave Kleikamp /* 919470decc6SDave Kleikamp * If the buffer is already part of the current transaction, then there 920470decc6SDave Kleikamp * is nothing we need to do. If it is already part of a prior 921470decc6SDave Kleikamp * transaction which we are still committing to disk, then we need to 922470decc6SDave Kleikamp * make sure that we do not overwrite the old copy: we do copy-out to 923470decc6SDave Kleikamp * preserve the copy going to disk. We also account the buffer against 924470decc6SDave Kleikamp * the handle's metadata buffer credits (unless the buffer is already 925470decc6SDave Kleikamp * part of the transaction, that is). 926470decc6SDave Kleikamp * 927470decc6SDave Kleikamp */ 928470decc6SDave Kleikamp static int 929470decc6SDave Kleikamp do_get_write_access(handle_t *handle, struct journal_head *jh, 930470decc6SDave Kleikamp int force_copy) 931470decc6SDave Kleikamp { 932470decc6SDave Kleikamp struct buffer_head *bh; 93341a5b913STheodore Ts'o transaction_t *transaction = handle->h_transaction; 934470decc6SDave Kleikamp journal_t *journal; 935470decc6SDave Kleikamp int error; 936470decc6SDave Kleikamp char *frozen_buffer = NULL; 937f783f091STheodore Ts'o unsigned long start_lock, time_lock; 938470decc6SDave Kleikamp 939470decc6SDave Kleikamp if (is_handle_aborted(handle)) 940470decc6SDave Kleikamp return -EROFS; 941470decc6SDave Kleikamp journal = transaction->t_journal; 942470decc6SDave Kleikamp 943cfef2c6aSTheodore Ts'o jbd_debug(5, "journal_head %p, force_copy %d\n", jh, force_copy); 944470decc6SDave Kleikamp 945470decc6SDave Kleikamp JBUFFER_TRACE(jh, "entry"); 946470decc6SDave Kleikamp repeat: 947470decc6SDave Kleikamp bh = jh2bh(jh); 948470decc6SDave Kleikamp 949470decc6SDave Kleikamp /* @@@ Need to check for errors here at some point. */ 950470decc6SDave Kleikamp 951f783f091STheodore Ts'o start_lock = jiffies; 952470decc6SDave Kleikamp lock_buffer(bh); 953470decc6SDave Kleikamp jbd_lock_bh_state(bh); 954470decc6SDave Kleikamp 955f783f091STheodore Ts'o /* If it takes too long to lock the buffer, trace it */ 956f783f091STheodore Ts'o time_lock = jbd2_time_diff(start_lock, jiffies); 957f783f091STheodore Ts'o if (time_lock > HZ/10) 958f783f091STheodore Ts'o trace_jbd2_lock_buffer_stall(bh->b_bdev->bd_dev, 959f783f091STheodore Ts'o jiffies_to_msecs(time_lock)); 960f783f091STheodore Ts'o 961470decc6SDave Kleikamp /* We now hold the buffer lock so it is safe to query the buffer 962470decc6SDave Kleikamp * state. Is the buffer dirty? 963470decc6SDave Kleikamp * 964470decc6SDave Kleikamp * If so, there are two possibilities. The buffer may be 965470decc6SDave Kleikamp * non-journaled, and undergoing a quite legitimate writeback. 966470decc6SDave Kleikamp * Otherwise, it is journaled, and we don't expect dirty buffers 967470decc6SDave Kleikamp * in that state (the buffers should be marked JBD_Dirty 968470decc6SDave Kleikamp * instead.) So either the IO is being done under our own 969470decc6SDave Kleikamp * control and this is a bug, or it's a third party IO such as 970470decc6SDave Kleikamp * dump(8) (which may leave the buffer scheduled for read --- 971470decc6SDave Kleikamp * ie. locked but not dirty) or tune2fs (which may actually have 972470decc6SDave Kleikamp * the buffer dirtied, ugh.) */ 973470decc6SDave Kleikamp 974470decc6SDave Kleikamp if (buffer_dirty(bh)) { 975470decc6SDave Kleikamp /* 976470decc6SDave Kleikamp * First question: is this buffer already part of the current 977470decc6SDave Kleikamp * transaction or the existing committing transaction? 978470decc6SDave Kleikamp */ 979470decc6SDave Kleikamp if (jh->b_transaction) { 980470decc6SDave Kleikamp J_ASSERT_JH(jh, 981470decc6SDave Kleikamp jh->b_transaction == transaction || 982470decc6SDave Kleikamp jh->b_transaction == 983470decc6SDave Kleikamp journal->j_committing_transaction); 984470decc6SDave Kleikamp if (jh->b_next_transaction) 985470decc6SDave Kleikamp J_ASSERT_JH(jh, jh->b_next_transaction == 986470decc6SDave Kleikamp transaction); 987f91d1d04SJan Kara warn_dirty_buffer(bh); 988470decc6SDave Kleikamp } 989470decc6SDave Kleikamp /* 990470decc6SDave Kleikamp * In any case we need to clean the dirty flag and we must 991470decc6SDave Kleikamp * do it under the buffer lock to be sure we don't race 992470decc6SDave Kleikamp * with running write-out. 993470decc6SDave Kleikamp */ 994f91d1d04SJan Kara JBUFFER_TRACE(jh, "Journalling dirty buffer"); 995f91d1d04SJan Kara clear_buffer_dirty(bh); 996f91d1d04SJan Kara set_buffer_jbddirty(bh); 997470decc6SDave Kleikamp } 998470decc6SDave Kleikamp 999470decc6SDave Kleikamp unlock_buffer(bh); 1000470decc6SDave Kleikamp 1001470decc6SDave Kleikamp error = -EROFS; 1002470decc6SDave Kleikamp if (is_handle_aborted(handle)) { 1003470decc6SDave Kleikamp jbd_unlock_bh_state(bh); 1004470decc6SDave Kleikamp goto out; 1005470decc6SDave Kleikamp } 1006470decc6SDave Kleikamp error = 0; 1007470decc6SDave Kleikamp 1008470decc6SDave Kleikamp /* 1009470decc6SDave Kleikamp * The buffer is already part of this transaction if b_transaction or 1010470decc6SDave Kleikamp * b_next_transaction points to it 1011470decc6SDave Kleikamp */ 1012470decc6SDave Kleikamp if (jh->b_transaction == transaction || 1013470decc6SDave Kleikamp jh->b_next_transaction == transaction) 1014470decc6SDave Kleikamp goto done; 1015470decc6SDave Kleikamp 1016470decc6SDave Kleikamp /* 10179fc7c63aSJosef Bacik * this is the first time this transaction is touching this buffer, 10189fc7c63aSJosef Bacik * reset the modified flag 10199fc7c63aSJosef Bacik */ 10209fc7c63aSJosef Bacik jh->b_modified = 0; 10219fc7c63aSJosef Bacik 10229fc7c63aSJosef Bacik /* 10238b00f400SJan Kara * If the buffer is not journaled right now, we need to make sure it 10248b00f400SJan Kara * doesn't get written to disk before the caller actually commits the 10258b00f400SJan Kara * new data 10268b00f400SJan Kara */ 10278b00f400SJan Kara if (!jh->b_transaction) { 10288b00f400SJan Kara JBUFFER_TRACE(jh, "no transaction"); 10298b00f400SJan Kara J_ASSERT_JH(jh, !jh->b_next_transaction); 10308b00f400SJan Kara JBUFFER_TRACE(jh, "file as BJ_Reserved"); 1031de92c8caSJan Kara /* 1032de92c8caSJan Kara * Make sure all stores to jh (b_modified, b_frozen_data) are 1033de92c8caSJan Kara * visible before attaching it to the running transaction. 1034de92c8caSJan Kara * Paired with barrier in jbd2_write_access_granted() 1035de92c8caSJan Kara */ 1036de92c8caSJan Kara smp_wmb(); 10378b00f400SJan Kara spin_lock(&journal->j_list_lock); 10388b00f400SJan Kara __jbd2_journal_file_buffer(jh, transaction, BJ_Reserved); 10398b00f400SJan Kara spin_unlock(&journal->j_list_lock); 10408b00f400SJan Kara goto done; 10418b00f400SJan Kara } 10428b00f400SJan Kara /* 1043470decc6SDave Kleikamp * If there is already a copy-out version of this buffer, then we don't 1044470decc6SDave Kleikamp * need to make another one 1045470decc6SDave Kleikamp */ 1046470decc6SDave Kleikamp if (jh->b_frozen_data) { 1047470decc6SDave Kleikamp JBUFFER_TRACE(jh, "has frozen data"); 1048470decc6SDave Kleikamp J_ASSERT_JH(jh, jh->b_next_transaction == NULL); 1049de92c8caSJan Kara goto attach_next; 1050470decc6SDave Kleikamp } 1051470decc6SDave Kleikamp 1052470decc6SDave Kleikamp JBUFFER_TRACE(jh, "owned by older transaction"); 1053470decc6SDave Kleikamp J_ASSERT_JH(jh, jh->b_next_transaction == NULL); 10548b00f400SJan Kara J_ASSERT_JH(jh, jh->b_transaction == journal->j_committing_transaction); 1055470decc6SDave Kleikamp 10568b00f400SJan Kara /* 10578b00f400SJan Kara * There is one case we have to be very careful about. If the 10588b00f400SJan Kara * committing transaction is currently writing this buffer out to disk 10598b00f400SJan Kara * and has NOT made a copy-out, then we cannot modify the buffer 10608b00f400SJan Kara * contents at all right now. The essence of copy-out is that it is 10618b00f400SJan Kara * the extra copy, not the primary copy, which gets journaled. If the 10628b00f400SJan Kara * primary copy is already going to disk then we cannot do copy-out 10638b00f400SJan Kara * here. 10648b00f400SJan Kara */ 1065b34090e5SJan Kara if (buffer_shadow(bh)) { 1066470decc6SDave Kleikamp JBUFFER_TRACE(jh, "on shadow: sleep"); 1067470decc6SDave Kleikamp jbd_unlock_bh_state(bh); 10688b00f400SJan Kara wait_on_bit_io(&bh->b_state, BH_Shadow, TASK_UNINTERRUPTIBLE); 1069470decc6SDave Kleikamp goto repeat; 1070470decc6SDave Kleikamp } 1071470decc6SDave Kleikamp 1072b34090e5SJan Kara /* 10738b00f400SJan Kara * Only do the copy if the currently-owning transaction still needs it. 10748b00f400SJan Kara * If buffer isn't on BJ_Metadata list, the committing transaction is 10758b00f400SJan Kara * past that stage (here we use the fact that BH_Shadow is set under 10768b00f400SJan Kara * bh_state lock together with refiling to BJ_Shadow list and at this 10778b00f400SJan Kara * point we know the buffer doesn't have BH_Shadow set). 1078470decc6SDave Kleikamp * 10798b00f400SJan Kara * Subtle point, though: if this is a get_undo_access, then we will be 10808b00f400SJan Kara * relying on the frozen_data to contain the new value of the 10818b00f400SJan Kara * committed_data record after the transaction, so we HAVE to force the 10828b00f400SJan Kara * frozen_data copy in that case. 1083b34090e5SJan Kara */ 1084b34090e5SJan Kara if (jh->b_jlist == BJ_Metadata || force_copy) { 1085470decc6SDave Kleikamp JBUFFER_TRACE(jh, "generate frozen data"); 1086470decc6SDave Kleikamp if (!frozen_buffer) { 1087470decc6SDave Kleikamp JBUFFER_TRACE(jh, "allocate memory for buffer"); 1088470decc6SDave Kleikamp jbd_unlock_bh_state(bh); 1089490c1b44SMichal Hocko frozen_buffer = jbd2_alloc(jh2bh(jh)->b_size, 1090490c1b44SMichal Hocko GFP_NOFS | __GFP_NOFAIL); 1091470decc6SDave Kleikamp goto repeat; 1092470decc6SDave Kleikamp } 1093470decc6SDave Kleikamp jh->b_frozen_data = frozen_buffer; 1094470decc6SDave Kleikamp frozen_buffer = NULL; 1095ee57aba1SJan Kara jbd2_freeze_jh_data(jh); 1096470decc6SDave Kleikamp } 1097de92c8caSJan Kara attach_next: 1098de92c8caSJan Kara /* 1099de92c8caSJan Kara * Make sure all stores to jh (b_modified, b_frozen_data) are visible 1100de92c8caSJan Kara * before attaching it to the running transaction. Paired with barrier 1101de92c8caSJan Kara * in jbd2_write_access_granted() 1102de92c8caSJan Kara */ 1103de92c8caSJan Kara smp_wmb(); 1104470decc6SDave Kleikamp jh->b_next_transaction = transaction; 1105470decc6SDave Kleikamp 1106470decc6SDave Kleikamp done: 1107470decc6SDave Kleikamp jbd_unlock_bh_state(bh); 1108470decc6SDave Kleikamp 1109470decc6SDave Kleikamp /* 1110470decc6SDave Kleikamp * If we are about to journal a buffer, then any revoke pending on it is 1111470decc6SDave Kleikamp * no longer valid 1112470decc6SDave Kleikamp */ 1113f7f4bccbSMingming Cao jbd2_journal_cancel_revoke(handle, jh); 1114470decc6SDave Kleikamp 1115470decc6SDave Kleikamp out: 1116470decc6SDave Kleikamp if (unlikely(frozen_buffer)) /* It's usually NULL */ 1117af1e76d6SMingming Cao jbd2_free(frozen_buffer, bh->b_size); 1118470decc6SDave Kleikamp 1119470decc6SDave Kleikamp JBUFFER_TRACE(jh, "exit"); 1120470decc6SDave Kleikamp return error; 1121470decc6SDave Kleikamp } 1122470decc6SDave Kleikamp 1123de92c8caSJan Kara /* Fast check whether buffer is already attached to the required transaction */ 1124087ffd4eSJunxiao Bi static bool jbd2_write_access_granted(handle_t *handle, struct buffer_head *bh, 1125087ffd4eSJunxiao Bi bool undo) 1126de92c8caSJan Kara { 1127de92c8caSJan Kara struct journal_head *jh; 1128de92c8caSJan Kara bool ret = false; 1129de92c8caSJan Kara 1130de92c8caSJan Kara /* Dirty buffers require special handling... */ 1131de92c8caSJan Kara if (buffer_dirty(bh)) 1132de92c8caSJan Kara return false; 1133de92c8caSJan Kara 1134de92c8caSJan Kara /* 1135de92c8caSJan Kara * RCU protects us from dereferencing freed pages. So the checks we do 1136de92c8caSJan Kara * are guaranteed not to oops. However the jh slab object can get freed 1137de92c8caSJan Kara * & reallocated while we work with it. So we have to be careful. When 1138de92c8caSJan Kara * we see jh attached to the running transaction, we know it must stay 1139de92c8caSJan Kara * so until the transaction is committed. Thus jh won't be freed and 1140de92c8caSJan Kara * will be attached to the same bh while we run. However it can 1141de92c8caSJan Kara * happen jh gets freed, reallocated, and attached to the transaction 1142de92c8caSJan Kara * just after we get pointer to it from bh. So we have to be careful 1143de92c8caSJan Kara * and recheck jh still belongs to our bh before we return success. 1144de92c8caSJan Kara */ 1145de92c8caSJan Kara rcu_read_lock(); 1146de92c8caSJan Kara if (!buffer_jbd(bh)) 1147de92c8caSJan Kara goto out; 1148de92c8caSJan Kara /* This should be bh2jh() but that doesn't work with inline functions */ 1149de92c8caSJan Kara jh = READ_ONCE(bh->b_private); 1150de92c8caSJan Kara if (!jh) 1151de92c8caSJan Kara goto out; 1152087ffd4eSJunxiao Bi /* For undo access buffer must have data copied */ 1153087ffd4eSJunxiao Bi if (undo && !jh->b_committed_data) 1154087ffd4eSJunxiao Bi goto out; 1155de92c8caSJan Kara if (jh->b_transaction != handle->h_transaction && 1156de92c8caSJan Kara jh->b_next_transaction != handle->h_transaction) 1157de92c8caSJan Kara goto out; 1158de92c8caSJan Kara /* 1159de92c8caSJan Kara * There are two reasons for the barrier here: 1160de92c8caSJan Kara * 1) Make sure to fetch b_bh after we did previous checks so that we 1161de92c8caSJan Kara * detect when jh went through free, realloc, attach to transaction 1162de92c8caSJan Kara * while we were checking. Paired with implicit barrier in that path. 1163de92c8caSJan Kara * 2) So that access to bh done after jbd2_write_access_granted() 1164de92c8caSJan Kara * doesn't get reordered and see inconsistent state of concurrent 1165de92c8caSJan Kara * do_get_write_access(). 1166de92c8caSJan Kara */ 1167de92c8caSJan Kara smp_mb(); 1168de92c8caSJan Kara if (unlikely(jh->b_bh != bh)) 1169de92c8caSJan Kara goto out; 1170de92c8caSJan Kara ret = true; 1171de92c8caSJan Kara out: 1172de92c8caSJan Kara rcu_read_unlock(); 1173de92c8caSJan Kara return ret; 1174de92c8caSJan Kara } 1175de92c8caSJan Kara 1176470decc6SDave Kleikamp /** 1177f7f4bccbSMingming Cao * int jbd2_journal_get_write_access() - notify intent to modify a buffer for metadata (not data) update. 1178470decc6SDave Kleikamp * @handle: transaction to add buffer modifications to 1179470decc6SDave Kleikamp * @bh: bh to be used for metadata writes 1180470decc6SDave Kleikamp * 1181df1b560aSMauro Carvalho Chehab * Returns: error code or 0 on success. 1182470decc6SDave Kleikamp * 1183470decc6SDave Kleikamp * In full data journalling mode the buffer may be of type BJ_AsyncData, 1184df1b560aSMauro Carvalho Chehab * because we're ``write()ing`` a buffer which is also part of a shared mapping. 1185470decc6SDave Kleikamp */ 1186470decc6SDave Kleikamp 1187f7f4bccbSMingming Cao int jbd2_journal_get_write_access(handle_t *handle, struct buffer_head *bh) 1188470decc6SDave Kleikamp { 1189de92c8caSJan Kara struct journal_head *jh; 1190470decc6SDave Kleikamp int rc; 1191470decc6SDave Kleikamp 1192087ffd4eSJunxiao Bi if (jbd2_write_access_granted(handle, bh, false)) 1193de92c8caSJan Kara return 0; 1194de92c8caSJan Kara 1195de92c8caSJan Kara jh = jbd2_journal_add_journal_head(bh); 1196470decc6SDave Kleikamp /* We do not want to get caught playing with fields which the 1197470decc6SDave Kleikamp * log thread also manipulates. Make sure that the buffer 1198470decc6SDave Kleikamp * completes any outstanding IO before proceeding. */ 1199470decc6SDave Kleikamp rc = do_get_write_access(handle, jh, 0); 1200f7f4bccbSMingming Cao jbd2_journal_put_journal_head(jh); 1201470decc6SDave Kleikamp return rc; 1202470decc6SDave Kleikamp } 1203470decc6SDave Kleikamp 1204470decc6SDave Kleikamp 1205470decc6SDave Kleikamp /* 1206470decc6SDave Kleikamp * When the user wants to journal a newly created buffer_head 1207470decc6SDave Kleikamp * (ie. getblk() returned a new buffer and we are going to populate it 1208470decc6SDave Kleikamp * manually rather than reading off disk), then we need to keep the 1209470decc6SDave Kleikamp * buffer_head locked until it has been completely filled with new 1210470decc6SDave Kleikamp * data. In this case, we should be able to make the assertion that 1211470decc6SDave Kleikamp * the bh is not already part of an existing transaction. 1212470decc6SDave Kleikamp * 1213470decc6SDave Kleikamp * The buffer should already be locked by the caller by this point. 1214470decc6SDave Kleikamp * There is no lock ranking violation: it was a newly created, 1215470decc6SDave Kleikamp * unlocked buffer beforehand. */ 1216470decc6SDave Kleikamp 1217470decc6SDave Kleikamp /** 1218f7f4bccbSMingming Cao * int jbd2_journal_get_create_access () - notify intent to use newly created bh 1219470decc6SDave Kleikamp * @handle: transaction to new buffer to 1220470decc6SDave Kleikamp * @bh: new buffer. 1221470decc6SDave Kleikamp * 1222470decc6SDave Kleikamp * Call this if you create a new bh. 1223470decc6SDave Kleikamp */ 1224f7f4bccbSMingming Cao int jbd2_journal_get_create_access(handle_t *handle, struct buffer_head *bh) 1225470decc6SDave Kleikamp { 1226470decc6SDave Kleikamp transaction_t *transaction = handle->h_transaction; 122741a5b913STheodore Ts'o journal_t *journal; 1228f7f4bccbSMingming Cao struct journal_head *jh = jbd2_journal_add_journal_head(bh); 1229470decc6SDave Kleikamp int err; 1230470decc6SDave Kleikamp 1231470decc6SDave Kleikamp jbd_debug(5, "journal_head %p\n", jh); 1232470decc6SDave Kleikamp err = -EROFS; 1233470decc6SDave Kleikamp if (is_handle_aborted(handle)) 1234470decc6SDave Kleikamp goto out; 123541a5b913STheodore Ts'o journal = transaction->t_journal; 1236470decc6SDave Kleikamp err = 0; 1237470decc6SDave Kleikamp 1238470decc6SDave Kleikamp JBUFFER_TRACE(jh, "entry"); 1239470decc6SDave Kleikamp /* 1240470decc6SDave Kleikamp * The buffer may already belong to this transaction due to pre-zeroing 1241470decc6SDave Kleikamp * in the filesystem's new_block code. It may also be on the previous, 1242470decc6SDave Kleikamp * committing transaction's lists, but it HAS to be in Forget state in 1243470decc6SDave Kleikamp * that case: the transaction must have deleted the buffer for it to be 1244470decc6SDave Kleikamp * reused here. 1245470decc6SDave Kleikamp */ 1246470decc6SDave Kleikamp jbd_lock_bh_state(bh); 1247470decc6SDave Kleikamp J_ASSERT_JH(jh, (jh->b_transaction == transaction || 1248470decc6SDave Kleikamp jh->b_transaction == NULL || 1249470decc6SDave Kleikamp (jh->b_transaction == journal->j_committing_transaction && 1250470decc6SDave Kleikamp jh->b_jlist == BJ_Forget))); 1251470decc6SDave Kleikamp 1252470decc6SDave Kleikamp J_ASSERT_JH(jh, jh->b_next_transaction == NULL); 1253470decc6SDave Kleikamp J_ASSERT_JH(jh, buffer_locked(jh2bh(jh))); 1254470decc6SDave Kleikamp 1255470decc6SDave Kleikamp if (jh->b_transaction == NULL) { 1256f91d1d04SJan Kara /* 1257f91d1d04SJan Kara * Previous jbd2_journal_forget() could have left the buffer 1258f91d1d04SJan Kara * with jbddirty bit set because it was being committed. When 1259f91d1d04SJan Kara * the commit finished, we've filed the buffer for 1260f91d1d04SJan Kara * checkpointing and marked it dirty. Now we are reallocating 1261f91d1d04SJan Kara * the buffer so the transaction freeing it must have 1262f91d1d04SJan Kara * committed and so it's safe to clear the dirty bit. 1263f91d1d04SJan Kara */ 1264f91d1d04SJan Kara clear_buffer_dirty(jh2bh(jh)); 12659fc7c63aSJosef Bacik /* first access by this transaction */ 12669fc7c63aSJosef Bacik jh->b_modified = 0; 12679fc7c63aSJosef Bacik 1268470decc6SDave Kleikamp JBUFFER_TRACE(jh, "file as BJ_Reserved"); 12696e4862a5STheodore Ts'o spin_lock(&journal->j_list_lock); 1270f7f4bccbSMingming Cao __jbd2_journal_file_buffer(jh, transaction, BJ_Reserved); 1271559cce69STaesoo Kim spin_unlock(&journal->j_list_lock); 1272470decc6SDave Kleikamp } else if (jh->b_transaction == journal->j_committing_transaction) { 12739fc7c63aSJosef Bacik /* first access by this transaction */ 12749fc7c63aSJosef Bacik jh->b_modified = 0; 12759fc7c63aSJosef Bacik 1276470decc6SDave Kleikamp JBUFFER_TRACE(jh, "set next transaction"); 12776e4862a5STheodore Ts'o spin_lock(&journal->j_list_lock); 1278470decc6SDave Kleikamp jh->b_next_transaction = transaction; 1279470decc6SDave Kleikamp spin_unlock(&journal->j_list_lock); 1280559cce69STaesoo Kim } 1281470decc6SDave Kleikamp jbd_unlock_bh_state(bh); 1282470decc6SDave Kleikamp 1283470decc6SDave Kleikamp /* 1284470decc6SDave Kleikamp * akpm: I added this. ext3_alloc_branch can pick up new indirect 1285470decc6SDave Kleikamp * blocks which contain freed but then revoked metadata. We need 1286470decc6SDave Kleikamp * to cancel the revoke in case we end up freeing it yet again 1287470decc6SDave Kleikamp * and the reallocating as data - this would cause a second revoke, 1288470decc6SDave Kleikamp * which hits an assertion error. 1289470decc6SDave Kleikamp */ 1290470decc6SDave Kleikamp JBUFFER_TRACE(jh, "cancelling revoke"); 1291f7f4bccbSMingming Cao jbd2_journal_cancel_revoke(handle, jh); 1292470decc6SDave Kleikamp out: 12933991b400SDing Dinghua jbd2_journal_put_journal_head(jh); 1294470decc6SDave Kleikamp return err; 1295470decc6SDave Kleikamp } 1296470decc6SDave Kleikamp 1297470decc6SDave Kleikamp /** 1298f7f4bccbSMingming Cao * int jbd2_journal_get_undo_access() - Notify intent to modify metadata with 1299470decc6SDave Kleikamp * non-rewindable consequences 1300470decc6SDave Kleikamp * @handle: transaction 1301470decc6SDave Kleikamp * @bh: buffer to undo 1302470decc6SDave Kleikamp * 1303470decc6SDave Kleikamp * Sometimes there is a need to distinguish between metadata which has 1304470decc6SDave Kleikamp * been committed to disk and that which has not. The ext3fs code uses 1305470decc6SDave Kleikamp * this for freeing and allocating space, we have to make sure that we 1306470decc6SDave Kleikamp * do not reuse freed space until the deallocation has been committed, 1307470decc6SDave Kleikamp * since if we overwrote that space we would make the delete 1308470decc6SDave Kleikamp * un-rewindable in case of a crash. 1309470decc6SDave Kleikamp * 1310f7f4bccbSMingming Cao * To deal with that, jbd2_journal_get_undo_access requests write access to a 1311470decc6SDave Kleikamp * buffer for parts of non-rewindable operations such as delete 1312470decc6SDave Kleikamp * operations on the bitmaps. The journaling code must keep a copy of 1313470decc6SDave Kleikamp * the buffer's contents prior to the undo_access call until such time 1314470decc6SDave Kleikamp * as we know that the buffer has definitely been committed to disk. 1315470decc6SDave Kleikamp * 1316470decc6SDave Kleikamp * We never need to know which transaction the committed data is part 1317470decc6SDave Kleikamp * of, buffers touched here are guaranteed to be dirtied later and so 1318470decc6SDave Kleikamp * will be committed to a new transaction in due course, at which point 1319470decc6SDave Kleikamp * we can discard the old committed data pointer. 1320470decc6SDave Kleikamp * 1321470decc6SDave Kleikamp * Returns error number or 0 on success. 1322470decc6SDave Kleikamp */ 1323f7f4bccbSMingming Cao int jbd2_journal_get_undo_access(handle_t *handle, struct buffer_head *bh) 1324470decc6SDave Kleikamp { 1325470decc6SDave Kleikamp int err; 1326de92c8caSJan Kara struct journal_head *jh; 1327470decc6SDave Kleikamp char *committed_data = NULL; 1328470decc6SDave Kleikamp 1329087ffd4eSJunxiao Bi if (jbd2_write_access_granted(handle, bh, true)) 1330de92c8caSJan Kara return 0; 1331470decc6SDave Kleikamp 1332de92c8caSJan Kara jh = jbd2_journal_add_journal_head(bh); 133301215d3eSzhangyi (F) JBUFFER_TRACE(jh, "entry"); 133401215d3eSzhangyi (F) 1335470decc6SDave Kleikamp /* 1336470decc6SDave Kleikamp * Do this first --- it can drop the journal lock, so we want to 1337470decc6SDave Kleikamp * make sure that obtaining the committed_data is done 1338470decc6SDave Kleikamp * atomically wrt. completion of any outstanding commits. 1339470decc6SDave Kleikamp */ 1340470decc6SDave Kleikamp err = do_get_write_access(handle, jh, 1); 1341470decc6SDave Kleikamp if (err) 1342470decc6SDave Kleikamp goto out; 1343470decc6SDave Kleikamp 1344470decc6SDave Kleikamp repeat: 1345490c1b44SMichal Hocko if (!jh->b_committed_data) 1346490c1b44SMichal Hocko committed_data = jbd2_alloc(jh2bh(jh)->b_size, 1347490c1b44SMichal Hocko GFP_NOFS|__GFP_NOFAIL); 1348470decc6SDave Kleikamp 1349470decc6SDave Kleikamp jbd_lock_bh_state(bh); 1350470decc6SDave Kleikamp if (!jh->b_committed_data) { 1351470decc6SDave Kleikamp /* Copy out the current buffer contents into the 1352470decc6SDave Kleikamp * preserved, committed copy. */ 1353470decc6SDave Kleikamp JBUFFER_TRACE(jh, "generate b_committed data"); 1354470decc6SDave Kleikamp if (!committed_data) { 1355470decc6SDave Kleikamp jbd_unlock_bh_state(bh); 1356470decc6SDave Kleikamp goto repeat; 1357470decc6SDave Kleikamp } 1358470decc6SDave Kleikamp 1359470decc6SDave Kleikamp jh->b_committed_data = committed_data; 1360470decc6SDave Kleikamp committed_data = NULL; 1361470decc6SDave Kleikamp memcpy(jh->b_committed_data, bh->b_data, bh->b_size); 1362470decc6SDave Kleikamp } 1363470decc6SDave Kleikamp jbd_unlock_bh_state(bh); 1364470decc6SDave Kleikamp out: 1365f7f4bccbSMingming Cao jbd2_journal_put_journal_head(jh); 1366470decc6SDave Kleikamp if (unlikely(committed_data)) 1367af1e76d6SMingming Cao jbd2_free(committed_data, bh->b_size); 1368470decc6SDave Kleikamp return err; 1369470decc6SDave Kleikamp } 1370470decc6SDave Kleikamp 1371470decc6SDave Kleikamp /** 1372e06c8227SJoel Becker * void jbd2_journal_set_triggers() - Add triggers for commit writeout 1373e06c8227SJoel Becker * @bh: buffer to trigger on 1374e06c8227SJoel Becker * @type: struct jbd2_buffer_trigger_type containing the trigger(s). 1375e06c8227SJoel Becker * 1376e06c8227SJoel Becker * Set any triggers on this journal_head. This is always safe, because 1377e06c8227SJoel Becker * triggers for a committing buffer will be saved off, and triggers for 1378e06c8227SJoel Becker * a running transaction will match the buffer in that transaction. 1379e06c8227SJoel Becker * 1380e06c8227SJoel Becker * Call with NULL to clear the triggers. 1381e06c8227SJoel Becker */ 1382e06c8227SJoel Becker void jbd2_journal_set_triggers(struct buffer_head *bh, 1383e06c8227SJoel Becker struct jbd2_buffer_trigger_type *type) 1384e06c8227SJoel Becker { 1385ad56edadSJan Kara struct journal_head *jh = jbd2_journal_grab_journal_head(bh); 1386e06c8227SJoel Becker 1387ad56edadSJan Kara if (WARN_ON(!jh)) 1388ad56edadSJan Kara return; 1389e06c8227SJoel Becker jh->b_triggers = type; 1390ad56edadSJan Kara jbd2_journal_put_journal_head(jh); 1391e06c8227SJoel Becker } 1392e06c8227SJoel Becker 139313ceef09SJan Kara void jbd2_buffer_frozen_trigger(struct journal_head *jh, void *mapped_data, 1394e06c8227SJoel Becker struct jbd2_buffer_trigger_type *triggers) 1395e06c8227SJoel Becker { 1396e06c8227SJoel Becker struct buffer_head *bh = jh2bh(jh); 1397e06c8227SJoel Becker 139813ceef09SJan Kara if (!triggers || !triggers->t_frozen) 1399e06c8227SJoel Becker return; 1400e06c8227SJoel Becker 140113ceef09SJan Kara triggers->t_frozen(triggers, bh, mapped_data, bh->b_size); 1402e06c8227SJoel Becker } 1403e06c8227SJoel Becker 1404e06c8227SJoel Becker void jbd2_buffer_abort_trigger(struct journal_head *jh, 1405e06c8227SJoel Becker struct jbd2_buffer_trigger_type *triggers) 1406e06c8227SJoel Becker { 1407e06c8227SJoel Becker if (!triggers || !triggers->t_abort) 1408e06c8227SJoel Becker return; 1409e06c8227SJoel Becker 1410e06c8227SJoel Becker triggers->t_abort(triggers, jh2bh(jh)); 1411e06c8227SJoel Becker } 1412e06c8227SJoel Becker 1413e06c8227SJoel Becker /** 1414f7f4bccbSMingming Cao * int jbd2_journal_dirty_metadata() - mark a buffer as containing dirty metadata 1415470decc6SDave Kleikamp * @handle: transaction to add buffer to. 1416470decc6SDave Kleikamp * @bh: buffer to mark 1417470decc6SDave Kleikamp * 1418470decc6SDave Kleikamp * mark dirty metadata which needs to be journaled as part of the current 1419470decc6SDave Kleikamp * transaction. 1420470decc6SDave Kleikamp * 14219ea7a0dfSTheodore Ts'o * The buffer must have previously had jbd2_journal_get_write_access() 14229ea7a0dfSTheodore Ts'o * called so that it has a valid journal_head attached to the buffer 14239ea7a0dfSTheodore Ts'o * head. 14249ea7a0dfSTheodore Ts'o * 1425470decc6SDave Kleikamp * The buffer is placed on the transaction's metadata list and is marked 1426470decc6SDave Kleikamp * as belonging to the transaction. 1427470decc6SDave Kleikamp * 1428470decc6SDave Kleikamp * Returns error number or 0 on success. 1429470decc6SDave Kleikamp * 1430470decc6SDave Kleikamp * Special care needs to be taken if the buffer already belongs to the 1431470decc6SDave Kleikamp * current committing transaction (in which case we should have frozen 1432470decc6SDave Kleikamp * data present for that commit). In that case, we don't relink the 1433470decc6SDave Kleikamp * buffer: that only gets done when the old transaction finally 1434470decc6SDave Kleikamp * completes its commit. 1435470decc6SDave Kleikamp */ 1436f7f4bccbSMingming Cao int jbd2_journal_dirty_metadata(handle_t *handle, struct buffer_head *bh) 1437470decc6SDave Kleikamp { 1438470decc6SDave Kleikamp transaction_t *transaction = handle->h_transaction; 143941a5b913STheodore Ts'o journal_t *journal; 1440ad56edadSJan Kara struct journal_head *jh; 14419ea7a0dfSTheodore Ts'o int ret = 0; 1442470decc6SDave Kleikamp 1443470decc6SDave Kleikamp if (is_handle_aborted(handle)) 144441a5b913STheodore Ts'o return -EROFS; 144501215d3eSzhangyi (F) if (!buffer_jbd(bh)) 144601215d3eSzhangyi (F) return -EUCLEAN; 144701215d3eSzhangyi (F) 14486e06ae88SJan Kara /* 14496e06ae88SJan Kara * We don't grab jh reference here since the buffer must be part 14506e06ae88SJan Kara * of the running transaction. 14516e06ae88SJan Kara */ 14526e06ae88SJan Kara jh = bh2jh(bh); 145301215d3eSzhangyi (F) jbd_debug(5, "journal_head %p\n", jh); 145401215d3eSzhangyi (F) JBUFFER_TRACE(jh, "entry"); 145501215d3eSzhangyi (F) 14566e06ae88SJan Kara /* 14576e06ae88SJan Kara * This and the following assertions are unreliable since we may see jh 14586e06ae88SJan Kara * in inconsistent state unless we grab bh_state lock. But this is 14596e06ae88SJan Kara * crucial to catch bugs so let's do a reliable check until the 14606e06ae88SJan Kara * lockless handling is fully proven. 14616e06ae88SJan Kara */ 14626e06ae88SJan Kara if (jh->b_transaction != transaction && 14636e06ae88SJan Kara jh->b_next_transaction != transaction) { 14646e06ae88SJan Kara jbd_lock_bh_state(bh); 14656e06ae88SJan Kara J_ASSERT_JH(jh, jh->b_transaction == transaction || 14666e06ae88SJan Kara jh->b_next_transaction == transaction); 14676e06ae88SJan Kara jbd_unlock_bh_state(bh); 14686e06ae88SJan Kara } 14696e06ae88SJan Kara if (jh->b_modified == 1) { 14706e06ae88SJan Kara /* If it's in our transaction it must be in BJ_Metadata list. */ 14716e06ae88SJan Kara if (jh->b_transaction == transaction && 14726e06ae88SJan Kara jh->b_jlist != BJ_Metadata) { 14736e06ae88SJan Kara jbd_lock_bh_state(bh); 1474e09463f2STheodore Ts'o if (jh->b_transaction == transaction && 1475e09463f2STheodore Ts'o jh->b_jlist != BJ_Metadata) 1476e09463f2STheodore Ts'o pr_err("JBD2: assertion failure: h_type=%u " 1477e09463f2STheodore Ts'o "h_line_no=%u block_no=%llu jlist=%u\n", 1478e09463f2STheodore Ts'o handle->h_type, handle->h_line_no, 1479e09463f2STheodore Ts'o (unsigned long long) bh->b_blocknr, 1480e09463f2STheodore Ts'o jh->b_jlist); 14816e06ae88SJan Kara J_ASSERT_JH(jh, jh->b_transaction != transaction || 14826e06ae88SJan Kara jh->b_jlist == BJ_Metadata); 14836e06ae88SJan Kara jbd_unlock_bh_state(bh); 14846e06ae88SJan Kara } 14856e06ae88SJan Kara goto out; 14866e06ae88SJan Kara } 14876e06ae88SJan Kara 14886e06ae88SJan Kara journal = transaction->t_journal; 1489470decc6SDave Kleikamp jbd_lock_bh_state(bh); 1490470decc6SDave Kleikamp 1491470decc6SDave Kleikamp if (jh->b_modified == 0) { 1492470decc6SDave Kleikamp /* 1493470decc6SDave Kleikamp * This buffer's got modified and becoming part 1494470decc6SDave Kleikamp * of the transaction. This needs to be done 1495470decc6SDave Kleikamp * once a transaction -bzzz 1496470decc6SDave Kleikamp */ 1497d090707eSJan Kara if (WARN_ON_ONCE(jbd2_handle_buffer_credits(handle) <= 0)) { 1498f6c07cadSTheodore Ts'o ret = -ENOSPC; 1499f6c07cadSTheodore Ts'o goto out_unlock_bh; 1500f6c07cadSTheodore Ts'o } 1501e09463f2STheodore Ts'o jh->b_modified = 1; 1502933f1c1eSJan Kara handle->h_total_credits--; 1503470decc6SDave Kleikamp } 1504470decc6SDave Kleikamp 1505470decc6SDave Kleikamp /* 1506470decc6SDave Kleikamp * fastpath, to avoid expensive locking. If this buffer is already 1507470decc6SDave Kleikamp * on the running transaction's metadata list there is nothing to do. 1508470decc6SDave Kleikamp * Nobody can take it off again because there is a handle open. 1509470decc6SDave Kleikamp * I _think_ we're OK here with SMP barriers - a mistaken decision will 1510470decc6SDave Kleikamp * result in this test being false, so we go in and take the locks. 1511470decc6SDave Kleikamp */ 1512470decc6SDave Kleikamp if (jh->b_transaction == transaction && jh->b_jlist == BJ_Metadata) { 1513470decc6SDave Kleikamp JBUFFER_TRACE(jh, "fastpath"); 15149ea7a0dfSTheodore Ts'o if (unlikely(jh->b_transaction != 15159ea7a0dfSTheodore Ts'o journal->j_running_transaction)) { 1516a67c848aSDmitry Monakhov printk(KERN_ERR "JBD2: %s: " 15179ea7a0dfSTheodore Ts'o "jh->b_transaction (%llu, %p, %u) != " 151866a4cb18STheodore Ts'o "journal->j_running_transaction (%p, %u)\n", 15199ea7a0dfSTheodore Ts'o journal->j_devname, 15209ea7a0dfSTheodore Ts'o (unsigned long long) bh->b_blocknr, 15219ea7a0dfSTheodore Ts'o jh->b_transaction, 15229ea7a0dfSTheodore Ts'o jh->b_transaction ? jh->b_transaction->t_tid : 0, 15239ea7a0dfSTheodore Ts'o journal->j_running_transaction, 15249ea7a0dfSTheodore Ts'o journal->j_running_transaction ? 15259ea7a0dfSTheodore Ts'o journal->j_running_transaction->t_tid : 0); 15269ea7a0dfSTheodore Ts'o ret = -EINVAL; 15279ea7a0dfSTheodore Ts'o } 1528470decc6SDave Kleikamp goto out_unlock_bh; 1529470decc6SDave Kleikamp } 1530470decc6SDave Kleikamp 1531470decc6SDave Kleikamp set_buffer_jbddirty(bh); 1532470decc6SDave Kleikamp 1533470decc6SDave Kleikamp /* 1534470decc6SDave Kleikamp * Metadata already on the current transaction list doesn't 1535470decc6SDave Kleikamp * need to be filed. Metadata on another transaction's list must 1536470decc6SDave Kleikamp * be committing, and will be refiled once the commit completes: 1537470decc6SDave Kleikamp * leave it alone for now. 1538470decc6SDave Kleikamp */ 1539470decc6SDave Kleikamp if (jh->b_transaction != transaction) { 1540470decc6SDave Kleikamp JBUFFER_TRACE(jh, "already on other transaction"); 154166a4cb18STheodore Ts'o if (unlikely(((jh->b_transaction != 154266a4cb18STheodore Ts'o journal->j_committing_transaction)) || 154366a4cb18STheodore Ts'o (jh->b_next_transaction != transaction))) { 154466a4cb18STheodore Ts'o printk(KERN_ERR "jbd2_journal_dirty_metadata: %s: " 154566a4cb18STheodore Ts'o "bad jh for block %llu: " 154666a4cb18STheodore Ts'o "transaction (%p, %u), " 154766a4cb18STheodore Ts'o "jh->b_transaction (%p, %u), " 154866a4cb18STheodore Ts'o "jh->b_next_transaction (%p, %u), jlist %u\n", 15499ea7a0dfSTheodore Ts'o journal->j_devname, 15509ea7a0dfSTheodore Ts'o (unsigned long long) bh->b_blocknr, 155166a4cb18STheodore Ts'o transaction, transaction->t_tid, 15529ea7a0dfSTheodore Ts'o jh->b_transaction, 155366a4cb18STheodore Ts'o jh->b_transaction ? 155466a4cb18STheodore Ts'o jh->b_transaction->t_tid : 0, 15559ea7a0dfSTheodore Ts'o jh->b_next_transaction, 15569ea7a0dfSTheodore Ts'o jh->b_next_transaction ? 15579ea7a0dfSTheodore Ts'o jh->b_next_transaction->t_tid : 0, 155866a4cb18STheodore Ts'o jh->b_jlist); 155966a4cb18STheodore Ts'o WARN_ON(1); 15609ea7a0dfSTheodore Ts'o ret = -EINVAL; 15619ea7a0dfSTheodore Ts'o } 1562470decc6SDave Kleikamp /* And this case is illegal: we can't reuse another 1563470decc6SDave Kleikamp * transaction's data buffer, ever. */ 1564470decc6SDave Kleikamp goto out_unlock_bh; 1565470decc6SDave Kleikamp } 1566470decc6SDave Kleikamp 1567470decc6SDave Kleikamp /* That test should have eliminated the following case: */ 15684019191bSMingming Cao J_ASSERT_JH(jh, jh->b_frozen_data == NULL); 1569470decc6SDave Kleikamp 1570470decc6SDave Kleikamp JBUFFER_TRACE(jh, "file as BJ_Metadata"); 1571470decc6SDave Kleikamp spin_lock(&journal->j_list_lock); 157241a5b913STheodore Ts'o __jbd2_journal_file_buffer(jh, transaction, BJ_Metadata); 1573470decc6SDave Kleikamp spin_unlock(&journal->j_list_lock); 1574470decc6SDave Kleikamp out_unlock_bh: 1575470decc6SDave Kleikamp jbd_unlock_bh_state(bh); 1576470decc6SDave Kleikamp out: 1577470decc6SDave Kleikamp JBUFFER_TRACE(jh, "exit"); 15789ea7a0dfSTheodore Ts'o return ret; 1579470decc6SDave Kleikamp } 1580470decc6SDave Kleikamp 1581470decc6SDave Kleikamp /** 1582f7f4bccbSMingming Cao * void jbd2_journal_forget() - bforget() for potentially-journaled buffers. 1583470decc6SDave Kleikamp * @handle: transaction handle 1584470decc6SDave Kleikamp * @bh: bh to 'forget' 1585470decc6SDave Kleikamp * 1586470decc6SDave Kleikamp * We can only do the bforget if there are no commits pending against the 1587470decc6SDave Kleikamp * buffer. If the buffer is dirty in the current running transaction we 1588470decc6SDave Kleikamp * can safely unlink it. 1589470decc6SDave Kleikamp * 1590470decc6SDave Kleikamp * bh may not be a journalled buffer at all - it may be a non-JBD 1591470decc6SDave Kleikamp * buffer which came off the hashtable. Check for this. 1592470decc6SDave Kleikamp * 1593470decc6SDave Kleikamp * Decrements bh->b_count by one. 1594470decc6SDave Kleikamp * 1595470decc6SDave Kleikamp * Allow this call even if the handle has aborted --- it may be part of 1596470decc6SDave Kleikamp * the caller's cleanup after an abort. 1597470decc6SDave Kleikamp */ 1598f7f4bccbSMingming Cao int jbd2_journal_forget (handle_t *handle, struct buffer_head *bh) 1599470decc6SDave Kleikamp { 1600470decc6SDave Kleikamp transaction_t *transaction = handle->h_transaction; 160141a5b913STheodore Ts'o journal_t *journal; 1602470decc6SDave Kleikamp struct journal_head *jh; 1603470decc6SDave Kleikamp int drop_reserve = 0; 1604470decc6SDave Kleikamp int err = 0; 16051dfc3220SJosef Bacik int was_modified = 0; 1606470decc6SDave Kleikamp 160741a5b913STheodore Ts'o if (is_handle_aborted(handle)) 160841a5b913STheodore Ts'o return -EROFS; 160941a5b913STheodore Ts'o journal = transaction->t_journal; 161041a5b913STheodore Ts'o 1611470decc6SDave Kleikamp BUFFER_TRACE(bh, "entry"); 1612470decc6SDave Kleikamp 1613470decc6SDave Kleikamp jbd_lock_bh_state(bh); 1614470decc6SDave Kleikamp 1615470decc6SDave Kleikamp if (!buffer_jbd(bh)) 1616470decc6SDave Kleikamp goto not_jbd; 1617470decc6SDave Kleikamp jh = bh2jh(bh); 1618470decc6SDave Kleikamp 1619470decc6SDave Kleikamp /* Critical error: attempting to delete a bitmap buffer, maybe? 1620470decc6SDave Kleikamp * Don't do any jbd operations, and return an error. */ 1621470decc6SDave Kleikamp if (!J_EXPECT_JH(jh, !jh->b_committed_data, 1622470decc6SDave Kleikamp "inconsistent data on disk")) { 1623470decc6SDave Kleikamp err = -EIO; 1624470decc6SDave Kleikamp goto not_jbd; 1625470decc6SDave Kleikamp } 1626470decc6SDave Kleikamp 162748fc7f7eSAdam Buchbinder /* keep track of whether or not this transaction modified us */ 16281dfc3220SJosef Bacik was_modified = jh->b_modified; 16291dfc3220SJosef Bacik 1630470decc6SDave Kleikamp /* 1631470decc6SDave Kleikamp * The buffer's going from the transaction, we must drop 1632470decc6SDave Kleikamp * all references -bzzz 1633470decc6SDave Kleikamp */ 1634470decc6SDave Kleikamp jh->b_modified = 0; 1635470decc6SDave Kleikamp 163641a5b913STheodore Ts'o if (jh->b_transaction == transaction) { 1637470decc6SDave Kleikamp J_ASSERT_JH(jh, !jh->b_frozen_data); 1638470decc6SDave Kleikamp 1639470decc6SDave Kleikamp /* If we are forgetting a buffer which is already part 1640470decc6SDave Kleikamp * of this transaction, then we can just drop it from 1641470decc6SDave Kleikamp * the transaction immediately. */ 1642470decc6SDave Kleikamp clear_buffer_dirty(bh); 1643470decc6SDave Kleikamp clear_buffer_jbddirty(bh); 1644470decc6SDave Kleikamp 1645470decc6SDave Kleikamp JBUFFER_TRACE(jh, "belongs to current transaction: unfile"); 1646470decc6SDave Kleikamp 16471dfc3220SJosef Bacik /* 16481dfc3220SJosef Bacik * we only want to drop a reference if this transaction 16491dfc3220SJosef Bacik * modified the buffer 16501dfc3220SJosef Bacik */ 16511dfc3220SJosef Bacik if (was_modified) 1652470decc6SDave Kleikamp drop_reserve = 1; 1653470decc6SDave Kleikamp 1654470decc6SDave Kleikamp /* 1655470decc6SDave Kleikamp * We are no longer going to journal this buffer. 1656470decc6SDave Kleikamp * However, the commit of this transaction is still 1657470decc6SDave Kleikamp * important to the buffer: the delete that we are now 1658470decc6SDave Kleikamp * processing might obsolete an old log entry, so by 1659470decc6SDave Kleikamp * committing, we can satisfy the buffer's checkpoint. 1660470decc6SDave Kleikamp * 1661470decc6SDave Kleikamp * So, if we have a checkpoint on the buffer, we should 1662470decc6SDave Kleikamp * now refile the buffer on our BJ_Forget list so that 1663470decc6SDave Kleikamp * we know to remove the checkpoint after we commit. 1664470decc6SDave Kleikamp */ 1665470decc6SDave Kleikamp 16660bfea811STheodore Ts'o spin_lock(&journal->j_list_lock); 1667470decc6SDave Kleikamp if (jh->b_cp_transaction) { 1668f7f4bccbSMingming Cao __jbd2_journal_temp_unlink_buffer(jh); 1669f7f4bccbSMingming Cao __jbd2_journal_file_buffer(jh, transaction, BJ_Forget); 1670470decc6SDave Kleikamp } else { 1671f7f4bccbSMingming Cao __jbd2_journal_unfile_buffer(jh); 1672470decc6SDave Kleikamp if (!buffer_jbd(bh)) { 1673470decc6SDave Kleikamp spin_unlock(&journal->j_list_lock); 167459759926Szhangyi (F) goto not_jbd; 1675470decc6SDave Kleikamp } 1676470decc6SDave Kleikamp } 16770bfea811STheodore Ts'o spin_unlock(&journal->j_list_lock); 1678470decc6SDave Kleikamp } else if (jh->b_transaction) { 1679470decc6SDave Kleikamp J_ASSERT_JH(jh, (jh->b_transaction == 1680470decc6SDave Kleikamp journal->j_committing_transaction)); 1681470decc6SDave Kleikamp /* However, if the buffer is still owned by a prior 1682470decc6SDave Kleikamp * (committing) transaction, we can't drop it yet... */ 1683470decc6SDave Kleikamp JBUFFER_TRACE(jh, "belongs to older transaction"); 1684904cdbd4Szhangyi (F) /* ... but we CAN drop it from the new transaction through 1685904cdbd4Szhangyi (F) * marking the buffer as freed and set j_next_transaction to 1686904cdbd4Szhangyi (F) * the new transaction, so that not only the commit code 1687904cdbd4Szhangyi (F) * knows it should clear dirty bits when it is done with the 1688904cdbd4Szhangyi (F) * buffer, but also the buffer can be checkpointed only 1689904cdbd4Szhangyi (F) * after the new transaction commits. */ 1690470decc6SDave Kleikamp 1691904cdbd4Szhangyi (F) set_buffer_freed(bh); 1692904cdbd4Szhangyi (F) 1693904cdbd4Szhangyi (F) if (!jh->b_next_transaction) { 16940bfea811STheodore Ts'o spin_lock(&journal->j_list_lock); 1695904cdbd4Szhangyi (F) jh->b_next_transaction = transaction; 16960bfea811STheodore Ts'o spin_unlock(&journal->j_list_lock); 1697904cdbd4Szhangyi (F) } else { 1698904cdbd4Szhangyi (F) J_ASSERT(jh->b_next_transaction == transaction); 16991dfc3220SJosef Bacik 17001dfc3220SJosef Bacik /* 17011dfc3220SJosef Bacik * only drop a reference if this transaction modified 17021dfc3220SJosef Bacik * the buffer 17031dfc3220SJosef Bacik */ 17041dfc3220SJosef Bacik if (was_modified) 1705470decc6SDave Kleikamp drop_reserve = 1; 1706470decc6SDave Kleikamp } 170759759926Szhangyi (F) } else { 170859759926Szhangyi (F) /* 170959759926Szhangyi (F) * Finally, if the buffer is not belongs to any 171059759926Szhangyi (F) * transaction, we can just drop it now if it has no 171159759926Szhangyi (F) * checkpoint. 171259759926Szhangyi (F) */ 171359759926Szhangyi (F) spin_lock(&journal->j_list_lock); 171459759926Szhangyi (F) if (!jh->b_cp_transaction) { 171559759926Szhangyi (F) JBUFFER_TRACE(jh, "belongs to none transaction"); 171659759926Szhangyi (F) spin_unlock(&journal->j_list_lock); 171759759926Szhangyi (F) goto not_jbd; 1718470decc6SDave Kleikamp } 1719470decc6SDave Kleikamp 172059759926Szhangyi (F) /* 172159759926Szhangyi (F) * Otherwise, if the buffer has been written to disk, 172259759926Szhangyi (F) * it is safe to remove the checkpoint and drop it. 172359759926Szhangyi (F) */ 172459759926Szhangyi (F) if (!buffer_dirty(bh)) { 172559759926Szhangyi (F) __jbd2_journal_remove_checkpoint(jh); 172659759926Szhangyi (F) spin_unlock(&journal->j_list_lock); 172759759926Szhangyi (F) goto not_jbd; 172859759926Szhangyi (F) } 172959759926Szhangyi (F) 173059759926Szhangyi (F) /* 173159759926Szhangyi (F) * The buffer is still not written to disk, we should 173259759926Szhangyi (F) * attach this buffer to current transaction so that the 173359759926Szhangyi (F) * buffer can be checkpointed only after the current 173459759926Szhangyi (F) * transaction commits. 173559759926Szhangyi (F) */ 173659759926Szhangyi (F) clear_buffer_dirty(bh); 173759759926Szhangyi (F) __jbd2_journal_file_buffer(jh, transaction, BJ_Forget); 173859759926Szhangyi (F) spin_unlock(&journal->j_list_lock); 173959759926Szhangyi (F) } 174059759926Szhangyi (F) 1741470decc6SDave Kleikamp jbd_unlock_bh_state(bh); 1742470decc6SDave Kleikamp __brelse(bh); 1743470decc6SDave Kleikamp drop: 1744470decc6SDave Kleikamp if (drop_reserve) { 1745470decc6SDave Kleikamp /* no need to reserve log space for this block -bzzz */ 1746933f1c1eSJan Kara handle->h_total_credits++; 1747470decc6SDave Kleikamp } 1748470decc6SDave Kleikamp return err; 174959759926Szhangyi (F) 175059759926Szhangyi (F) not_jbd: 175159759926Szhangyi (F) jbd_unlock_bh_state(bh); 175259759926Szhangyi (F) __bforget(bh); 175359759926Szhangyi (F) goto drop; 1754470decc6SDave Kleikamp } 1755470decc6SDave Kleikamp 1756470decc6SDave Kleikamp /** 1757f7f4bccbSMingming Cao * int jbd2_journal_stop() - complete a transaction 1758bd7ced98SMasanari Iida * @handle: transaction to complete. 1759470decc6SDave Kleikamp * 1760470decc6SDave Kleikamp * All done for a particular handle. 1761470decc6SDave Kleikamp * 1762470decc6SDave Kleikamp * There is not much action needed here. We just return any remaining 1763470decc6SDave Kleikamp * buffer credits to the transaction and remove the handle. The only 1764470decc6SDave Kleikamp * complication is that we need to start a commit operation if the 1765470decc6SDave Kleikamp * filesystem is marked for synchronous update. 1766470decc6SDave Kleikamp * 1767f7f4bccbSMingming Cao * jbd2_journal_stop itself will not usually return an error, but it may 1768470decc6SDave Kleikamp * do so in unusual circumstances. In particular, expect it to 1769f7f4bccbSMingming Cao * return -EIO if a jbd2_journal_abort has been executed since the 1770470decc6SDave Kleikamp * transaction began. 1771470decc6SDave Kleikamp */ 1772f7f4bccbSMingming Cao int jbd2_journal_stop(handle_t *handle) 1773470decc6SDave Kleikamp { 1774470decc6SDave Kleikamp transaction_t *transaction = handle->h_transaction; 177541a5b913STheodore Ts'o journal_t *journal; 177641a5b913STheodore Ts'o int err = 0, wait_for_commit = 0; 1777a51dca9cSTheodore Ts'o tid_t tid; 1778470decc6SDave Kleikamp pid_t pid; 1779470decc6SDave Kleikamp 17809d506594SLukas Czerner if (--handle->h_ref > 0) { 17819d506594SLukas Czerner jbd_debug(4, "h_ref %d -> %d\n", handle->h_ref + 1, 17829d506594SLukas Czerner handle->h_ref); 1783dfaf5ffdSJan Kara if (is_handle_aborted(handle)) 1784dfaf5ffdSJan Kara return -EIO; 1785dfaf5ffdSJan Kara return 0; 1786dfaf5ffdSJan Kara } 1787dfaf5ffdSJan Kara if (!transaction) { 1788dfaf5ffdSJan Kara /* 1789dfaf5ffdSJan Kara * Handle is already detached from the transaction so there is 1790dfaf5ffdSJan Kara * nothing to do other than free the handle. 1791dfaf5ffdSJan Kara */ 1792ec8b6f60SJan Kara memalloc_nofs_restore(handle->saved_alloc_context); 179341a5b913STheodore Ts'o goto free_and_exit; 17949d506594SLukas Czerner } 179541a5b913STheodore Ts'o journal = transaction->t_journal; 1796dfaf5ffdSJan Kara tid = transaction->t_tid; 179741a5b913STheodore Ts'o 1798470decc6SDave Kleikamp if (is_handle_aborted(handle)) 1799470decc6SDave Kleikamp err = -EIO; 1800470decc6SDave Kleikamp 1801470decc6SDave Kleikamp jbd_debug(4, "Handle %p going down\n", handle); 1802343d9c28STheodore Ts'o trace_jbd2_handle_stats(journal->j_fs_dev->bd_dev, 1803dfaf5ffdSJan Kara tid, handle->h_type, handle->h_line_no, 1804343d9c28STheodore Ts'o jiffies - handle->h_start_jiffies, 1805343d9c28STheodore Ts'o handle->h_sync, handle->h_requested_credits, 1806343d9c28STheodore Ts'o (handle->h_requested_credits - 1807933f1c1eSJan Kara handle->h_total_credits)); 1808470decc6SDave Kleikamp 1809470decc6SDave Kleikamp /* 1810470decc6SDave Kleikamp * Implement synchronous transaction batching. If the handle 1811470decc6SDave Kleikamp * was synchronous, don't force a commit immediately. Let's 1812e07f7183SJosef Bacik * yield and let another thread piggyback onto this 1813e07f7183SJosef Bacik * transaction. Keep doing that while new threads continue to 1814e07f7183SJosef Bacik * arrive. It doesn't cost much - we're about to run a commit 1815e07f7183SJosef Bacik * and sleep on IO anyway. Speeds up many-threaded, many-dir 1816e07f7183SJosef Bacik * operations by 30x or more... 1817470decc6SDave Kleikamp * 1818e07f7183SJosef Bacik * We try and optimize the sleep time against what the 1819e07f7183SJosef Bacik * underlying disk can do, instead of having a static sleep 1820e07f7183SJosef Bacik * time. This is useful for the case where our storage is so 1821e07f7183SJosef Bacik * fast that it is more optimal to go ahead and force a flush 1822e07f7183SJosef Bacik * and wait for the transaction to be committed than it is to 1823e07f7183SJosef Bacik * wait for an arbitrary amount of time for new writers to 1824e07f7183SJosef Bacik * join the transaction. We achieve this by measuring how 1825e07f7183SJosef Bacik * long it takes to commit a transaction, and compare it with 1826e07f7183SJosef Bacik * how long this transaction has been running, and if run time 1827e07f7183SJosef Bacik * < commit time then we sleep for the delta and commit. This 1828e07f7183SJosef Bacik * greatly helps super fast disks that would see slowdowns as 1829e07f7183SJosef Bacik * more threads started doing fsyncs. 1830e07f7183SJosef Bacik * 1831e07f7183SJosef Bacik * But don't do this if this process was the most recent one 1832e07f7183SJosef Bacik * to perform a synchronous write. We do this to detect the 1833e07f7183SJosef Bacik * case where a single process is doing a stream of sync 1834e07f7183SJosef Bacik * writes. No point in waiting for joiners in that case. 18355dd21424SEric Sandeen * 18365dd21424SEric Sandeen * Setting max_batch_time to 0 disables this completely. 1837470decc6SDave Kleikamp */ 1838470decc6SDave Kleikamp pid = current->pid; 18395dd21424SEric Sandeen if (handle->h_sync && journal->j_last_sync_writer != pid && 18405dd21424SEric Sandeen journal->j_max_batch_time) { 1841e07f7183SJosef Bacik u64 commit_time, trans_time; 1842e07f7183SJosef Bacik 1843470decc6SDave Kleikamp journal->j_last_sync_writer = pid; 1844e07f7183SJosef Bacik 1845a931da6aSTheodore Ts'o read_lock(&journal->j_state_lock); 1846e07f7183SJosef Bacik commit_time = journal->j_average_commit_time; 1847a931da6aSTheodore Ts'o read_unlock(&journal->j_state_lock); 1848e07f7183SJosef Bacik 1849e07f7183SJosef Bacik trans_time = ktime_to_ns(ktime_sub(ktime_get(), 1850e07f7183SJosef Bacik transaction->t_start_time)); 1851e07f7183SJosef Bacik 185230773840STheodore Ts'o commit_time = max_t(u64, commit_time, 185330773840STheodore Ts'o 1000*journal->j_min_batch_time); 1854e07f7183SJosef Bacik commit_time = min_t(u64, commit_time, 185530773840STheodore Ts'o 1000*journal->j_max_batch_time); 1856e07f7183SJosef Bacik 1857e07f7183SJosef Bacik if (trans_time < commit_time) { 1858e07f7183SJosef Bacik ktime_t expires = ktime_add_ns(ktime_get(), 1859e07f7183SJosef Bacik commit_time); 1860e07f7183SJosef Bacik set_current_state(TASK_UNINTERRUPTIBLE); 1861e07f7183SJosef Bacik schedule_hrtimeout(&expires, HRTIMER_MODE_ABS); 1862e07f7183SJosef Bacik } 1863470decc6SDave Kleikamp } 1864470decc6SDave Kleikamp 18657058548cSTheodore Ts'o if (handle->h_sync) 18667058548cSTheodore Ts'o transaction->t_synchronous_commit = 1; 1867470decc6SDave Kleikamp 1868470decc6SDave Kleikamp /* 1869470decc6SDave Kleikamp * If the handle is marked SYNC, we need to set another commit 1870150549edSJan Kara * going! We also want to force a commit if the transaction is too 1871150549edSJan Kara * old now. 1872470decc6SDave Kleikamp */ 1873470decc6SDave Kleikamp if (handle->h_sync || 1874470decc6SDave Kleikamp time_after_eq(jiffies, transaction->t_expires)) { 1875470decc6SDave Kleikamp /* Do this even for aborted journals: an abort still 1876470decc6SDave Kleikamp * completes the commit thread, it just doesn't write 1877470decc6SDave Kleikamp * anything to disk. */ 1878470decc6SDave Kleikamp 1879470decc6SDave Kleikamp jbd_debug(2, "transaction too old, requesting commit for " 1880470decc6SDave Kleikamp "handle %p\n", handle); 1881470decc6SDave Kleikamp /* This is non-blocking */ 1882dfaf5ffdSJan Kara jbd2_log_start_commit(journal, tid); 1883470decc6SDave Kleikamp 1884470decc6SDave Kleikamp /* 1885f7f4bccbSMingming Cao * Special case: JBD2_SYNC synchronous updates require us 1886470decc6SDave Kleikamp * to wait for the commit to complete. 1887470decc6SDave Kleikamp */ 1888470decc6SDave Kleikamp if (handle->h_sync && !(current->flags & PF_MEMALLOC)) 1889a51dca9cSTheodore Ts'o wait_for_commit = 1; 1890470decc6SDave Kleikamp } 1891470decc6SDave Kleikamp 1892a51dca9cSTheodore Ts'o /* 1893ec8b6f60SJan Kara * Once stop_this_handle() drops t_updates, the transaction could start 1894ec8b6f60SJan Kara * committing on us and eventually disappear. So we must not 1895ec8b6f60SJan Kara * dereference transaction pointer again after calling 1896ec8b6f60SJan Kara * stop_this_handle(). 1897a51dca9cSTheodore Ts'o */ 1898ec8b6f60SJan Kara stop_this_handle(handle); 18997a4b188fSJan Kara 1900a51dca9cSTheodore Ts'o if (wait_for_commit) 1901a51dca9cSTheodore Ts'o err = jbd2_log_wait_commit(journal, tid); 1902a51dca9cSTheodore Ts'o 190341a5b913STheodore Ts'o free_and_exit: 1904ec8b6f60SJan Kara if (handle->h_rsv_handle) 1905ec8b6f60SJan Kara jbd2_free_handle(handle->h_rsv_handle); 1906af1e76d6SMingming Cao jbd2_free_handle(handle); 1907470decc6SDave Kleikamp return err; 1908470decc6SDave Kleikamp } 1909470decc6SDave Kleikamp 1910470decc6SDave Kleikamp /* 1911470decc6SDave Kleikamp * 1912470decc6SDave Kleikamp * List management code snippets: various functions for manipulating the 1913470decc6SDave Kleikamp * transaction buffer lists. 1914470decc6SDave Kleikamp * 1915470decc6SDave Kleikamp */ 1916470decc6SDave Kleikamp 1917470decc6SDave Kleikamp /* 1918470decc6SDave Kleikamp * Append a buffer to a transaction list, given the transaction's list head 1919470decc6SDave Kleikamp * pointer. 1920470decc6SDave Kleikamp * 1921470decc6SDave Kleikamp * j_list_lock is held. 1922470decc6SDave Kleikamp * 1923470decc6SDave Kleikamp * jbd_lock_bh_state(jh2bh(jh)) is held. 1924470decc6SDave Kleikamp */ 1925470decc6SDave Kleikamp 1926470decc6SDave Kleikamp static inline void 1927470decc6SDave Kleikamp __blist_add_buffer(struct journal_head **list, struct journal_head *jh) 1928470decc6SDave Kleikamp { 1929470decc6SDave Kleikamp if (!*list) { 1930470decc6SDave Kleikamp jh->b_tnext = jh->b_tprev = jh; 1931470decc6SDave Kleikamp *list = jh; 1932470decc6SDave Kleikamp } else { 1933470decc6SDave Kleikamp /* Insert at the tail of the list to preserve order */ 1934470decc6SDave Kleikamp struct journal_head *first = *list, *last = first->b_tprev; 1935470decc6SDave Kleikamp jh->b_tprev = last; 1936470decc6SDave Kleikamp jh->b_tnext = first; 1937470decc6SDave Kleikamp last->b_tnext = first->b_tprev = jh; 1938470decc6SDave Kleikamp } 1939470decc6SDave Kleikamp } 1940470decc6SDave Kleikamp 1941470decc6SDave Kleikamp /* 1942470decc6SDave Kleikamp * Remove a buffer from a transaction list, given the transaction's list 1943470decc6SDave Kleikamp * head pointer. 1944470decc6SDave Kleikamp * 1945470decc6SDave Kleikamp * Called with j_list_lock held, and the journal may not be locked. 1946470decc6SDave Kleikamp * 1947470decc6SDave Kleikamp * jbd_lock_bh_state(jh2bh(jh)) is held. 1948470decc6SDave Kleikamp */ 1949470decc6SDave Kleikamp 1950470decc6SDave Kleikamp static inline void 1951470decc6SDave Kleikamp __blist_del_buffer(struct journal_head **list, struct journal_head *jh) 1952470decc6SDave Kleikamp { 1953470decc6SDave Kleikamp if (*list == jh) { 1954470decc6SDave Kleikamp *list = jh->b_tnext; 1955470decc6SDave Kleikamp if (*list == jh) 1956470decc6SDave Kleikamp *list = NULL; 1957470decc6SDave Kleikamp } 1958470decc6SDave Kleikamp jh->b_tprev->b_tnext = jh->b_tnext; 1959470decc6SDave Kleikamp jh->b_tnext->b_tprev = jh->b_tprev; 1960470decc6SDave Kleikamp } 1961470decc6SDave Kleikamp 1962470decc6SDave Kleikamp /* 1963470decc6SDave Kleikamp * Remove a buffer from the appropriate transaction list. 1964470decc6SDave Kleikamp * 1965470decc6SDave Kleikamp * Note that this function can *change* the value of 1966f5113effSJan Kara * bh->b_transaction->t_buffers, t_forget, t_shadow_list, t_log_list or 1967f5113effSJan Kara * t_reserved_list. If the caller is holding onto a copy of one of these 1968f5113effSJan Kara * pointers, it could go bad. Generally the caller needs to re-read the 1969f5113effSJan Kara * pointer from the transaction_t. 1970470decc6SDave Kleikamp * 19715bebccf9SJan Kara * Called under j_list_lock. 1972470decc6SDave Kleikamp */ 19735bebccf9SJan Kara static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh) 1974470decc6SDave Kleikamp { 1975470decc6SDave Kleikamp struct journal_head **list = NULL; 1976470decc6SDave Kleikamp transaction_t *transaction; 1977470decc6SDave Kleikamp struct buffer_head *bh = jh2bh(jh); 1978470decc6SDave Kleikamp 1979470decc6SDave Kleikamp J_ASSERT_JH(jh, jbd_is_locked_bh_state(bh)); 1980470decc6SDave Kleikamp transaction = jh->b_transaction; 1981470decc6SDave Kleikamp if (transaction) 1982470decc6SDave Kleikamp assert_spin_locked(&transaction->t_journal->j_list_lock); 1983470decc6SDave Kleikamp 1984470decc6SDave Kleikamp J_ASSERT_JH(jh, jh->b_jlist < BJ_Types); 1985470decc6SDave Kleikamp if (jh->b_jlist != BJ_None) 19864019191bSMingming Cao J_ASSERT_JH(jh, transaction != NULL); 1987470decc6SDave Kleikamp 1988470decc6SDave Kleikamp switch (jh->b_jlist) { 1989470decc6SDave Kleikamp case BJ_None: 1990470decc6SDave Kleikamp return; 1991470decc6SDave Kleikamp case BJ_Metadata: 1992470decc6SDave Kleikamp transaction->t_nr_buffers--; 1993470decc6SDave Kleikamp J_ASSERT_JH(jh, transaction->t_nr_buffers >= 0); 1994470decc6SDave Kleikamp list = &transaction->t_buffers; 1995470decc6SDave Kleikamp break; 1996470decc6SDave Kleikamp case BJ_Forget: 1997470decc6SDave Kleikamp list = &transaction->t_forget; 1998470decc6SDave Kleikamp break; 1999470decc6SDave Kleikamp case BJ_Shadow: 2000470decc6SDave Kleikamp list = &transaction->t_shadow_list; 2001470decc6SDave Kleikamp break; 2002470decc6SDave Kleikamp case BJ_Reserved: 2003470decc6SDave Kleikamp list = &transaction->t_reserved_list; 2004470decc6SDave Kleikamp break; 2005470decc6SDave Kleikamp } 2006470decc6SDave Kleikamp 2007470decc6SDave Kleikamp __blist_del_buffer(list, jh); 2008470decc6SDave Kleikamp jh->b_jlist = BJ_None; 2009e112666bSTheodore Ts'o if (transaction && is_journal_aborted(transaction->t_journal)) 2010e112666bSTheodore Ts'o clear_buffer_jbddirty(bh); 2011e112666bSTheodore Ts'o else if (test_clear_buffer_jbddirty(bh)) 2012470decc6SDave Kleikamp mark_buffer_dirty(bh); /* Expose it to the VM */ 2013470decc6SDave Kleikamp } 2014470decc6SDave Kleikamp 2015de1b7941SJan Kara /* 2016de1b7941SJan Kara * Remove buffer from all transactions. 2017de1b7941SJan Kara * 2018de1b7941SJan Kara * Called with bh_state lock and j_list_lock 2019de1b7941SJan Kara * 2020de1b7941SJan Kara * jh and bh may be already freed when this function returns. 2021de1b7941SJan Kara */ 2022de1b7941SJan Kara static void __jbd2_journal_unfile_buffer(struct journal_head *jh) 2023470decc6SDave Kleikamp { 2024f7f4bccbSMingming Cao __jbd2_journal_temp_unlink_buffer(jh); 2025470decc6SDave Kleikamp jh->b_transaction = NULL; 2026de1b7941SJan Kara jbd2_journal_put_journal_head(jh); 2027470decc6SDave Kleikamp } 2028470decc6SDave Kleikamp 2029f7f4bccbSMingming Cao void jbd2_journal_unfile_buffer(journal_t *journal, struct journal_head *jh) 2030470decc6SDave Kleikamp { 2031de1b7941SJan Kara struct buffer_head *bh = jh2bh(jh); 2032de1b7941SJan Kara 2033de1b7941SJan Kara /* Get reference so that buffer cannot be freed before we unlock it */ 2034de1b7941SJan Kara get_bh(bh); 2035de1b7941SJan Kara jbd_lock_bh_state(bh); 2036470decc6SDave Kleikamp spin_lock(&journal->j_list_lock); 2037f7f4bccbSMingming Cao __jbd2_journal_unfile_buffer(jh); 2038470decc6SDave Kleikamp spin_unlock(&journal->j_list_lock); 2039de1b7941SJan Kara jbd_unlock_bh_state(bh); 2040de1b7941SJan Kara __brelse(bh); 2041470decc6SDave Kleikamp } 2042470decc6SDave Kleikamp 2043470decc6SDave Kleikamp /* 2044f7f4bccbSMingming Cao * Called from jbd2_journal_try_to_free_buffers(). 2045470decc6SDave Kleikamp * 2046470decc6SDave Kleikamp * Called under jbd_lock_bh_state(bh) 2047470decc6SDave Kleikamp */ 2048470decc6SDave Kleikamp static void 2049470decc6SDave Kleikamp __journal_try_to_free_buffer(journal_t *journal, struct buffer_head *bh) 2050470decc6SDave Kleikamp { 2051470decc6SDave Kleikamp struct journal_head *jh; 2052470decc6SDave Kleikamp 2053470decc6SDave Kleikamp jh = bh2jh(bh); 2054470decc6SDave Kleikamp 2055470decc6SDave Kleikamp if (buffer_locked(bh) || buffer_dirty(bh)) 2056470decc6SDave Kleikamp goto out; 2057470decc6SDave Kleikamp 2058d2eb0b99STheodore Ts'o if (jh->b_next_transaction != NULL || jh->b_transaction != NULL) 2059470decc6SDave Kleikamp goto out; 2060470decc6SDave Kleikamp 2061470decc6SDave Kleikamp spin_lock(&journal->j_list_lock); 2062d2eb0b99STheodore Ts'o if (jh->b_cp_transaction != NULL) { 2063470decc6SDave Kleikamp /* written-back checkpointed metadata buffer */ 2064470decc6SDave Kleikamp JBUFFER_TRACE(jh, "remove from checkpoint list"); 2065f7f4bccbSMingming Cao __jbd2_journal_remove_checkpoint(jh); 2066470decc6SDave Kleikamp } 2067470decc6SDave Kleikamp spin_unlock(&journal->j_list_lock); 2068470decc6SDave Kleikamp out: 2069470decc6SDave Kleikamp return; 2070470decc6SDave Kleikamp } 2071470decc6SDave Kleikamp 2072470decc6SDave Kleikamp /** 2073f7f4bccbSMingming Cao * int jbd2_journal_try_to_free_buffers() - try to free page buffers. 2074470decc6SDave Kleikamp * @journal: journal for operation 2075470decc6SDave Kleikamp * @page: to try and free 2076530576bbSMingming Cao * @gfp_mask: we use the mask to detect how hard should we try to release 2077d0164adcSMel Gorman * buffers. If __GFP_DIRECT_RECLAIM and __GFP_FS is set, we wait for commit 2078d0164adcSMel Gorman * code to release the buffers. 2079470decc6SDave Kleikamp * 2080470decc6SDave Kleikamp * 2081470decc6SDave Kleikamp * For all the buffers on this page, 2082470decc6SDave Kleikamp * if they are fully written out ordered data, move them onto BUF_CLEAN 2083470decc6SDave Kleikamp * so try_to_free_buffers() can reap them. 2084470decc6SDave Kleikamp * 2085470decc6SDave Kleikamp * This function returns non-zero if we wish try_to_free_buffers() 2086470decc6SDave Kleikamp * to be called. We do this if the page is releasable by try_to_free_buffers(). 2087470decc6SDave Kleikamp * We also do it if the page has locked or dirty buffers and the caller wants 2088470decc6SDave Kleikamp * us to perform sync or async writeout. 2089470decc6SDave Kleikamp * 2090470decc6SDave Kleikamp * This complicates JBD locking somewhat. We aren't protected by the 2091470decc6SDave Kleikamp * BKL here. We wish to remove the buffer from its committing or 2092f7f4bccbSMingming Cao * running transaction's ->t_datalist via __jbd2_journal_unfile_buffer. 2093470decc6SDave Kleikamp * 2094470decc6SDave Kleikamp * This may *change* the value of transaction_t->t_datalist, so anyone 2095470decc6SDave Kleikamp * who looks at t_datalist needs to lock against this function. 2096470decc6SDave Kleikamp * 2097f7f4bccbSMingming Cao * Even worse, someone may be doing a jbd2_journal_dirty_data on this 2098f7f4bccbSMingming Cao * buffer. So we need to lock against that. jbd2_journal_dirty_data() 2099470decc6SDave Kleikamp * will come out of the lock with the buffer dirty, which makes it 2100470decc6SDave Kleikamp * ineligible for release here. 2101470decc6SDave Kleikamp * 2102470decc6SDave Kleikamp * Who else is affected by this? hmm... Really the only contender 2103470decc6SDave Kleikamp * is do_get_write_access() - it could be looking at the buffer while 2104470decc6SDave Kleikamp * journal_try_to_free_buffer() is changing its state. But that 2105470decc6SDave Kleikamp * cannot happen because we never reallocate freed data as metadata 2106470decc6SDave Kleikamp * while the data is part of a transaction. Yes? 2107530576bbSMingming Cao * 2108530576bbSMingming Cao * Return 0 on failure, 1 on success 2109470decc6SDave Kleikamp */ 2110f7f4bccbSMingming Cao int jbd2_journal_try_to_free_buffers(journal_t *journal, 2111530576bbSMingming Cao struct page *page, gfp_t gfp_mask) 2112470decc6SDave Kleikamp { 2113470decc6SDave Kleikamp struct buffer_head *head; 2114470decc6SDave Kleikamp struct buffer_head *bh; 2115470decc6SDave Kleikamp int ret = 0; 2116470decc6SDave Kleikamp 2117470decc6SDave Kleikamp J_ASSERT(PageLocked(page)); 2118470decc6SDave Kleikamp 2119470decc6SDave Kleikamp head = page_buffers(page); 2120470decc6SDave Kleikamp bh = head; 2121470decc6SDave Kleikamp do { 2122470decc6SDave Kleikamp struct journal_head *jh; 2123470decc6SDave Kleikamp 2124470decc6SDave Kleikamp /* 2125470decc6SDave Kleikamp * We take our own ref against the journal_head here to avoid 2126470decc6SDave Kleikamp * having to add tons of locking around each instance of 2127530576bbSMingming Cao * jbd2_journal_put_journal_head(). 2128470decc6SDave Kleikamp */ 2129f7f4bccbSMingming Cao jh = jbd2_journal_grab_journal_head(bh); 2130470decc6SDave Kleikamp if (!jh) 2131470decc6SDave Kleikamp continue; 2132470decc6SDave Kleikamp 2133470decc6SDave Kleikamp jbd_lock_bh_state(bh); 2134470decc6SDave Kleikamp __journal_try_to_free_buffer(journal, bh); 2135f7f4bccbSMingming Cao jbd2_journal_put_journal_head(jh); 2136470decc6SDave Kleikamp jbd_unlock_bh_state(bh); 2137470decc6SDave Kleikamp if (buffer_jbd(bh)) 2138470decc6SDave Kleikamp goto busy; 2139470decc6SDave Kleikamp } while ((bh = bh->b_this_page) != head); 2140530576bbSMingming Cao 2141470decc6SDave Kleikamp ret = try_to_free_buffers(page); 2142530576bbSMingming Cao 2143470decc6SDave Kleikamp busy: 2144470decc6SDave Kleikamp return ret; 2145470decc6SDave Kleikamp } 2146470decc6SDave Kleikamp 2147470decc6SDave Kleikamp /* 2148470decc6SDave Kleikamp * This buffer is no longer needed. If it is on an older transaction's 2149470decc6SDave Kleikamp * checkpoint list we need to record it on this transaction's forget list 2150470decc6SDave Kleikamp * to pin this buffer (and hence its checkpointing transaction) down until 2151470decc6SDave Kleikamp * this transaction commits. If the buffer isn't on a checkpoint list, we 2152470decc6SDave Kleikamp * release it. 2153470decc6SDave Kleikamp * Returns non-zero if JBD no longer has an interest in the buffer. 2154470decc6SDave Kleikamp * 2155470decc6SDave Kleikamp * Called under j_list_lock. 2156470decc6SDave Kleikamp * 2157470decc6SDave Kleikamp * Called under jbd_lock_bh_state(bh). 2158470decc6SDave Kleikamp */ 2159470decc6SDave Kleikamp static int __dispose_buffer(struct journal_head *jh, transaction_t *transaction) 2160470decc6SDave Kleikamp { 2161470decc6SDave Kleikamp int may_free = 1; 2162470decc6SDave Kleikamp struct buffer_head *bh = jh2bh(jh); 2163470decc6SDave Kleikamp 2164470decc6SDave Kleikamp if (jh->b_cp_transaction) { 2165470decc6SDave Kleikamp JBUFFER_TRACE(jh, "on running+cp transaction"); 2166de1b7941SJan Kara __jbd2_journal_temp_unlink_buffer(jh); 2167f91d1d04SJan Kara /* 2168f91d1d04SJan Kara * We don't want to write the buffer anymore, clear the 2169f91d1d04SJan Kara * bit so that we don't confuse checks in 2170f91d1d04SJan Kara * __journal_file_buffer 2171f91d1d04SJan Kara */ 2172f91d1d04SJan Kara clear_buffer_dirty(bh); 2173f7f4bccbSMingming Cao __jbd2_journal_file_buffer(jh, transaction, BJ_Forget); 2174470decc6SDave Kleikamp may_free = 0; 2175470decc6SDave Kleikamp } else { 2176470decc6SDave Kleikamp JBUFFER_TRACE(jh, "on running transaction"); 2177de1b7941SJan Kara __jbd2_journal_unfile_buffer(jh); 2178470decc6SDave Kleikamp } 2179470decc6SDave Kleikamp return may_free; 2180470decc6SDave Kleikamp } 2181470decc6SDave Kleikamp 2182470decc6SDave Kleikamp /* 2183f7f4bccbSMingming Cao * jbd2_journal_invalidatepage 2184470decc6SDave Kleikamp * 2185470decc6SDave Kleikamp * This code is tricky. It has a number of cases to deal with. 2186470decc6SDave Kleikamp * 2187470decc6SDave Kleikamp * There are two invariants which this code relies on: 2188470decc6SDave Kleikamp * 2189470decc6SDave Kleikamp * i_size must be updated on disk before we start calling invalidatepage on the 2190470decc6SDave Kleikamp * data. 2191470decc6SDave Kleikamp * 2192470decc6SDave Kleikamp * This is done in ext3 by defining an ext3_setattr method which 2193470decc6SDave Kleikamp * updates i_size before truncate gets going. By maintaining this 2194470decc6SDave Kleikamp * invariant, we can be sure that it is safe to throw away any buffers 2195470decc6SDave Kleikamp * attached to the current transaction: once the transaction commits, 2196470decc6SDave Kleikamp * we know that the data will not be needed. 2197470decc6SDave Kleikamp * 2198470decc6SDave Kleikamp * Note however that we can *not* throw away data belonging to the 2199470decc6SDave Kleikamp * previous, committing transaction! 2200470decc6SDave Kleikamp * 2201470decc6SDave Kleikamp * Any disk blocks which *are* part of the previous, committing 2202470decc6SDave Kleikamp * transaction (and which therefore cannot be discarded immediately) are 2203470decc6SDave Kleikamp * not going to be reused in the new running transaction 2204470decc6SDave Kleikamp * 2205470decc6SDave Kleikamp * The bitmap committed_data images guarantee this: any block which is 2206470decc6SDave Kleikamp * allocated in one transaction and removed in the next will be marked 2207470decc6SDave Kleikamp * as in-use in the committed_data bitmap, so cannot be reused until 2208470decc6SDave Kleikamp * the next transaction to delete the block commits. This means that 2209470decc6SDave Kleikamp * leaving committing buffers dirty is quite safe: the disk blocks 2210470decc6SDave Kleikamp * cannot be reallocated to a different file and so buffer aliasing is 2211470decc6SDave Kleikamp * not possible. 2212470decc6SDave Kleikamp * 2213470decc6SDave Kleikamp * 2214470decc6SDave Kleikamp * The above applies mainly to ordered data mode. In writeback mode we 2215470decc6SDave Kleikamp * don't make guarantees about the order in which data hits disk --- in 2216470decc6SDave Kleikamp * particular we don't guarantee that new dirty data is flushed before 2217470decc6SDave Kleikamp * transaction commit --- so it is always safe just to discard data 2218470decc6SDave Kleikamp * immediately in that mode. --sct 2219470decc6SDave Kleikamp */ 2220470decc6SDave Kleikamp 2221470decc6SDave Kleikamp /* 2222470decc6SDave Kleikamp * The journal_unmap_buffer helper function returns zero if the buffer 2223470decc6SDave Kleikamp * concerned remains pinned as an anonymous buffer belonging to an older 2224470decc6SDave Kleikamp * transaction. 2225470decc6SDave Kleikamp * 2226470decc6SDave Kleikamp * We're outside-transaction here. Either or both of j_running_transaction 2227470decc6SDave Kleikamp * and j_committing_transaction may be NULL. 2228470decc6SDave Kleikamp */ 2229b794e7a6SJan Kara static int journal_unmap_buffer(journal_t *journal, struct buffer_head *bh, 2230b794e7a6SJan Kara int partial_page) 2231470decc6SDave Kleikamp { 2232470decc6SDave Kleikamp transaction_t *transaction; 2233470decc6SDave Kleikamp struct journal_head *jh; 2234470decc6SDave Kleikamp int may_free = 1; 2235470decc6SDave Kleikamp 2236470decc6SDave Kleikamp BUFFER_TRACE(bh, "entry"); 2237470decc6SDave Kleikamp 2238470decc6SDave Kleikamp /* 2239470decc6SDave Kleikamp * It is safe to proceed here without the j_list_lock because the 2240470decc6SDave Kleikamp * buffers cannot be stolen by try_to_free_buffers as long as we are 2241470decc6SDave Kleikamp * holding the page lock. --sct 2242470decc6SDave Kleikamp */ 2243470decc6SDave Kleikamp 2244470decc6SDave Kleikamp if (!buffer_jbd(bh)) 2245470decc6SDave Kleikamp goto zap_buffer_unlocked; 2246470decc6SDave Kleikamp 224787c89c23SJan Kara /* OK, we have data buffer in journaled mode */ 2248a931da6aSTheodore Ts'o write_lock(&journal->j_state_lock); 2249470decc6SDave Kleikamp jbd_lock_bh_state(bh); 2250470decc6SDave Kleikamp spin_lock(&journal->j_list_lock); 2251470decc6SDave Kleikamp 2252f7f4bccbSMingming Cao jh = jbd2_journal_grab_journal_head(bh); 2253470decc6SDave Kleikamp if (!jh) 2254470decc6SDave Kleikamp goto zap_buffer_no_jh; 2255470decc6SDave Kleikamp 2256ba869023Sdingdinghua /* 2257ba869023Sdingdinghua * We cannot remove the buffer from checkpoint lists until the 2258ba869023Sdingdinghua * transaction adding inode to orphan list (let's call it T) 2259ba869023Sdingdinghua * is committed. Otherwise if the transaction changing the 2260ba869023Sdingdinghua * buffer would be cleaned from the journal before T is 2261ba869023Sdingdinghua * committed, a crash will cause that the correct contents of 2262ba869023Sdingdinghua * the buffer will be lost. On the other hand we have to 2263ba869023Sdingdinghua * clear the buffer dirty bit at latest at the moment when the 2264ba869023Sdingdinghua * transaction marking the buffer as freed in the filesystem 2265ba869023Sdingdinghua * structures is committed because from that moment on the 2266b794e7a6SJan Kara * block can be reallocated and used by a different page. 2267ba869023Sdingdinghua * Since the block hasn't been freed yet but the inode has 2268ba869023Sdingdinghua * already been added to orphan list, it is safe for us to add 2269ba869023Sdingdinghua * the buffer to BJ_Forget list of the newest transaction. 2270b794e7a6SJan Kara * 2271b794e7a6SJan Kara * Also we have to clear buffer_mapped flag of a truncated buffer 2272b794e7a6SJan Kara * because the buffer_head may be attached to the page straddling 2273b794e7a6SJan Kara * i_size (can happen only when blocksize < pagesize) and thus the 2274b794e7a6SJan Kara * buffer_head can be reused when the file is extended again. So we end 2275b794e7a6SJan Kara * up keeping around invalidated buffers attached to transactions' 2276b794e7a6SJan Kara * BJ_Forget list just to stop checkpointing code from cleaning up 2277b794e7a6SJan Kara * the transaction this buffer was modified in. 2278ba869023Sdingdinghua */ 2279470decc6SDave Kleikamp transaction = jh->b_transaction; 2280470decc6SDave Kleikamp if (transaction == NULL) { 2281470decc6SDave Kleikamp /* First case: not on any transaction. If it 2282470decc6SDave Kleikamp * has no checkpoint link, then we can zap it: 2283470decc6SDave Kleikamp * it's a writeback-mode buffer so we don't care 2284470decc6SDave Kleikamp * if it hits disk safely. */ 2285470decc6SDave Kleikamp if (!jh->b_cp_transaction) { 2286470decc6SDave Kleikamp JBUFFER_TRACE(jh, "not on any transaction: zap"); 2287470decc6SDave Kleikamp goto zap_buffer; 2288470decc6SDave Kleikamp } 2289470decc6SDave Kleikamp 2290470decc6SDave Kleikamp if (!buffer_dirty(bh)) { 2291470decc6SDave Kleikamp /* bdflush has written it. We can drop it now */ 2292bc23f0c8SJan Kara __jbd2_journal_remove_checkpoint(jh); 2293470decc6SDave Kleikamp goto zap_buffer; 2294470decc6SDave Kleikamp } 2295470decc6SDave Kleikamp 2296470decc6SDave Kleikamp /* OK, it must be in the journal but still not 2297470decc6SDave Kleikamp * written fully to disk: it's metadata or 2298470decc6SDave Kleikamp * journaled data... */ 2299470decc6SDave Kleikamp 2300470decc6SDave Kleikamp if (journal->j_running_transaction) { 2301470decc6SDave Kleikamp /* ... and once the current transaction has 2302470decc6SDave Kleikamp * committed, the buffer won't be needed any 2303470decc6SDave Kleikamp * longer. */ 2304470decc6SDave Kleikamp JBUFFER_TRACE(jh, "checkpointed: add to BJ_Forget"); 2305b794e7a6SJan Kara may_free = __dispose_buffer(jh, 2306470decc6SDave Kleikamp journal->j_running_transaction); 2307b794e7a6SJan Kara goto zap_buffer; 2308470decc6SDave Kleikamp } else { 2309470decc6SDave Kleikamp /* There is no currently-running transaction. So the 2310470decc6SDave Kleikamp * orphan record which we wrote for this file must have 2311470decc6SDave Kleikamp * passed into commit. We must attach this buffer to 2312470decc6SDave Kleikamp * the committing transaction, if it exists. */ 2313470decc6SDave Kleikamp if (journal->j_committing_transaction) { 2314470decc6SDave Kleikamp JBUFFER_TRACE(jh, "give to committing trans"); 2315b794e7a6SJan Kara may_free = __dispose_buffer(jh, 2316470decc6SDave Kleikamp journal->j_committing_transaction); 2317b794e7a6SJan Kara goto zap_buffer; 2318470decc6SDave Kleikamp } else { 2319470decc6SDave Kleikamp /* The orphan record's transaction has 2320470decc6SDave Kleikamp * committed. We can cleanse this buffer */ 2321470decc6SDave Kleikamp clear_buffer_jbddirty(bh); 2322bc23f0c8SJan Kara __jbd2_journal_remove_checkpoint(jh); 2323470decc6SDave Kleikamp goto zap_buffer; 2324470decc6SDave Kleikamp } 2325470decc6SDave Kleikamp } 2326470decc6SDave Kleikamp } else if (transaction == journal->j_committing_transaction) { 23279b57988dSEric Sandeen JBUFFER_TRACE(jh, "on committing transaction"); 2328470decc6SDave Kleikamp /* 2329ba869023Sdingdinghua * The buffer is committing, we simply cannot touch 2330b794e7a6SJan Kara * it. If the page is straddling i_size we have to wait 2331b794e7a6SJan Kara * for commit and try again. 2332b794e7a6SJan Kara */ 2333b794e7a6SJan Kara if (partial_page) { 2334b794e7a6SJan Kara jbd2_journal_put_journal_head(jh); 2335b794e7a6SJan Kara spin_unlock(&journal->j_list_lock); 2336b794e7a6SJan Kara jbd_unlock_bh_state(bh); 2337b794e7a6SJan Kara write_unlock(&journal->j_state_lock); 233853e87268SJan Kara return -EBUSY; 2339b794e7a6SJan Kara } 2340b794e7a6SJan Kara /* 2341b794e7a6SJan Kara * OK, buffer won't be reachable after truncate. We just set 2342b794e7a6SJan Kara * j_next_transaction to the running transaction (if there is 2343b794e7a6SJan Kara * one) and mark buffer as freed so that commit code knows it 2344b794e7a6SJan Kara * should clear dirty bits when it is done with the buffer. 2345ba869023Sdingdinghua */ 2346470decc6SDave Kleikamp set_buffer_freed(bh); 2347ba869023Sdingdinghua if (journal->j_running_transaction && buffer_jbddirty(bh)) 2348ba869023Sdingdinghua jh->b_next_transaction = journal->j_running_transaction; 2349f7f4bccbSMingming Cao jbd2_journal_put_journal_head(jh); 2350470decc6SDave Kleikamp spin_unlock(&journal->j_list_lock); 2351470decc6SDave Kleikamp jbd_unlock_bh_state(bh); 2352a931da6aSTheodore Ts'o write_unlock(&journal->j_state_lock); 2353470decc6SDave Kleikamp return 0; 2354470decc6SDave Kleikamp } else { 2355470decc6SDave Kleikamp /* Good, the buffer belongs to the running transaction. 2356470decc6SDave Kleikamp * We are writing our own transaction's data, not any 2357470decc6SDave Kleikamp * previous one's, so it is safe to throw it away 2358470decc6SDave Kleikamp * (remember that we expect the filesystem to have set 2359470decc6SDave Kleikamp * i_size already for this truncate so recovery will not 2360470decc6SDave Kleikamp * expose the disk blocks we are discarding here.) */ 2361470decc6SDave Kleikamp J_ASSERT_JH(jh, transaction == journal->j_running_transaction); 23629b57988dSEric Sandeen JBUFFER_TRACE(jh, "on running transaction"); 2363470decc6SDave Kleikamp may_free = __dispose_buffer(jh, transaction); 2364470decc6SDave Kleikamp } 2365470decc6SDave Kleikamp 2366470decc6SDave Kleikamp zap_buffer: 2367b794e7a6SJan Kara /* 2368b794e7a6SJan Kara * This is tricky. Although the buffer is truncated, it may be reused 2369b794e7a6SJan Kara * if blocksize < pagesize and it is attached to the page straddling 2370b794e7a6SJan Kara * EOF. Since the buffer might have been added to BJ_Forget list of the 2371b794e7a6SJan Kara * running transaction, journal_get_write_access() won't clear 2372b794e7a6SJan Kara * b_modified and credit accounting gets confused. So clear b_modified 2373b794e7a6SJan Kara * here. 2374b794e7a6SJan Kara */ 2375b794e7a6SJan Kara jh->b_modified = 0; 2376f7f4bccbSMingming Cao jbd2_journal_put_journal_head(jh); 2377470decc6SDave Kleikamp zap_buffer_no_jh: 2378470decc6SDave Kleikamp spin_unlock(&journal->j_list_lock); 2379470decc6SDave Kleikamp jbd_unlock_bh_state(bh); 2380a931da6aSTheodore Ts'o write_unlock(&journal->j_state_lock); 2381470decc6SDave Kleikamp zap_buffer_unlocked: 2382470decc6SDave Kleikamp clear_buffer_dirty(bh); 2383470decc6SDave Kleikamp J_ASSERT_BH(bh, !buffer_jbddirty(bh)); 2384470decc6SDave Kleikamp clear_buffer_mapped(bh); 2385470decc6SDave Kleikamp clear_buffer_req(bh); 2386470decc6SDave Kleikamp clear_buffer_new(bh); 238715291164SEric Sandeen clear_buffer_delay(bh); 238815291164SEric Sandeen clear_buffer_unwritten(bh); 2389470decc6SDave Kleikamp bh->b_bdev = NULL; 2390470decc6SDave Kleikamp return may_free; 2391470decc6SDave Kleikamp } 2392470decc6SDave Kleikamp 2393470decc6SDave Kleikamp /** 2394f7f4bccbSMingming Cao * void jbd2_journal_invalidatepage() 2395470decc6SDave Kleikamp * @journal: journal to use for flush... 2396470decc6SDave Kleikamp * @page: page to flush 2397259709b0SLukas Czerner * @offset: start of the range to invalidate 2398259709b0SLukas Czerner * @length: length of the range to invalidate 2399470decc6SDave Kleikamp * 2400259709b0SLukas Czerner * Reap page buffers containing data after in the specified range in page. 2401259709b0SLukas Czerner * Can return -EBUSY if buffers are part of the committing transaction and 2402259709b0SLukas Czerner * the page is straddling i_size. Caller then has to wait for current commit 2403259709b0SLukas Czerner * and try again. 2404470decc6SDave Kleikamp */ 240553e87268SJan Kara int jbd2_journal_invalidatepage(journal_t *journal, 2406470decc6SDave Kleikamp struct page *page, 2407259709b0SLukas Czerner unsigned int offset, 2408259709b0SLukas Czerner unsigned int length) 2409470decc6SDave Kleikamp { 2410470decc6SDave Kleikamp struct buffer_head *head, *bh, *next; 2411259709b0SLukas Czerner unsigned int stop = offset + length; 2412470decc6SDave Kleikamp unsigned int curr_off = 0; 241309cbfeafSKirill A. Shutemov int partial_page = (offset || length < PAGE_SIZE); 2414470decc6SDave Kleikamp int may_free = 1; 241553e87268SJan Kara int ret = 0; 2416470decc6SDave Kleikamp 2417470decc6SDave Kleikamp if (!PageLocked(page)) 2418470decc6SDave Kleikamp BUG(); 2419470decc6SDave Kleikamp if (!page_has_buffers(page)) 242053e87268SJan Kara return 0; 2421470decc6SDave Kleikamp 242209cbfeafSKirill A. Shutemov BUG_ON(stop > PAGE_SIZE || stop < length); 2423259709b0SLukas Czerner 2424470decc6SDave Kleikamp /* We will potentially be playing with lists other than just the 2425470decc6SDave Kleikamp * data lists (especially for journaled data mode), so be 2426470decc6SDave Kleikamp * cautious in our locking. */ 2427470decc6SDave Kleikamp 2428470decc6SDave Kleikamp head = bh = page_buffers(page); 2429470decc6SDave Kleikamp do { 2430470decc6SDave Kleikamp unsigned int next_off = curr_off + bh->b_size; 2431470decc6SDave Kleikamp next = bh->b_this_page; 2432470decc6SDave Kleikamp 2433259709b0SLukas Czerner if (next_off > stop) 2434259709b0SLukas Czerner return 0; 2435259709b0SLukas Czerner 2436470decc6SDave Kleikamp if (offset <= curr_off) { 2437470decc6SDave Kleikamp /* This block is wholly outside the truncation point */ 2438470decc6SDave Kleikamp lock_buffer(bh); 2439259709b0SLukas Czerner ret = journal_unmap_buffer(journal, bh, partial_page); 2440470decc6SDave Kleikamp unlock_buffer(bh); 244153e87268SJan Kara if (ret < 0) 244253e87268SJan Kara return ret; 244353e87268SJan Kara may_free &= ret; 2444470decc6SDave Kleikamp } 2445470decc6SDave Kleikamp curr_off = next_off; 2446470decc6SDave Kleikamp bh = next; 2447470decc6SDave Kleikamp 2448470decc6SDave Kleikamp } while (bh != head); 2449470decc6SDave Kleikamp 2450259709b0SLukas Czerner if (!partial_page) { 2451470decc6SDave Kleikamp if (may_free && try_to_free_buffers(page)) 2452470decc6SDave Kleikamp J_ASSERT(!page_has_buffers(page)); 2453470decc6SDave Kleikamp } 245453e87268SJan Kara return 0; 2455470decc6SDave Kleikamp } 2456470decc6SDave Kleikamp 2457470decc6SDave Kleikamp /* 2458470decc6SDave Kleikamp * File a buffer on the given transaction list. 2459470decc6SDave Kleikamp */ 2460f7f4bccbSMingming Cao void __jbd2_journal_file_buffer(struct journal_head *jh, 2461470decc6SDave Kleikamp transaction_t *transaction, int jlist) 2462470decc6SDave Kleikamp { 2463470decc6SDave Kleikamp struct journal_head **list = NULL; 2464470decc6SDave Kleikamp int was_dirty = 0; 2465470decc6SDave Kleikamp struct buffer_head *bh = jh2bh(jh); 2466470decc6SDave Kleikamp 2467470decc6SDave Kleikamp J_ASSERT_JH(jh, jbd_is_locked_bh_state(bh)); 2468470decc6SDave Kleikamp assert_spin_locked(&transaction->t_journal->j_list_lock); 2469470decc6SDave Kleikamp 2470470decc6SDave Kleikamp J_ASSERT_JH(jh, jh->b_jlist < BJ_Types); 2471470decc6SDave Kleikamp J_ASSERT_JH(jh, jh->b_transaction == transaction || 24724019191bSMingming Cao jh->b_transaction == NULL); 2473470decc6SDave Kleikamp 2474470decc6SDave Kleikamp if (jh->b_transaction && jh->b_jlist == jlist) 2475470decc6SDave Kleikamp return; 2476470decc6SDave Kleikamp 2477470decc6SDave Kleikamp if (jlist == BJ_Metadata || jlist == BJ_Reserved || 2478470decc6SDave Kleikamp jlist == BJ_Shadow || jlist == BJ_Forget) { 2479f91d1d04SJan Kara /* 2480f91d1d04SJan Kara * For metadata buffers, we track dirty bit in buffer_jbddirty 2481f91d1d04SJan Kara * instead of buffer_dirty. We should not see a dirty bit set 2482f91d1d04SJan Kara * here because we clear it in do_get_write_access but e.g. 2483f91d1d04SJan Kara * tune2fs can modify the sb and set the dirty bit at any time 2484f91d1d04SJan Kara * so we try to gracefully handle that. 2485f91d1d04SJan Kara */ 2486f91d1d04SJan Kara if (buffer_dirty(bh)) 2487f91d1d04SJan Kara warn_dirty_buffer(bh); 2488470decc6SDave Kleikamp if (test_clear_buffer_dirty(bh) || 2489470decc6SDave Kleikamp test_clear_buffer_jbddirty(bh)) 2490470decc6SDave Kleikamp was_dirty = 1; 2491470decc6SDave Kleikamp } 2492470decc6SDave Kleikamp 2493470decc6SDave Kleikamp if (jh->b_transaction) 2494f7f4bccbSMingming Cao __jbd2_journal_temp_unlink_buffer(jh); 2495de1b7941SJan Kara else 2496de1b7941SJan Kara jbd2_journal_grab_journal_head(bh); 2497470decc6SDave Kleikamp jh->b_transaction = transaction; 2498470decc6SDave Kleikamp 2499470decc6SDave Kleikamp switch (jlist) { 2500470decc6SDave Kleikamp case BJ_None: 2501470decc6SDave Kleikamp J_ASSERT_JH(jh, !jh->b_committed_data); 2502470decc6SDave Kleikamp J_ASSERT_JH(jh, !jh->b_frozen_data); 2503470decc6SDave Kleikamp return; 2504470decc6SDave Kleikamp case BJ_Metadata: 2505470decc6SDave Kleikamp transaction->t_nr_buffers++; 2506470decc6SDave Kleikamp list = &transaction->t_buffers; 2507470decc6SDave Kleikamp break; 2508470decc6SDave Kleikamp case BJ_Forget: 2509470decc6SDave Kleikamp list = &transaction->t_forget; 2510470decc6SDave Kleikamp break; 2511470decc6SDave Kleikamp case BJ_Shadow: 2512470decc6SDave Kleikamp list = &transaction->t_shadow_list; 2513470decc6SDave Kleikamp break; 2514470decc6SDave Kleikamp case BJ_Reserved: 2515470decc6SDave Kleikamp list = &transaction->t_reserved_list; 2516470decc6SDave Kleikamp break; 2517470decc6SDave Kleikamp } 2518470decc6SDave Kleikamp 2519470decc6SDave Kleikamp __blist_add_buffer(list, jh); 2520470decc6SDave Kleikamp jh->b_jlist = jlist; 2521470decc6SDave Kleikamp 2522470decc6SDave Kleikamp if (was_dirty) 2523470decc6SDave Kleikamp set_buffer_jbddirty(bh); 2524470decc6SDave Kleikamp } 2525470decc6SDave Kleikamp 2526f7f4bccbSMingming Cao void jbd2_journal_file_buffer(struct journal_head *jh, 2527470decc6SDave Kleikamp transaction_t *transaction, int jlist) 2528470decc6SDave Kleikamp { 2529470decc6SDave Kleikamp jbd_lock_bh_state(jh2bh(jh)); 2530470decc6SDave Kleikamp spin_lock(&transaction->t_journal->j_list_lock); 2531f7f4bccbSMingming Cao __jbd2_journal_file_buffer(jh, transaction, jlist); 2532470decc6SDave Kleikamp spin_unlock(&transaction->t_journal->j_list_lock); 2533470decc6SDave Kleikamp jbd_unlock_bh_state(jh2bh(jh)); 2534470decc6SDave Kleikamp } 2535470decc6SDave Kleikamp 2536470decc6SDave Kleikamp /* 2537470decc6SDave Kleikamp * Remove a buffer from its current buffer list in preparation for 2538470decc6SDave Kleikamp * dropping it from its current transaction entirely. If the buffer has 2539470decc6SDave Kleikamp * already started to be used by a subsequent transaction, refile the 2540470decc6SDave Kleikamp * buffer on that transaction's metadata list. 2541470decc6SDave Kleikamp * 2542de1b7941SJan Kara * Called under j_list_lock 2543470decc6SDave Kleikamp * Called under jbd_lock_bh_state(jh2bh(jh)) 2544de1b7941SJan Kara * 2545de1b7941SJan Kara * jh and bh may be already free when this function returns 2546470decc6SDave Kleikamp */ 2547f7f4bccbSMingming Cao void __jbd2_journal_refile_buffer(struct journal_head *jh) 2548470decc6SDave Kleikamp { 2549ba869023Sdingdinghua int was_dirty, jlist; 2550470decc6SDave Kleikamp struct buffer_head *bh = jh2bh(jh); 2551470decc6SDave Kleikamp 2552470decc6SDave Kleikamp J_ASSERT_JH(jh, jbd_is_locked_bh_state(bh)); 2553470decc6SDave Kleikamp if (jh->b_transaction) 2554470decc6SDave Kleikamp assert_spin_locked(&jh->b_transaction->t_journal->j_list_lock); 2555470decc6SDave Kleikamp 2556470decc6SDave Kleikamp /* If the buffer is now unused, just drop it. */ 2557470decc6SDave Kleikamp if (jh->b_next_transaction == NULL) { 2558f7f4bccbSMingming Cao __jbd2_journal_unfile_buffer(jh); 2559470decc6SDave Kleikamp return; 2560470decc6SDave Kleikamp } 2561470decc6SDave Kleikamp 2562470decc6SDave Kleikamp /* 2563470decc6SDave Kleikamp * It has been modified by a later transaction: add it to the new 2564470decc6SDave Kleikamp * transaction's metadata list. 2565470decc6SDave Kleikamp */ 2566470decc6SDave Kleikamp 2567470decc6SDave Kleikamp was_dirty = test_clear_buffer_jbddirty(bh); 2568f7f4bccbSMingming Cao __jbd2_journal_temp_unlink_buffer(jh); 2569de1b7941SJan Kara /* 2570de1b7941SJan Kara * We set b_transaction here because b_next_transaction will inherit 2571de1b7941SJan Kara * our jh reference and thus __jbd2_journal_file_buffer() must not 2572de1b7941SJan Kara * take a new one. 2573de1b7941SJan Kara */ 2574470decc6SDave Kleikamp jh->b_transaction = jh->b_next_transaction; 2575470decc6SDave Kleikamp jh->b_next_transaction = NULL; 2576ba869023Sdingdinghua if (buffer_freed(bh)) 2577ba869023Sdingdinghua jlist = BJ_Forget; 2578ba869023Sdingdinghua else if (jh->b_modified) 2579ba869023Sdingdinghua jlist = BJ_Metadata; 2580ba869023Sdingdinghua else 2581ba869023Sdingdinghua jlist = BJ_Reserved; 2582ba869023Sdingdinghua __jbd2_journal_file_buffer(jh, jh->b_transaction, jlist); 2583470decc6SDave Kleikamp J_ASSERT_JH(jh, jh->b_transaction->t_state == T_RUNNING); 2584470decc6SDave Kleikamp 2585470decc6SDave Kleikamp if (was_dirty) 2586470decc6SDave Kleikamp set_buffer_jbddirty(bh); 2587470decc6SDave Kleikamp } 2588470decc6SDave Kleikamp 2589470decc6SDave Kleikamp /* 2590de1b7941SJan Kara * __jbd2_journal_refile_buffer() with necessary locking added. We take our 2591de1b7941SJan Kara * bh reference so that we can safely unlock bh. 2592470decc6SDave Kleikamp * 2593de1b7941SJan Kara * The jh and bh may be freed by this call. 2594470decc6SDave Kleikamp */ 2595f7f4bccbSMingming Cao void jbd2_journal_refile_buffer(journal_t *journal, struct journal_head *jh) 2596470decc6SDave Kleikamp { 2597470decc6SDave Kleikamp struct buffer_head *bh = jh2bh(jh); 2598470decc6SDave Kleikamp 2599de1b7941SJan Kara /* Get reference so that buffer cannot be freed before we unlock it */ 2600de1b7941SJan Kara get_bh(bh); 2601470decc6SDave Kleikamp jbd_lock_bh_state(bh); 2602470decc6SDave Kleikamp spin_lock(&journal->j_list_lock); 2603f7f4bccbSMingming Cao __jbd2_journal_refile_buffer(jh); 2604470decc6SDave Kleikamp jbd_unlock_bh_state(bh); 2605470decc6SDave Kleikamp spin_unlock(&journal->j_list_lock); 2606470decc6SDave Kleikamp __brelse(bh); 2607470decc6SDave Kleikamp } 2608c851ed54SJan Kara 2609c851ed54SJan Kara /* 2610c851ed54SJan Kara * File inode in the inode list of the handle's transaction 2611c851ed54SJan Kara */ 261241617e1aSJan Kara static int jbd2_journal_file_inode(handle_t *handle, struct jbd2_inode *jinode, 26136ba0e7dcSRoss Zwisler unsigned long flags, loff_t start_byte, loff_t end_byte) 2614c851ed54SJan Kara { 2615c851ed54SJan Kara transaction_t *transaction = handle->h_transaction; 261641a5b913STheodore Ts'o journal_t *journal; 2617c851ed54SJan Kara 2618c851ed54SJan Kara if (is_handle_aborted(handle)) 261941a5b913STheodore Ts'o return -EROFS; 262041a5b913STheodore Ts'o journal = transaction->t_journal; 2621c851ed54SJan Kara 2622c851ed54SJan Kara jbd_debug(4, "Adding inode %lu, tid:%d\n", jinode->i_vfs_inode->i_ino, 2623c851ed54SJan Kara transaction->t_tid); 2624c851ed54SJan Kara 2625c851ed54SJan Kara spin_lock(&journal->j_list_lock); 262641617e1aSJan Kara jinode->i_flags |= flags; 26276ba0e7dcSRoss Zwisler 26286ba0e7dcSRoss Zwisler if (jinode->i_dirty_end) { 26296ba0e7dcSRoss Zwisler jinode->i_dirty_start = min(jinode->i_dirty_start, start_byte); 26306ba0e7dcSRoss Zwisler jinode->i_dirty_end = max(jinode->i_dirty_end, end_byte); 26316ba0e7dcSRoss Zwisler } else { 26326ba0e7dcSRoss Zwisler jinode->i_dirty_start = start_byte; 26336ba0e7dcSRoss Zwisler jinode->i_dirty_end = end_byte; 26346ba0e7dcSRoss Zwisler } 26356ba0e7dcSRoss Zwisler 263641617e1aSJan Kara /* Is inode already attached where we need it? */ 2637c851ed54SJan Kara if (jinode->i_transaction == transaction || 2638c851ed54SJan Kara jinode->i_next_transaction == transaction) 2639c851ed54SJan Kara goto done; 2640c851ed54SJan Kara 264181be12c8SJan Kara /* 264281be12c8SJan Kara * We only ever set this variable to 1 so the test is safe. Since 264381be12c8SJan Kara * t_need_data_flush is likely to be set, we do the test to save some 264481be12c8SJan Kara * cacheline bouncing 264581be12c8SJan Kara */ 264681be12c8SJan Kara if (!transaction->t_need_data_flush) 264781be12c8SJan Kara transaction->t_need_data_flush = 1; 2648c851ed54SJan Kara /* On some different transaction's list - should be 2649c851ed54SJan Kara * the committing one */ 2650c851ed54SJan Kara if (jinode->i_transaction) { 2651c851ed54SJan Kara J_ASSERT(jinode->i_next_transaction == NULL); 2652c851ed54SJan Kara J_ASSERT(jinode->i_transaction == 2653c851ed54SJan Kara journal->j_committing_transaction); 2654c851ed54SJan Kara jinode->i_next_transaction = transaction; 2655c851ed54SJan Kara goto done; 2656c851ed54SJan Kara } 2657c851ed54SJan Kara /* Not on any transaction list... */ 2658c851ed54SJan Kara J_ASSERT(!jinode->i_next_transaction); 2659c851ed54SJan Kara jinode->i_transaction = transaction; 2660c851ed54SJan Kara list_add(&jinode->i_list, &transaction->t_inode_list); 2661c851ed54SJan Kara done: 2662c851ed54SJan Kara spin_unlock(&journal->j_list_lock); 2663c851ed54SJan Kara 2664c851ed54SJan Kara return 0; 2665c851ed54SJan Kara } 2666c851ed54SJan Kara 26676ba0e7dcSRoss Zwisler int jbd2_journal_inode_ranged_write(handle_t *handle, 26686ba0e7dcSRoss Zwisler struct jbd2_inode *jinode, loff_t start_byte, loff_t length) 26696ba0e7dcSRoss Zwisler { 26706ba0e7dcSRoss Zwisler return jbd2_journal_file_inode(handle, jinode, 26716ba0e7dcSRoss Zwisler JI_WRITE_DATA | JI_WAIT_DATA, start_byte, 26726ba0e7dcSRoss Zwisler start_byte + length - 1); 26736ba0e7dcSRoss Zwisler } 26746ba0e7dcSRoss Zwisler 26756ba0e7dcSRoss Zwisler int jbd2_journal_inode_ranged_wait(handle_t *handle, struct jbd2_inode *jinode, 26766ba0e7dcSRoss Zwisler loff_t start_byte, loff_t length) 26776ba0e7dcSRoss Zwisler { 26786ba0e7dcSRoss Zwisler return jbd2_journal_file_inode(handle, jinode, JI_WAIT_DATA, 26796ba0e7dcSRoss Zwisler start_byte, start_byte + length - 1); 268041617e1aSJan Kara } 268141617e1aSJan Kara 2682c851ed54SJan Kara /* 26837f5aa215SJan Kara * File truncate and transaction commit interact with each other in a 26847f5aa215SJan Kara * non-trivial way. If a transaction writing data block A is 26857f5aa215SJan Kara * committing, we cannot discard the data by truncate until we have 26867f5aa215SJan Kara * written them. Otherwise if we crashed after the transaction with 26877f5aa215SJan Kara * write has committed but before the transaction with truncate has 26887f5aa215SJan Kara * committed, we could see stale data in block A. This function is a 26897f5aa215SJan Kara * helper to solve this problem. It starts writeout of the truncated 26907f5aa215SJan Kara * part in case it is in the committing transaction. 26917f5aa215SJan Kara * 26927f5aa215SJan Kara * Filesystem code must call this function when inode is journaled in 26937f5aa215SJan Kara * ordered mode before truncation happens and after the inode has been 26947f5aa215SJan Kara * placed on orphan list with the new inode size. The second condition 26957f5aa215SJan Kara * avoids the race that someone writes new data and we start 26967f5aa215SJan Kara * committing the transaction after this function has been called but 26977f5aa215SJan Kara * before a transaction for truncate is started (and furthermore it 26987f5aa215SJan Kara * allows us to optimize the case where the addition to orphan list 26997f5aa215SJan Kara * happens in the same transaction as write --- we don't have to write 27007f5aa215SJan Kara * any data in such case). 2701c851ed54SJan Kara */ 27027f5aa215SJan Kara int jbd2_journal_begin_ordered_truncate(journal_t *journal, 27037f5aa215SJan Kara struct jbd2_inode *jinode, 2704c851ed54SJan Kara loff_t new_size) 2705c851ed54SJan Kara { 27067f5aa215SJan Kara transaction_t *inode_trans, *commit_trans; 2707c851ed54SJan Kara int ret = 0; 2708c851ed54SJan Kara 27097f5aa215SJan Kara /* This is a quick check to avoid locking if not necessary */ 27107f5aa215SJan Kara if (!jinode->i_transaction) 2711c851ed54SJan Kara goto out; 27127f5aa215SJan Kara /* Locks are here just to force reading of recent values, it is 27137f5aa215SJan Kara * enough that the transaction was not committing before we started 27147f5aa215SJan Kara * a transaction adding the inode to orphan list */ 2715a931da6aSTheodore Ts'o read_lock(&journal->j_state_lock); 2716c851ed54SJan Kara commit_trans = journal->j_committing_transaction; 2717a931da6aSTheodore Ts'o read_unlock(&journal->j_state_lock); 27187f5aa215SJan Kara spin_lock(&journal->j_list_lock); 27197f5aa215SJan Kara inode_trans = jinode->i_transaction; 27207f5aa215SJan Kara spin_unlock(&journal->j_list_lock); 27217f5aa215SJan Kara if (inode_trans == commit_trans) { 27227f5aa215SJan Kara ret = filemap_fdatawrite_range(jinode->i_vfs_inode->i_mapping, 2723c851ed54SJan Kara new_size, LLONG_MAX); 2724c851ed54SJan Kara if (ret) 2725c851ed54SJan Kara jbd2_journal_abort(journal, ret); 2726c851ed54SJan Kara } 2727c851ed54SJan Kara out: 2728c851ed54SJan Kara return ret; 2729c851ed54SJan Kara } 2730