f51667685749e (Theodore Ts'o 2017-12-17 22:00:59 -0500 1) // SPDX-License-Identifier: GPL-2.0+
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2) /*
5886269962f94 (Uwe Kleine-König 2007-05-09 07:51:49 +0200 3) * linux/fs/jbd2/transaction.c
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 4) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 5) * Written by Stephen C. Tweedie <sct@redhat.com>, 1998
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 6) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 7) * Copyright 1998 Red Hat corp --- All Rights Reserved
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 8) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 9) * Generic filesystem transaction handling code; part of the ext2fs
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 10) * journaling system.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 11) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 12) * This file manages transactions (compound commits managed by the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 13) * journaling code) and handles (individual atomic operations by the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 14) * filesystem).
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 15) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 16)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 17) #include <linux/time.h>
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 18) #include <linux/fs.h>
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 19) #include <linux/jbd2.h>
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 20) #include <linux/errno.h>
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 21) #include <linux/slab.h>
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 22) #include <linux/timer.h>
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 23) #include <linux/mm.h>
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 24) #include <linux/highmem.h>
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 25) #include <linux/hrtimer.h>
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 26) #include <linux/backing-dev.h>
44705754610db (Randy Dunlap 2011-10-27 04:05:13 -0400 27) #include <linux/bug.h>
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 28) #include <linux/module.h>
81378da64de6d (Michal Hocko 2017-05-03 14:53:22 -0700 29) #include <linux/sched/mm.h>
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 30)
343d9c283c984 (Theodore Ts'o 2013-02-08 13:00:22 -0500 31) #include <trace/events/jbd2.h>
343d9c283c984 (Theodore Ts'o 2013-02-08 13:00:22 -0500 32)
7ddae86095794 (Adrian Bunk 2006-12-06 20:38:27 -0800 33) static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh);
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 34) static void __jbd2_journal_unfile_buffer(struct journal_head *jh);
7ddae86095794 (Adrian Bunk 2006-12-06 20:38:27 -0800 35)
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 36) static struct kmem_cache *transaction_cache;
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 37) int __init jbd2_journal_init_transaction_cache(void)
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 38) {
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 39) J_ASSERT(!transaction_cache);
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 40) transaction_cache = kmem_cache_create("jbd2_transaction_s",
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 41) sizeof(transaction_t),
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 42) 0,
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 43) SLAB_HWCACHE_ALIGN|SLAB_TEMPORARY,
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 44) NULL);
0d52154bb0a70 (Chengguang Xu 2019-05-10 21:15:47 -0400 45) if (!transaction_cache) {
0d52154bb0a70 (Chengguang Xu 2019-05-10 21:15:47 -0400 46) pr_emerg("JBD2: failed to create transaction cache\n");
0d52154bb0a70 (Chengguang Xu 2019-05-10 21:15:47 -0400 47) return -ENOMEM;
0d52154bb0a70 (Chengguang Xu 2019-05-10 21:15:47 -0400 48) }
0d52154bb0a70 (Chengguang Xu 2019-05-10 21:15:47 -0400 49) return 0;
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 50) }
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 51)
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 52) void jbd2_journal_destroy_transaction_cache(void)
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 53) {
8bdd5b60e0273 (Wang Long 2018-05-20 22:38:26 -0400 54) kmem_cache_destroy(transaction_cache);
8bdd5b60e0273 (Wang Long 2018-05-20 22:38:26 -0400 55) transaction_cache = NULL;
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 56) }
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 57)
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 58) void jbd2_journal_free_transaction(transaction_t *transaction)
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 59) {
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 60) if (unlikely(ZERO_OR_NULL_PTR(transaction)))
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 61) return;
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 62) kmem_cache_free(transaction_cache, transaction);
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 63) }
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 64)
9f356e5a4f120 (Jan Kara 2019-11-05 17:44:24 +0100 65) /*
19014d697147c (Jan Kara 2019-11-05 17:44:31 +0100 66) * Base amount of descriptor blocks we reserve for each transaction.
9f356e5a4f120 (Jan Kara 2019-11-05 17:44:24 +0100 67) */
9f356e5a4f120 (Jan Kara 2019-11-05 17:44:24 +0100 68) static int jbd2_descriptor_blocks_per_trans(journal_t *journal)
9f356e5a4f120 (Jan Kara 2019-11-05 17:44:24 +0100 69) {
19014d697147c (Jan Kara 2019-11-05 17:44:31 +0100 70) int tag_space = journal->j_blocksize - sizeof(journal_header_t);
19014d697147c (Jan Kara 2019-11-05 17:44:31 +0100 71) int tags_per_block;
19014d697147c (Jan Kara 2019-11-05 17:44:31 +0100 72)
19014d697147c (Jan Kara 2019-11-05 17:44:31 +0100 73) /* Subtract UUID */
19014d697147c (Jan Kara 2019-11-05 17:44:31 +0100 74) tag_space -= 16;
19014d697147c (Jan Kara 2019-11-05 17:44:31 +0100 75) if (jbd2_journal_has_csum_v2or3(journal))
19014d697147c (Jan Kara 2019-11-05 17:44:31 +0100 76) tag_space -= sizeof(struct jbd2_journal_block_tail);
19014d697147c (Jan Kara 2019-11-05 17:44:31 +0100 77) /* Commit code leaves a slack space of 16 bytes at the end of block */
19014d697147c (Jan Kara 2019-11-05 17:44:31 +0100 78) tags_per_block = (tag_space - 16) / journal_tag_bytes(journal);
19014d697147c (Jan Kara 2019-11-05 17:44:31 +0100 79) /*
19014d697147c (Jan Kara 2019-11-05 17:44:31 +0100 80) * Revoke descriptors are accounted separately so we need to reserve
19014d697147c (Jan Kara 2019-11-05 17:44:31 +0100 81) * space for commit block and normal transaction descriptor blocks.
19014d697147c (Jan Kara 2019-11-05 17:44:31 +0100 82) */
19014d697147c (Jan Kara 2019-11-05 17:44:31 +0100 83) return 1 + DIV_ROUND_UP(journal->j_max_transaction_buffers,
19014d697147c (Jan Kara 2019-11-05 17:44:31 +0100 84) tags_per_block);
9f356e5a4f120 (Jan Kara 2019-11-05 17:44:24 +0100 85) }
9f356e5a4f120 (Jan Kara 2019-11-05 17:44:24 +0100 86)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 87) /*
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 88) * jbd2_get_transaction: obtain a new transaction_t object.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 89) *
0df6f46995a9f (Liu Song 2019-03-01 00:36:57 -0500 90) * Simply initialise a new transaction. Initialize it in
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 91) * RUNNING state and add it to the current journal (which should not
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 92) * have an existing running transaction: we only make a new transaction
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 93) * once we have started to commit the old one).
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 94) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 95) * Preconditions:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 96) * The journal MUST be locked. We don't perform atomic mallocs on the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 97) * new transaction and we can't block without protecting against other
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 98) * processes trying to touch the journal while it is in transition.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 99) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 100) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 101)
0df6f46995a9f (Liu Song 2019-03-01 00:36:57 -0500 102) static void jbd2_get_transaction(journal_t *journal,
0df6f46995a9f (Liu Song 2019-03-01 00:36:57 -0500 103) transaction_t *transaction)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 104) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 105) transaction->t_journal = journal;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 106) transaction->t_state = T_RUNNING;
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 107) transaction->t_start_time = ktime_get();
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 108) transaction->t_tid = journal->j_transaction_sequence++;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 109) transaction->t_expires = jiffies + journal->j_commit_interval;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 110) spin_lock_init(&transaction->t_handle_lock);
a51dca9cd3bb4 (Theodore Ts'o 2010-08-02 08:43:25 -0400 111) atomic_set(&transaction->t_updates, 0);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 112) atomic_set(&transaction->t_outstanding_credits,
9f356e5a4f120 (Jan Kara 2019-11-05 17:44:24 +0100 113) jbd2_descriptor_blocks_per_trans(journal) +
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 114) atomic_read(&journal->j_reserved_credits));
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 115) atomic_set(&transaction->t_outstanding_revokes, 0);
8dd420466c7bf (Theodore Ts'o 2010-08-03 21:38:29 -0400 116) atomic_set(&transaction->t_handle_count, 0);
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 117) INIT_LIST_HEAD(&transaction->t_inode_list);
3e624fc72fba0 (Theodore Ts'o 2008-10-16 20:00:24 -0400 118) INIT_LIST_HEAD(&transaction->t_private_list);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 119)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 120) /* Set up the commit timer for the new transaction. */
b1f485f20eb9b (Andreas Dilger 2009-08-10 22:51:53 -0400 121) journal->j_commit_timer.expires = round_jiffies_up(transaction->t_expires);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 122) add_timer(&journal->j_commit_timer);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 123)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 124) J_ASSERT(journal->j_running_transaction == NULL);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 125) journal->j_running_transaction = transaction;
8e85fb3f305b2 (Johann Lombardi 2008-01-28 23:58:27 -0500 126) transaction->t_max_wait = 0;
8e85fb3f305b2 (Johann Lombardi 2008-01-28 23:58:27 -0500 127) transaction->t_start = jiffies;
9fff24aa2c5c5 (Theodore Ts'o 2013-02-06 22:30:23 -0500 128) transaction->t_requested = 0;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 129) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 130)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 131) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 132) * Handle management.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 133) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 134) * A handle_t is an object which represents a single atomic update to a
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 135) * filesystem, and which tracks all of the modifications which form part
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 136) * of that one update.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 137) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 138)
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 139) /*
28e35e42fb255 (Tao Ma 2011-05-22 21:45:26 -0400 140) * Update transaction's maximum wait time, if debugging is enabled.
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 141) *
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 142) * In order for t_max_wait to be reliable, it must be protected by a
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 143) * lock. But doing so will mean that start_this_handle() can not be
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 144) * run in parallel on SMP systems, which limits our scalability. So
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 145) * unless debugging is enabled, we no longer update t_max_wait, which
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 146) * means that maximum wait time reported by the jbd2_run_stats
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 147) * tracepoint will always be zero.
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 148) */
28e35e42fb255 (Tao Ma 2011-05-22 21:45:26 -0400 149) static inline void update_t_max_wait(transaction_t *transaction,
28e35e42fb255 (Tao Ma 2011-05-22 21:45:26 -0400 150) unsigned long ts)
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 151) {
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 152) #ifdef CONFIG_JBD2_DEBUG
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 153) if (jbd2_journal_enable_debug &&
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 154) time_after(transaction->t_start, ts)) {
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 155) ts = jbd2_time_diff(ts, transaction->t_start);
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 156) spin_lock(&transaction->t_handle_lock);
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 157) if (ts > transaction->t_max_wait)
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 158) transaction->t_max_wait = ts;
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 159) spin_unlock(&transaction->t_handle_lock);
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 160) }
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 161) #endif
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 162) }
6d0bf00512b3b (Theodore Ts'o 2010-08-09 17:28:38 -0400 163)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 164) /*
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 165) * Wait until running transaction passes to T_FLUSH state and new transaction
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 166) * can thus be started. Also starts the commit if needed. The function expects
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 167) * running transaction to exist and releases j_state_lock.
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 168) */
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 169) static void wait_transaction_locked(journal_t *journal)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 170) __releases(journal->j_state_lock)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 171) {
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 172) DEFINE_WAIT(wait);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 173) int need_to_start;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 174) tid_t tid = journal->j_running_transaction->t_tid;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 175)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 176) prepare_to_wait(&journal->j_wait_transaction_locked, &wait,
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 177) TASK_UNINTERRUPTIBLE);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 178) need_to_start = !tid_geq(journal->j_commit_request, tid);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 179) read_unlock(&journal->j_state_lock);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 180) if (need_to_start)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 181) jbd2_log_start_commit(journal, tid);
e03a9976afce6 (Jan Kara 2016-09-22 11:44:06 -0400 182) jbd2_might_wait_for_commit(journal);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 183) schedule();
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 184) finish_wait(&journal->j_wait_transaction_locked, &wait);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 185) }
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 186)
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 187) /*
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 188) * Wait until running transaction transitions from T_SWITCH to T_FLUSH
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 189) * state and new transaction can thus be started. The function releases
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 190) * j_state_lock.
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 191) */
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 192) static void wait_transaction_switching(journal_t *journal)
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 193) __releases(journal->j_state_lock)
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 194) {
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 195) DEFINE_WAIT(wait);
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 196)
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 197) if (WARN_ON(!journal->j_running_transaction ||
05d5233df85e9 (Theodore Ts'o 2020-11-07 00:00:49 -0500 198) journal->j_running_transaction->t_state != T_SWITCH)) {
05d5233df85e9 (Theodore Ts'o 2020-11-07 00:00:49 -0500 199) read_unlock(&journal->j_state_lock);
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 200) return;
05d5233df85e9 (Theodore Ts'o 2020-11-07 00:00:49 -0500 201) }
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 202) prepare_to_wait(&journal->j_wait_transaction_locked, &wait,
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 203) TASK_UNINTERRUPTIBLE);
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 204) read_unlock(&journal->j_state_lock);
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 205) /*
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 206) * We don't call jbd2_might_wait_for_commit() here as there's no
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 207) * waiting for outstanding handles happening anymore in T_SWITCH state
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 208) * and handling of reserved handles actually relies on that for
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 209) * correctness.
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 210) */
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 211) schedule();
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 212) finish_wait(&journal->j_wait_transaction_locked, &wait);
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 213) }
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 214)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 215) static void sub_reserved_credits(journal_t *journal, int blocks)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 216) {
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 217) atomic_sub(blocks, &journal->j_reserved_credits);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 218) wake_up(&journal->j_wait_reserved);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 219) }
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 220)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 221) /*
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 222) * Wait until we can add credits for handle to the running transaction. Called
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 223) * with j_state_lock held for reading. Returns 0 if handle joined the running
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 224) * transaction. Returns 1 if we had to wait, j_state_lock is dropped, and
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 225) * caller must retry.
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 226) */
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 227) static int add_transaction_credits(journal_t *journal, int blocks,
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 228) int rsv_blocks)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 229) {
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 230) transaction_t *t = journal->j_running_transaction;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 231) int needed;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 232) int total = blocks + rsv_blocks;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 233)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 234) /*
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 235) * If the current transaction is locked down for commit, wait
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 236) * for the lock to be released.
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 237) */
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 238) if (t->t_state != T_RUNNING) {
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 239) WARN_ON_ONCE(t->t_state >= T_FLUSH);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 240) wait_transaction_locked(journal);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 241) return 1;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 242) }
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 243)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 244) /*
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 245) * If there is not enough space left in the log to write all
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 246) * potential buffers requested by this operation, we need to
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 247) * stall pending a log checkpoint to free some more log space.
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 248) */
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 249) needed = atomic_add_return(total, &t->t_outstanding_credits);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 250) if (needed > journal->j_max_transaction_buffers) {
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 251) /*
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 252) * If the current transaction is already too large,
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 253) * then start to commit it: we can then go back and
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 254) * attach this handle to a new transaction.
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 255) */
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 256) atomic_sub(total, &t->t_outstanding_credits);
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 257)
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 258) /*
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 259) * Is the number of reserved credits in the current transaction too
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 260) * big to fit this handle? Wait until reserved credits are freed.
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 261) */
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 262) if (atomic_read(&journal->j_reserved_credits) + total >
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 263) journal->j_max_transaction_buffers) {
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 264) read_unlock(&journal->j_state_lock);
e03a9976afce6 (Jan Kara 2016-09-22 11:44:06 -0400 265) jbd2_might_wait_for_commit(journal);
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 266) wait_event(journal->j_wait_reserved,
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 267) atomic_read(&journal->j_reserved_credits) + total <=
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 268) journal->j_max_transaction_buffers);
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 269) return 1;
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 270) }
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 271)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 272) wait_transaction_locked(journal);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 273) return 1;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 274) }
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 275)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 276) /*
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 277) * The commit code assumes that it can get enough log space
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 278) * without forcing a checkpoint. This is *critical* for
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 279) * correctness: a checkpoint of a buffer which is also
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 280) * associated with a committing transaction creates a deadlock,
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 281) * so commit simply cannot force through checkpoints.
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 282) *
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 283) * We must therefore ensure the necessary space in the journal
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 284) * *before* starting to dirty potentially checkpointed buffers
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 285) * in the new transaction.
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 286) */
77444ac4f9537 (Jan Kara 2019-11-05 17:44:25 +0100 287) if (jbd2_log_space_left(journal) < journal->j_max_transaction_buffers) {
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 288) atomic_sub(total, &t->t_outstanding_credits);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 289) read_unlock(&journal->j_state_lock);
e03a9976afce6 (Jan Kara 2016-09-22 11:44:06 -0400 290) jbd2_might_wait_for_commit(journal);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 291) write_lock(&journal->j_state_lock);
77444ac4f9537 (Jan Kara 2019-11-05 17:44:25 +0100 292) if (jbd2_log_space_left(journal) <
77444ac4f9537 (Jan Kara 2019-11-05 17:44:25 +0100 293) journal->j_max_transaction_buffers)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 294) __jbd2_log_wait_for_space(journal);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 295) write_unlock(&journal->j_state_lock);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 296) return 1;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 297) }
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 298)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 299) /* No reservation? We are done... */
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 300) if (!rsv_blocks)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 301) return 0;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 302)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 303) needed = atomic_add_return(rsv_blocks, &journal->j_reserved_credits);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 304) /* We allow at most half of a transaction to be reserved */
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 305) if (needed > journal->j_max_transaction_buffers / 2) {
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 306) sub_reserved_credits(journal, rsv_blocks);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 307) atomic_sub(total, &t->t_outstanding_credits);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 308) read_unlock(&journal->j_state_lock);
e03a9976afce6 (Jan Kara 2016-09-22 11:44:06 -0400 309) jbd2_might_wait_for_commit(journal);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 310) wait_event(journal->j_wait_reserved,
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 311) atomic_read(&journal->j_reserved_credits) + rsv_blocks
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 312) <= journal->j_max_transaction_buffers / 2);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 313) return 1;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 314) }
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 315) return 0;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 316) }
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 317)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 318) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 319) * start_this_handle: Given a handle, deal with any locking or stalling
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 320) * needed to make sure that there is enough journal space for the handle
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 321) * to begin. Attach the handle to a transaction and set up the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 322) * transaction's buffer credits.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 323) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 324)
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 325) static int start_this_handle(journal_t *journal, handle_t *handle,
d2159fb7b8bac (Dan Carpenter 2011-09-04 10:20:14 -0400 326) gfp_t gfp_mask)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 327) {
e44718318004a (Theodore Ts'o 2011-02-12 08:18:24 -0500 328) transaction_t *transaction, *new_transaction = NULL;
933f1c1e0b75b (Jan Kara 2019-11-05 17:44:27 +0100 329) int blocks = handle->h_total_credits;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 330) int rsv_blocks = 0;
28e35e42fb255 (Tao Ma 2011-05-22 21:45:26 -0400 331) unsigned long ts = jiffies;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 332)
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 333) if (handle->h_rsv_handle)
933f1c1e0b75b (Jan Kara 2019-11-05 17:44:27 +0100 334) rsv_blocks = handle->h_rsv_handle->h_total_credits;
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 335)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 336) /*
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 337) * Limit the number of reserved credits to 1/2 of maximum transaction
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 338) * size and limit the number of total credits to not exceed maximum
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 339) * transaction size per operation.
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 340) */
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 341) if ((rsv_blocks > journal->j_max_transaction_buffers / 2) ||
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 342) (rsv_blocks + blocks > journal->j_max_transaction_buffers)) {
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 343) printk(KERN_ERR "JBD2: %s wants too many credits "
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 344) "credits:%d rsv_credits:%d max:%d\n",
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 345) current->comm, blocks, rsv_blocks,
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 346) journal->j_max_transaction_buffers);
6d3ec14d703c6 (Lukas Czerner 2015-08-04 11:21:52 -0400 347) WARN_ON(1);
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 348) return -ENOSPC;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 349) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 350)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 351) alloc_transaction:
3b1833e92baba (Jan Kara 2021-04-06 18:17:59 +0200 352) /*
3b1833e92baba (Jan Kara 2021-04-06 18:17:59 +0200 353) * This check is racy but it is just an optimization of allocating new
3b1833e92baba (Jan Kara 2021-04-06 18:17:59 +0200 354) * transaction early if there are high chances we'll need it. If we
3b1833e92baba (Jan Kara 2021-04-06 18:17:59 +0200 355) * guess wrong, we'll retry or free unused transaction.
3b1833e92baba (Jan Kara 2021-04-06 18:17:59 +0200 356) */
3b1833e92baba (Jan Kara 2021-04-06 18:17:59 +0200 357) if (!data_race(journal->j_running_transaction)) {
6ccaf3e2f302b (Michal Hocko 2015-06-08 10:53:10 -0400 358) /*
6ccaf3e2f302b (Michal Hocko 2015-06-08 10:53:10 -0400 359) * If __GFP_FS is not present, then we may be being called from
6ccaf3e2f302b (Michal Hocko 2015-06-08 10:53:10 -0400 360) * inside the fs writeback layer, so we MUST NOT fail.
6ccaf3e2f302b (Michal Hocko 2015-06-08 10:53:10 -0400 361) */
6ccaf3e2f302b (Michal Hocko 2015-06-08 10:53:10 -0400 362) if ((gfp_mask & __GFP_FS) == 0)
6ccaf3e2f302b (Michal Hocko 2015-06-08 10:53:10 -0400 363) gfp_mask |= __GFP_NOFAIL;
b2f4edb335f23 (Wanlong Gao 2012-06-01 00:10:32 -0400 364) new_transaction = kmem_cache_zalloc(transaction_cache,
b2f4edb335f23 (Wanlong Gao 2012-06-01 00:10:32 -0400 365) gfp_mask);
6ccaf3e2f302b (Michal Hocko 2015-06-08 10:53:10 -0400 366) if (!new_transaction)
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 367) return -ENOMEM;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 368) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 369)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 370) jbd_debug(3, "New handle %p going live.\n", handle);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 371)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 372) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 373) * We need to hold j_state_lock until t_updates has been incremented,
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 374) * for proper journal barrier handling
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 375) */
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 376) repeat:
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 377) read_lock(&journal->j_state_lock);
5c2178e785244 (Theodore Ts'o 2010-10-27 21:30:04 -0400 378) BUG_ON(journal->j_flags & JBD2_UNMOUNT);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 379) if (is_journal_aborted(journal) ||
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 380) (journal->j_errno != 0 && !(journal->j_flags & JBD2_ACK_ERR))) {
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 381) read_unlock(&journal->j_state_lock);
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 382) jbd2_journal_free_transaction(new_transaction);
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 383) return -EROFS;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 384) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 385)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 386) /*
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 387) * Wait on the journal's transaction barrier if necessary. Specifically
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 388) * we allow reserved handles to proceed because otherwise commit could
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 389) * deadlock on page writeback not being able to complete.
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 390) */
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 391) if (!handle->h_reserved && journal->j_barrier_count) {
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 392) read_unlock(&journal->j_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 393) wait_event(journal->j_wait_transaction_locked,
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 394) journal->j_barrier_count == 0);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 395) goto repeat;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 396) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 397)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 398) if (!journal->j_running_transaction) {
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 399) read_unlock(&journal->j_state_lock);
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 400) if (!new_transaction)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 401) goto alloc_transaction;
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 402) write_lock(&journal->j_state_lock);
d7961c7fa4d2e (Jan Kara 2012-12-21 00:15:51 -0500 403) if (!journal->j_running_transaction &&
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 404) (handle->h_reserved || !journal->j_barrier_count)) {
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 405) jbd2_get_transaction(journal, new_transaction);
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 406) new_transaction = NULL;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 407) }
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 408) write_unlock(&journal->j_state_lock);
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 409) goto repeat;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 410) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 411)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 412) transaction = journal->j_running_transaction;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 413)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 414) if (!handle->h_reserved) {
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 415) /* We may have dropped j_state_lock - restart in that case */
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 416) if (add_transaction_credits(journal, blocks, rsv_blocks))
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 417) goto repeat;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 418) } else {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 419) /*
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 420) * We have handle reserved so we are allowed to join T_LOCKED
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 421) * transaction and we don't have to check for transaction size
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 422) * and journal space. But we still have to wait while running
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 423) * transaction is being switched to a committing one as it
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 424) * won't wait for any handles anymore.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 425) */
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 426) if (transaction->t_state == T_SWITCH) {
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 427) wait_transaction_switching(journal);
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 428) goto repeat;
96f1e09745750 (Jan Kara 2018-12-03 23:16:07 -0500 429) }
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 430) sub_reserved_credits(journal, blocks);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 431) handle->h_reserved = 0;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 432) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 433)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 434) /* OK, account for the buffers that this operation expects to
8dd420466c7bf (Theodore Ts'o 2010-08-03 21:38:29 -0400 435) * use and add the handle to the running transaction.
8dd420466c7bf (Theodore Ts'o 2010-08-03 21:38:29 -0400 436) */
28e35e42fb255 (Tao Ma 2011-05-22 21:45:26 -0400 437) update_t_max_wait(transaction, ts);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 438) handle->h_transaction = transaction;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 439) handle->h_requested_credits = blocks;
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 440) handle->h_revoke_credits_requested = handle->h_revoke_credits;
343d9c283c984 (Theodore Ts'o 2013-02-08 13:00:22 -0500 441) handle->h_start_jiffies = jiffies;
a51dca9cd3bb4 (Theodore Ts'o 2010-08-02 08:43:25 -0400 442) atomic_inc(&transaction->t_updates);
8dd420466c7bf (Theodore Ts'o 2010-08-03 21:38:29 -0400 443) atomic_inc(&transaction->t_handle_count);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 444) jbd_debug(4, "Handle %p given %d credits (total %d, free %lu)\n",
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 445) handle, blocks,
a51dca9cd3bb4 (Theodore Ts'o 2010-08-02 08:43:25 -0400 446) atomic_read(&transaction->t_outstanding_credits),
76c3990456100 (Jan Kara 2013-06-04 12:12:57 -0400 447) jbd2_log_space_left(journal));
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 448) read_unlock(&journal->j_state_lock);
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 449) current->journal_info = handle;
9599b0e597d81 (Jan Kara 2009-08-17 21:23:17 -0400 450)
ab714aff4f744 (Jan Kara 2016-06-30 11:39:38 -0400 451) rwsem_acquire_read(&journal->j_trans_commit_map, 0, 0, _THIS_IP_);
0c2022eccb016 (Yongqiang Yang 2012-02-20 17:53:02 -0500 452) jbd2_journal_free_transaction(new_transaction);
81378da64de6d (Michal Hocko 2017-05-03 14:53:22 -0700 453) /*
81378da64de6d (Michal Hocko 2017-05-03 14:53:22 -0700 454) * Ensure that no allocations done while the transaction is open are
81378da64de6d (Michal Hocko 2017-05-03 14:53:22 -0700 455) * going to recurse back to the fs layer.
81378da64de6d (Michal Hocko 2017-05-03 14:53:22 -0700 456) */
81378da64de6d (Michal Hocko 2017-05-03 14:53:22 -0700 457) handle->saved_alloc_context = memalloc_nofs_save();
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 458) return 0;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 459) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 460)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 461) /* Allocate a new handle. This should probably be in a slab... */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 462) static handle_t *new_handle(int nblocks)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 463) {
af1e76d6b3f37 (Mingming Cao 2007-10-16 18:38:25 -0400 464) handle_t *handle = jbd2_alloc_handle(GFP_NOFS);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 465) if (!handle)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 466) return NULL;
933f1c1e0b75b (Jan Kara 2019-11-05 17:44:27 +0100 467) handle->h_total_credits = nblocks;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 468) handle->h_ref = 1;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 469)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 470) return handle;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 471) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 472)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 473) handle_t *jbd2__journal_start(journal_t *journal, int nblocks, int rsv_blocks,
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 474) int revoke_records, gfp_t gfp_mask,
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 475) unsigned int type, unsigned int line_no)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 476) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 477) handle_t *handle = journal_current_handle();
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 478) int err;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 479)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 480) if (!journal)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 481) return ERR_PTR(-EROFS);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 482)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 483) if (handle) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 484) J_ASSERT(handle->h_transaction->t_journal == journal);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 485) handle->h_ref++;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 486) return handle;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 487) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 488)
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 489) nblocks += DIV_ROUND_UP(revoke_records,
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 490) journal->j_revoke_records_per_block);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 491) handle = new_handle(nblocks);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 492) if (!handle)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 493) return ERR_PTR(-ENOMEM);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 494) if (rsv_blocks) {
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 495) handle_t *rsv_handle;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 496)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 497) rsv_handle = new_handle(rsv_blocks);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 498) if (!rsv_handle) {
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 499) jbd2_free_handle(handle);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 500) return ERR_PTR(-ENOMEM);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 501) }
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 502) rsv_handle->h_reserved = 1;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 503) rsv_handle->h_journal = journal;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 504) handle->h_rsv_handle = rsv_handle;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 505) }
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 506) handle->h_revoke_credits = revoke_records;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 507)
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 508) err = start_this_handle(journal, handle, gfp_mask);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 509) if (err < 0) {
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 510) if (handle->h_rsv_handle)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 511) jbd2_free_handle(handle->h_rsv_handle);
af1e76d6b3f37 (Mingming Cao 2007-10-16 18:38:25 -0400 512) jbd2_free_handle(handle);
df05c1b85a888 (Dmitry Monakhov 2013-03-02 17:08:46 -0500 513) return ERR_PTR(err);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 514) }
343d9c283c984 (Theodore Ts'o 2013-02-08 13:00:22 -0500 515) handle->h_type = type;
343d9c283c984 (Theodore Ts'o 2013-02-08 13:00:22 -0500 516) handle->h_line_no = line_no;
343d9c283c984 (Theodore Ts'o 2013-02-08 13:00:22 -0500 517) trace_jbd2_handle_start(journal->j_fs_dev->bd_dev,
343d9c283c984 (Theodore Ts'o 2013-02-08 13:00:22 -0500 518) handle->h_transaction->t_tid, type,
343d9c283c984 (Theodore Ts'o 2013-02-08 13:00:22 -0500 519) line_no, nblocks);
81378da64de6d (Michal Hocko 2017-05-03 14:53:22 -0700 520)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 521) return handle;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 522) }
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 523) EXPORT_SYMBOL(jbd2__journal_start);
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 524)
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 525)
91e4775d0fe30 (Mauro Carvalho Chehab 2017-05-12 07:25:21 -0300 526) /**
2bf31d94423c8 (Mauro Carvalho Chehab 2020-11-16 11:18:08 +0100 527) * jbd2_journal_start() - Obtain a new handle.
91e4775d0fe30 (Mauro Carvalho Chehab 2017-05-12 07:25:21 -0300 528) * @journal: Journal to start transaction on.
91e4775d0fe30 (Mauro Carvalho Chehab 2017-05-12 07:25:21 -0300 529) * @nblocks: number of block buffer we might modify
91e4775d0fe30 (Mauro Carvalho Chehab 2017-05-12 07:25:21 -0300 530) *
91e4775d0fe30 (Mauro Carvalho Chehab 2017-05-12 07:25:21 -0300 531) * We make sure that the transaction can guarantee at least nblocks of
91e4775d0fe30 (Mauro Carvalho Chehab 2017-05-12 07:25:21 -0300 532) * modified buffers in the log. We block until the log can guarantee
91e4775d0fe30 (Mauro Carvalho Chehab 2017-05-12 07:25:21 -0300 533) * that much space. Additionally, if rsv_blocks > 0, we also create another
91e4775d0fe30 (Mauro Carvalho Chehab 2017-05-12 07:25:21 -0300 534) * handle with rsv_blocks reserved blocks in the journal. This handle is
0c1cba6cca862 (wangyan 2020-01-22 17:33:10 +0800 535) * stored in h_rsv_handle. It is not attached to any particular transaction
91e4775d0fe30 (Mauro Carvalho Chehab 2017-05-12 07:25:21 -0300 536) * and thus doesn't block transaction commit. If the caller uses this reserved
91e4775d0fe30 (Mauro Carvalho Chehab 2017-05-12 07:25:21 -0300 537) * handle, it has to set h_rsv_handle to NULL as otherwise jbd2_journal_stop()
91e4775d0fe30 (Mauro Carvalho Chehab 2017-05-12 07:25:21 -0300 538) * on the parent handle will dispose the reserved one. Reserved handle has to
91e4775d0fe30 (Mauro Carvalho Chehab 2017-05-12 07:25:21 -0300 539) * be converted to a normal handle using jbd2_journal_start_reserved() before
91e4775d0fe30 (Mauro Carvalho Chehab 2017-05-12 07:25:21 -0300 540) * it can be used.
91e4775d0fe30 (Mauro Carvalho Chehab 2017-05-12 07:25:21 -0300 541) *
91e4775d0fe30 (Mauro Carvalho Chehab 2017-05-12 07:25:21 -0300 542) * Return a pointer to a newly allocated handle, or an ERR_PTR() value
91e4775d0fe30 (Mauro Carvalho Chehab 2017-05-12 07:25:21 -0300 543) * on failure.
91e4775d0fe30 (Mauro Carvalho Chehab 2017-05-12 07:25:21 -0300 544) */
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 545) handle_t *jbd2_journal_start(journal_t *journal, int nblocks)
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 546) {
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 547) return jbd2__journal_start(journal, nblocks, 0, 0, GFP_NOFS, 0, 0);
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 548) }
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 549) EXPORT_SYMBOL(jbd2_journal_start);
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 550)
14ff6286309e2 (Jan Kara 2020-05-20 15:31:19 +0200 551) static void __jbd2_journal_unreserve_handle(handle_t *handle, transaction_t *t)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 552) {
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 553) journal_t *journal = handle->h_journal;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 554)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 555) WARN_ON(!handle->h_reserved);
933f1c1e0b75b (Jan Kara 2019-11-05 17:44:27 +0100 556) sub_reserved_credits(journal, handle->h_total_credits);
14ff6286309e2 (Jan Kara 2020-05-20 15:31:19 +0200 557) if (t)
14ff6286309e2 (Jan Kara 2020-05-20 15:31:19 +0200 558) atomic_sub(handle->h_total_credits, &t->t_outstanding_credits);
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 559) }
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 560)
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 561) void jbd2_journal_free_reserved(handle_t *handle)
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 562) {
14ff6286309e2 (Jan Kara 2020-05-20 15:31:19 +0200 563) journal_t *journal = handle->h_journal;
14ff6286309e2 (Jan Kara 2020-05-20 15:31:19 +0200 564)
14ff6286309e2 (Jan Kara 2020-05-20 15:31:19 +0200 565) /* Get j_state_lock to pin running transaction if it exists */
14ff6286309e2 (Jan Kara 2020-05-20 15:31:19 +0200 566) read_lock(&journal->j_state_lock);
14ff6286309e2 (Jan Kara 2020-05-20 15:31:19 +0200 567) __jbd2_journal_unreserve_handle(handle, journal->j_running_transaction);
14ff6286309e2 (Jan Kara 2020-05-20 15:31:19 +0200 568) read_unlock(&journal->j_state_lock);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 569) jbd2_free_handle(handle);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 570) }
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 571) EXPORT_SYMBOL(jbd2_journal_free_reserved);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 572)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 573) /**
2bf31d94423c8 (Mauro Carvalho Chehab 2020-11-16 11:18:08 +0100 574) * jbd2_journal_start_reserved() - start reserved handle
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 575) * @handle: handle to start
f69120ce6c024 (Tobin C. Harding 2018-01-10 00:27:29 -0500 576) * @type: for handle statistics
f69120ce6c024 (Tobin C. Harding 2018-01-10 00:27:29 -0500 577) * @line_no: for handle statistics
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 578) *
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 579) * Start handle that has been previously reserved with jbd2_journal_reserve().
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 580) * This attaches @handle to the running transaction (or creates one if there's
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 581) * not transaction running). Unlike jbd2_journal_start() this function cannot
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 582) * block on journal commit, checkpointing, or similar stuff. It can block on
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 583) * memory allocation or frozen journal though.
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 584) *
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 585) * Return 0 on success, non-zero on error - handle is freed in that case.
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 586) */
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 587) int jbd2_journal_start_reserved(handle_t *handle, unsigned int type,
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 588) unsigned int line_no)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 589) {
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 590) journal_t *journal = handle->h_journal;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 591) int ret = -EIO;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 592)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 593) if (WARN_ON(!handle->h_reserved)) {
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 594) /* Someone passed in normal handle? Just stop it. */
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 595) jbd2_journal_stop(handle);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 596) return ret;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 597) }
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 598) /*
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 599) * Usefulness of mixing of reserved and unreserved handles is
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 600) * questionable. So far nobody seems to need it so just error out.
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 601) */
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 602) if (WARN_ON(current->journal_info)) {
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 603) jbd2_journal_free_reserved(handle);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 604) return ret;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 605) }
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 606)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 607) handle->h_journal = NULL;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 608) /*
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 609) * GFP_NOFS is here because callers are likely from writeback or
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 610) * similarly constrained call sites
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 611) */
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 612) ret = start_this_handle(journal, handle, GFP_NOFS);
92e3b40537707 (Dan Carpenter 2014-02-17 20:33:01 -0500 613) if (ret < 0) {
b2569260d5522 (Theodore Ts'o 2018-04-18 11:49:31 -0400 614) handle->h_journal = journal;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 615) jbd2_journal_free_reserved(handle);
92e3b40537707 (Dan Carpenter 2014-02-17 20:33:01 -0500 616) return ret;
92e3b40537707 (Dan Carpenter 2014-02-17 20:33:01 -0500 617) }
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 618) handle->h_type = type;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 619) handle->h_line_no = line_no;
4c273352bb458 (Xiaoguang Wang 2019-08-24 23:10:17 -0400 620) trace_jbd2_handle_start(journal->j_fs_dev->bd_dev,
4c273352bb458 (Xiaoguang Wang 2019-08-24 23:10:17 -0400 621) handle->h_transaction->t_tid, type,
933f1c1e0b75b (Jan Kara 2019-11-05 17:44:27 +0100 622) line_no, handle->h_total_credits);
92e3b40537707 (Dan Carpenter 2014-02-17 20:33:01 -0500 623) return 0;
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 624) }
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 625) EXPORT_SYMBOL(jbd2_journal_start_reserved);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 626)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 627) /**
2bf31d94423c8 (Mauro Carvalho Chehab 2020-11-16 11:18:08 +0100 628) * jbd2_journal_extend() - extend buffer credits.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 629) * @handle: handle to 'extend'
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 630) * @nblocks: nr blocks to try to extend by.
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 631) * @revoke_records: number of revoke records to try to extend by.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 632) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 633) * Some transactions, such as large extends and truncates, can be done
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 634) * atomically all at once or in several stages. The operation requests
bd7ced98812db (Masanari Iida 2016-02-02 22:31:06 +0900 635) * a credit for a number of buffer modifications in advance, but can
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 636) * extend its credit if it needs more.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 637) *
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 638) * jbd2_journal_extend tries to give the running handle more buffer credits.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 639) * It does not guarantee that allocation - this is a best-effort only.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 640) * The calling process MUST be able to deal cleanly with a failure to
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 641) * extend here.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 642) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 643) * Return 0 on success, non-zero on failure.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 644) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 645) * return code < 0 implies an error
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 646) * return code > 0 implies normal transaction-full status.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 647) */
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 648) int jbd2_journal_extend(handle_t *handle, int nblocks, int revoke_records)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 649) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 650) transaction_t *transaction = handle->h_transaction;
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 651) journal_t *journal;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 652) int result;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 653) int wanted;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 654)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 655) if (is_handle_aborted(handle))
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 656) return -EROFS;
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 657) journal = transaction->t_journal;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 658)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 659) result = 1;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 660)
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 661) read_lock(&journal->j_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 662)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 663) /* Don't extend a locked-down transaction! */
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 664) if (transaction->t_state != T_RUNNING) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 665) jbd_debug(3, "denied handle %p %d blocks: "
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 666) "transaction not running\n", handle, nblocks);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 667) goto error_out;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 668) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 669)
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 670) nblocks += DIV_ROUND_UP(
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 671) handle->h_revoke_credits_requested + revoke_records,
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 672) journal->j_revoke_records_per_block) -
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 673) DIV_ROUND_UP(
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 674) handle->h_revoke_credits_requested,
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 675) journal->j_revoke_records_per_block);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 676) spin_lock(&transaction->t_handle_lock);
fe1e8db598b25 (Jan Kara 2013-06-04 12:22:15 -0400 677) wanted = atomic_add_return(nblocks,
fe1e8db598b25 (Jan Kara 2013-06-04 12:22:15 -0400 678) &transaction->t_outstanding_credits);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 679)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 680) if (wanted > journal->j_max_transaction_buffers) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 681) jbd_debug(3, "denied handle %p %d blocks: "
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 682) "transaction too large\n", handle, nblocks);
fe1e8db598b25 (Jan Kara 2013-06-04 12:22:15 -0400 683) atomic_sub(nblocks, &transaction->t_outstanding_credits);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 684) goto unlock;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 685) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 686)
343d9c283c984 (Theodore Ts'o 2013-02-08 13:00:22 -0500 687) trace_jbd2_handle_extend(journal->j_fs_dev->bd_dev,
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 688) transaction->t_tid,
343d9c283c984 (Theodore Ts'o 2013-02-08 13:00:22 -0500 689) handle->h_type, handle->h_line_no,
933f1c1e0b75b (Jan Kara 2019-11-05 17:44:27 +0100 690) handle->h_total_credits,
343d9c283c984 (Theodore Ts'o 2013-02-08 13:00:22 -0500 691) nblocks);
343d9c283c984 (Theodore Ts'o 2013-02-08 13:00:22 -0500 692)
933f1c1e0b75b (Jan Kara 2019-11-05 17:44:27 +0100 693) handle->h_total_credits += nblocks;
343d9c283c984 (Theodore Ts'o 2013-02-08 13:00:22 -0500 694) handle->h_requested_credits += nblocks;
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 695) handle->h_revoke_credits += revoke_records;
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 696) handle->h_revoke_credits_requested += revoke_records;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 697) result = 0;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 698)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 699) jbd_debug(3, "extended handle %p by %d\n", handle, nblocks);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 700) unlock:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 701) spin_unlock(&transaction->t_handle_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 702) error_out:
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 703) read_unlock(&journal->j_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 704) return result;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 705) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 706)
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 707) static void stop_this_handle(handle_t *handle)
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 708) {
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 709) transaction_t *transaction = handle->h_transaction;
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 710) journal_t *journal = transaction->t_journal;
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 711) int revokes;
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 712)
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 713) J_ASSERT(journal_current_handle() == handle);
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 714) J_ASSERT(atomic_read(&transaction->t_updates) > 0);
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 715) current->journal_info = NULL;
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 716) /*
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 717) * Subtract necessary revoke descriptor blocks from handle credits. We
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 718) * take care to account only for revoke descriptor blocks the
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 719) * transaction will really need as large sequences of transactions with
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 720) * small numbers of revokes are relatively common.
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 721) */
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 722) revokes = handle->h_revoke_credits_requested - handle->h_revoke_credits;
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 723) if (revokes) {
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 724) int t_revokes, revoke_descriptors;
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 725) int rr_per_blk = journal->j_revoke_records_per_block;
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 726)
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 727) WARN_ON_ONCE(DIV_ROUND_UP(revokes, rr_per_blk)
933f1c1e0b75b (Jan Kara 2019-11-05 17:44:27 +0100 728) > handle->h_total_credits);
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 729) t_revokes = atomic_add_return(revokes,
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 730) &transaction->t_outstanding_revokes);
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 731) revoke_descriptors =
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 732) DIV_ROUND_UP(t_revokes, rr_per_blk) -
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 733) DIV_ROUND_UP(t_revokes - revokes, rr_per_blk);
933f1c1e0b75b (Jan Kara 2019-11-05 17:44:27 +0100 734) handle->h_total_credits -= revoke_descriptors;
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 735) }
933f1c1e0b75b (Jan Kara 2019-11-05 17:44:27 +0100 736) atomic_sub(handle->h_total_credits,
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 737) &transaction->t_outstanding_credits);
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 738) if (handle->h_rsv_handle)
14ff6286309e2 (Jan Kara 2020-05-20 15:31:19 +0200 739) __jbd2_journal_unreserve_handle(handle->h_rsv_handle,
14ff6286309e2 (Jan Kara 2020-05-20 15:31:19 +0200 740) transaction);
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 741) if (atomic_dec_and_test(&transaction->t_updates))
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 742) wake_up(&journal->j_wait_updates);
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 743)
50b8b3f85a015 (Linus Torvalds 2019-11-30 10:53:02 -0800 744) rwsem_release(&journal->j_trans_commit_map, _THIS_IP_);
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 745) /*
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 746) * Scope of the GFP_NOFS context is over here and so we can restore the
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 747) * original alloc context.
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 748) */
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 749) memalloc_nofs_restore(handle->saved_alloc_context);
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 750) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 751)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 752) /**
2bf31d94423c8 (Mauro Carvalho Chehab 2020-11-16 11:18:08 +0100 753) * jbd2__journal_restart() - restart a handle .
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 754) * @handle: handle to restart
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 755) * @nblocks: nr credits requested
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 756) * @revoke_records: number of revoke record credits requested
f69120ce6c024 (Tobin C. Harding 2018-01-10 00:27:29 -0500 757) * @gfp_mask: memory allocation flags (for start_this_handle)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 758) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 759) * Restart a handle for a multi-transaction filesystem
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 760) * operation.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 761) *
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 762) * If the jbd2_journal_extend() call above fails to grant new buffer credits
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 763) * to a running handle, a call to jbd2_journal_restart will commit the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 764) * handle's transaction so far and reattach the handle to a new
bd7ced98812db (Masanari Iida 2016-02-02 22:31:06 +0900 765) * transaction capable of guaranteeing the requested number of
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 766) * credits. We preserve reserved handle if there's any attached to the
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 767) * passed in handle.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 768) */
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 769) int jbd2__journal_restart(handle_t *handle, int nblocks, int revoke_records,
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 770) gfp_t gfp_mask)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 771) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 772) transaction_t *transaction = handle->h_transaction;
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 773) journal_t *journal;
e44718318004a (Theodore Ts'o 2011-02-12 08:18:24 -0500 774) tid_t tid;
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 775) int need_to_start;
0094f981bbaca (Jan Kara 2019-11-05 17:44:30 +0100 776) int ret;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 777)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 778) /* If we've had an abort of any type, don't even think about
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 779) * actually doing the restart! */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 780) if (is_handle_aborted(handle))
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 781) return 0;
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 782) journal = transaction->t_journal;
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 783) tid = transaction->t_tid;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 784)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 785) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 786) * First unlink the handle from its current transaction, and start the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 787) * commit on that.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 788) */
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 789) jbd_debug(2, "restarting handle %p\n", handle);
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 790) stop_this_handle(handle);
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 791) handle->h_transaction = NULL;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 792)
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 793) /*
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 794) * TODO: If we use READ_ONCE / WRITE_ONCE for j_commit_request we can
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 795) * get rid of pointless j_state_lock traffic like this.
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 796) */
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 797) read_lock(&journal->j_state_lock);
e44718318004a (Theodore Ts'o 2011-02-12 08:18:24 -0500 798) need_to_start = !tid_geq(journal->j_commit_request, tid);
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 799) read_unlock(&journal->j_state_lock);
e44718318004a (Theodore Ts'o 2011-02-12 08:18:24 -0500 800) if (need_to_start)
e44718318004a (Theodore Ts'o 2011-02-12 08:18:24 -0500 801) jbd2_log_start_commit(journal, tid);
933f1c1e0b75b (Jan Kara 2019-11-05 17:44:27 +0100 802) handle->h_total_credits = nblocks +
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 803) DIV_ROUND_UP(revoke_records,
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 804) journal->j_revoke_records_per_block);
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 805) handle->h_revoke_credits = revoke_records;
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 806) ret = start_this_handle(journal, handle, gfp_mask);
0094f981bbaca (Jan Kara 2019-11-05 17:44:30 +0100 807) trace_jbd2_handle_restart(journal->j_fs_dev->bd_dev,
0094f981bbaca (Jan Kara 2019-11-05 17:44:30 +0100 808) ret ? 0 : handle->h_transaction->t_tid,
0094f981bbaca (Jan Kara 2019-11-05 17:44:30 +0100 809) handle->h_type, handle->h_line_no,
0094f981bbaca (Jan Kara 2019-11-05 17:44:30 +0100 810) handle->h_total_credits);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 811) return ret;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 812) }
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 813) EXPORT_SYMBOL(jbd2__journal_restart);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 814)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 815)
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 816) int jbd2_journal_restart(handle_t *handle, int nblocks)
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 817) {
fdc3ef882a5d5 (Jan Kara 2019-11-05 17:44:26 +0100 818) return jbd2__journal_restart(handle, nblocks, 0, GFP_NOFS);
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 819) }
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 820) EXPORT_SYMBOL(jbd2_journal_restart);
47def82672b3b (Theodore Ts'o 2010-07-27 11:56:05 -0400 821)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 822) /**
2bf31d94423c8 (Mauro Carvalho Chehab 2020-11-16 11:18:08 +0100 823) * jbd2_journal_lock_updates () - establish a transaction barrier.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 824) * @journal: Journal to establish a barrier on.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 825) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 826) * This locks out any further updates from being started, and blocks
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 827) * until all existing updates have completed, returning only once the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 828) * journal is in a quiescent state with no updates running.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 829) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 830) * The journal lock should not be held on entry.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 831) */
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 832) void jbd2_journal_lock_updates(journal_t *journal)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 833) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 834) DEFINE_WAIT(wait);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 835)
1eaa566d368b2 (Jan Kara 2016-06-30 11:40:54 -0400 836) jbd2_might_wait_for_commit(journal);
1eaa566d368b2 (Jan Kara 2016-06-30 11:40:54 -0400 837)
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 838) write_lock(&journal->j_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 839) ++journal->j_barrier_count;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 840)
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 841) /* Wait until there are no reserved handles */
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 842) if (atomic_read(&journal->j_reserved_credits)) {
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 843) write_unlock(&journal->j_state_lock);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 844) wait_event(journal->j_wait_reserved,
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 845) atomic_read(&journal->j_reserved_credits) == 0);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 846) write_lock(&journal->j_state_lock);
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 847) }
8f7d89f36829b (Jan Kara 2013-06-04 12:35:11 -0400 848)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 849) /* Wait until there are no running updates */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 850) while (1) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 851) transaction_t *transaction = journal->j_running_transaction;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 852)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 853) if (!transaction)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 854) break;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 855)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 856) spin_lock(&transaction->t_handle_lock);
9837d8e982b7e (Jan Kara 2012-01-04 22:03:11 -0500 857) prepare_to_wait(&journal->j_wait_updates, &wait,
9837d8e982b7e (Jan Kara 2012-01-04 22:03:11 -0500 858) TASK_UNINTERRUPTIBLE);
a51dca9cd3bb4 (Theodore Ts'o 2010-08-02 08:43:25 -0400 859) if (!atomic_read(&transaction->t_updates)) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 860) spin_unlock(&transaction->t_handle_lock);
9837d8e982b7e (Jan Kara 2012-01-04 22:03:11 -0500 861) finish_wait(&journal->j_wait_updates, &wait);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 862) break;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 863) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 864) spin_unlock(&transaction->t_handle_lock);
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 865) write_unlock(&journal->j_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 866) schedule();
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 867) finish_wait(&journal->j_wait_updates, &wait);
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 868) write_lock(&journal->j_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 869) }
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 870) write_unlock(&journal->j_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 871)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 872) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 873) * We have now established a barrier against other normal updates, but
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 874) * we also need to barrier against other jbd2_journal_lock_updates() calls
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 875) * to make sure that we serialise special journal-locked operations
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 876) * too.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 877) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 878) mutex_lock(&journal->j_barrier);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 879) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 880)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 881) /**
2bf31d94423c8 (Mauro Carvalho Chehab 2020-11-16 11:18:08 +0100 882) * jbd2_journal_unlock_updates () - release barrier
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 883) * @journal: Journal to release the barrier on.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 884) *
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 885) * Release a transaction barrier obtained with jbd2_journal_lock_updates().
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 886) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 887) * Should be called without the journal lock held.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 888) */
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 889) void jbd2_journal_unlock_updates (journal_t *journal)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 890) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 891) J_ASSERT(journal->j_barrier_count != 0);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 892)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 893) mutex_unlock(&journal->j_barrier);
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 894) write_lock(&journal->j_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 895) --journal->j_barrier_count;
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 896) write_unlock(&journal->j_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 897) wake_up(&journal->j_wait_transaction_locked);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 898) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 899)
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 900) static void warn_dirty_buffer(struct buffer_head *bh)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 901) {
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 902) printk(KERN_WARNING
a1c6f05733c27 (Dmitry Monakhov 2015-04-13 16:31:37 +0400 903) "JBD2: Spotted dirty metadata buffer (dev = %pg, blocknr = %llu). "
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 904) "There's a risk of filesystem corruption in case of system "
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 905) "crash.\n",
a1c6f05733c27 (Dmitry Monakhov 2015-04-13 16:31:37 +0400 906) bh->b_bdev, (unsigned long long)bh->b_blocknr);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 907) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 908)
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 909) /* Call t_frozen trigger and copy buffer data into jh->b_frozen_data. */
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 910) static void jbd2_freeze_jh_data(struct journal_head *jh)
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 911) {
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 912) struct page *page;
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 913) int offset;
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 914) char *source;
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 915) struct buffer_head *bh = jh2bh(jh);
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 916)
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 917) J_EXPECT_JH(jh, buffer_uptodate(bh), "Possible IO failure.\n");
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 918) page = bh->b_page;
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 919) offset = offset_in_page(bh->b_data);
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 920) source = kmap_atomic(page);
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 921) /* Fire data frozen trigger just before we copy the data */
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 922) jbd2_buffer_frozen_trigger(jh, source + offset, jh->b_triggers);
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 923) memcpy(jh->b_frozen_data, source + offset, bh->b_size);
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 924) kunmap_atomic(source);
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 925)
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 926) /*
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 927) * Now that the frozen data is saved off, we need to store any matching
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 928) * triggers.
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 929) */
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 930) jh->b_frozen_triggers = jh->b_triggers;
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 931) }
ee57aba159a5c (Jan Kara 2015-06-08 12:39:07 -0400 932)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 933) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 934) * If the buffer is already part of the current transaction, then there
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 935) * is nothing we need to do. If it is already part of a prior
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 936) * transaction which we are still committing to disk, then we need to
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 937) * make sure that we do not overwrite the old copy: we do copy-out to
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 938) * preserve the copy going to disk. We also account the buffer against
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 939) * the handle's metadata buffer credits (unless the buffer is already
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 940) * part of the transaction, that is).
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 941) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 942) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 943) static int
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 944) do_get_write_access(handle_t *handle, struct journal_head *jh,
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 945) int force_copy)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 946) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 947) struct buffer_head *bh;
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 948) transaction_t *transaction = handle->h_transaction;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 949) journal_t *journal;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 950) int error;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 951) char *frozen_buffer = NULL;
f783f091e49ce (Theodore Ts'o 2013-04-21 16:47:54 -0400 952) unsigned long start_lock, time_lock;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 953)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 954) journal = transaction->t_journal;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 955)
cfef2c6a559b1 (Theodore Ts'o 2010-12-18 13:07:34 -0500 956) jbd_debug(5, "journal_head %p, force_copy %d\n", jh, force_copy);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 957)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 958) JBUFFER_TRACE(jh, "entry");
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 959) repeat:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 960) bh = jh2bh(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 961)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 962) /* @@@ Need to check for errors here at some point. */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 963)
f783f091e49ce (Theodore Ts'o 2013-04-21 16:47:54 -0400 964) start_lock = jiffies;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 965) lock_buffer(bh);
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 966) spin_lock(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 967)
f783f091e49ce (Theodore Ts'o 2013-04-21 16:47:54 -0400 968) /* If it takes too long to lock the buffer, trace it */
f783f091e49ce (Theodore Ts'o 2013-04-21 16:47:54 -0400 969) time_lock = jbd2_time_diff(start_lock, jiffies);
f783f091e49ce (Theodore Ts'o 2013-04-21 16:47:54 -0400 970) if (time_lock > HZ/10)
f783f091e49ce (Theodore Ts'o 2013-04-21 16:47:54 -0400 971) trace_jbd2_lock_buffer_stall(bh->b_bdev->bd_dev,
f783f091e49ce (Theodore Ts'o 2013-04-21 16:47:54 -0400 972) jiffies_to_msecs(time_lock));
f783f091e49ce (Theodore Ts'o 2013-04-21 16:47:54 -0400 973)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 974) /* We now hold the buffer lock so it is safe to query the buffer
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 975) * state. Is the buffer dirty?
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 976) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 977) * If so, there are two possibilities. The buffer may be
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 978) * non-journaled, and undergoing a quite legitimate writeback.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 979) * Otherwise, it is journaled, and we don't expect dirty buffers
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 980) * in that state (the buffers should be marked JBD_Dirty
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 981) * instead.) So either the IO is being done under our own
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 982) * control and this is a bug, or it's a third party IO such as
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 983) * dump(8) (which may leave the buffer scheduled for read ---
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 984) * ie. locked but not dirty) or tune2fs (which may actually have
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 985) * the buffer dirtied, ugh.) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 986)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 987) if (buffer_dirty(bh)) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 988) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 989) * First question: is this buffer already part of the current
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 990) * transaction or the existing committing transaction?
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 991) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 992) if (jh->b_transaction) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 993) J_ASSERT_JH(jh,
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 994) jh->b_transaction == transaction ||
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 995) jh->b_transaction ==
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 996) journal->j_committing_transaction);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 997) if (jh->b_next_transaction)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 998) J_ASSERT_JH(jh, jh->b_next_transaction ==
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 999) transaction);
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 1000) warn_dirty_buffer(bh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1001) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1002) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1003) * In any case we need to clean the dirty flag and we must
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1004) * do it under the buffer lock to be sure we don't race
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1005) * with running write-out.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1006) */
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 1007) JBUFFER_TRACE(jh, "Journalling dirty buffer");
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 1008) clear_buffer_dirty(bh);
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 1009) set_buffer_jbddirty(bh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1010) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1011)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1012) unlock_buffer(bh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1013)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1014) error = -EROFS;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1015) if (is_handle_aborted(handle)) {
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1016) spin_unlock(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1017) goto out;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1018) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1019) error = 0;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1020)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1021) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1022) * The buffer is already part of this transaction if b_transaction or
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1023) * b_next_transaction points to it
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1024) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1025) if (jh->b_transaction == transaction ||
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1026) jh->b_next_transaction == transaction)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1027) goto done;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1028)
9fc7c63a1d6e9 (Josef Bacik 2008-04-17 10:38:59 -0400 1029) /*
9fc7c63a1d6e9 (Josef Bacik 2008-04-17 10:38:59 -0400 1030) * this is the first time this transaction is touching this buffer,
9fc7c63a1d6e9 (Josef Bacik 2008-04-17 10:38:59 -0400 1031) * reset the modified flag
9fc7c63a1d6e9 (Josef Bacik 2008-04-17 10:38:59 -0400 1032) */
561405f031fec (Colin Ian King 2018-12-04 00:20:10 -0500 1033) jh->b_modified = 0;
9fc7c63a1d6e9 (Josef Bacik 2008-04-17 10:38:59 -0400 1034)
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1035) /*
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1036) * If the buffer is not journaled right now, we need to make sure it
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1037) * doesn't get written to disk before the caller actually commits the
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1038) * new data
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1039) */
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1040) if (!jh->b_transaction) {
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1041) JBUFFER_TRACE(jh, "no transaction");
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1042) J_ASSERT_JH(jh, !jh->b_next_transaction);
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1043) JBUFFER_TRACE(jh, "file as BJ_Reserved");
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1044) /*
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1045) * Make sure all stores to jh (b_modified, b_frozen_data) are
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1046) * visible before attaching it to the running transaction.
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1047) * Paired with barrier in jbd2_write_access_granted()
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1048) */
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1049) smp_wmb();
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1050) spin_lock(&journal->j_list_lock);
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1051) __jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1052) spin_unlock(&journal->j_list_lock);
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1053) goto done;
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1054) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1055) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1056) * If there is already a copy-out version of this buffer, then we don't
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1057) * need to make another one
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1058) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1059) if (jh->b_frozen_data) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1060) JBUFFER_TRACE(jh, "has frozen data");
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1061) J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1062) goto attach_next;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1063) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1064)
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1065) JBUFFER_TRACE(jh, "owned by older transaction");
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1066) J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1067) J_ASSERT_JH(jh, jh->b_transaction == journal->j_committing_transaction);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1068)
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1069) /*
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1070) * There is one case we have to be very careful about. If the
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1071) * committing transaction is currently writing this buffer out to disk
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1072) * and has NOT made a copy-out, then we cannot modify the buffer
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1073) * contents at all right now. The essence of copy-out is that it is
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1074) * the extra copy, not the primary copy, which gets journaled. If the
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1075) * primary copy is already going to disk then we cannot do copy-out
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1076) * here.
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1077) */
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1078) if (buffer_shadow(bh)) {
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1079) JBUFFER_TRACE(jh, "on shadow: sleep");
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1080) spin_unlock(&jh->b_state_lock);
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1081) wait_on_bit_io(&bh->b_state, BH_Shadow, TASK_UNINTERRUPTIBLE);
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1082) goto repeat;
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1083) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1084)
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1085) /*
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1086) * Only do the copy if the currently-owning transaction still needs it.
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1087) * If buffer isn't on BJ_Metadata list, the committing transaction is
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1088) * past that stage (here we use the fact that BH_Shadow is set under
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1089) * bh_state lock together with refiling to BJ_Shadow list and at this
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1090) * point we know the buffer doesn't have BH_Shadow set).
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1091) *
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1092) * Subtle point, though: if this is a get_undo_access, then we will be
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1093) * relying on the frozen_data to contain the new value of the
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1094) * committed_data record after the transaction, so we HAVE to force the
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1095) * frozen_data copy in that case.
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1096) */
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1097) if (jh->b_jlist == BJ_Metadata || force_copy) {
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1098) JBUFFER_TRACE(jh, "generate frozen data");
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1099) if (!frozen_buffer) {
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1100) JBUFFER_TRACE(jh, "allocate memory for buffer");
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1101) spin_unlock(&jh->b_state_lock);
490c1b444ce65 (Michal Hocko 2016-03-13 17:38:20 -0400 1102) frozen_buffer = jbd2_alloc(jh2bh(jh)->b_size,
490c1b444ce65 (Michal Hocko 2016-03-13 17:38:20 -0400 1103) GFP_NOFS | __GFP_NOFAIL);
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1104) goto repeat;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1105) }
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1106) jh->b_frozen_data = frozen_buffer;
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1107) frozen_buffer = NULL;
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1108) jbd2_freeze_jh_data(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1109) }
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1110) attach_next:
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1111) /*
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1112) * Make sure all stores to jh (b_modified, b_frozen_data) are visible
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1113) * before attaching it to the running transaction. Paired with barrier
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1114) * in jbd2_write_access_granted()
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1115) */
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1116) smp_wmb();
8b00f400eedf9 (Jan Kara 2015-06-08 12:44:21 -0400 1117) jh->b_next_transaction = transaction;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1118)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1119) done:
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1120) spin_unlock(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1121)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1122) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1123) * If we are about to journal a buffer, then any revoke pending on it is
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1124) * no longer valid
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1125) */
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 1126) jbd2_journal_cancel_revoke(handle, jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1127)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1128) out:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1129) if (unlikely(frozen_buffer)) /* It's usually NULL */
af1e76d6b3f37 (Mingming Cao 2007-10-16 18:38:25 -0400 1130) jbd2_free(frozen_buffer, bh->b_size);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1131)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1132) JBUFFER_TRACE(jh, "exit");
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1133) return error;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1134) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1135)
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1136) /* Fast check whether buffer is already attached to the required transaction */
087ffd4eae992 (Junxiao Bi 2015-12-04 12:29:28 -0500 1137) static bool jbd2_write_access_granted(handle_t *handle, struct buffer_head *bh,
087ffd4eae992 (Junxiao Bi 2015-12-04 12:29:28 -0500 1138) bool undo)
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1139) {
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1140) struct journal_head *jh;
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1141) bool ret = false;
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1142)
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1143) /* Dirty buffers require special handling... */
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1144) if (buffer_dirty(bh))
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1145) return false;
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1146)
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1147) /*
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1148) * RCU protects us from dereferencing freed pages. So the checks we do
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1149) * are guaranteed not to oops. However the jh slab object can get freed
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1150) * & reallocated while we work with it. So we have to be careful. When
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1151) * we see jh attached to the running transaction, we know it must stay
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1152) * so until the transaction is committed. Thus jh won't be freed and
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1153) * will be attached to the same bh while we run. However it can
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1154) * happen jh gets freed, reallocated, and attached to the transaction
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1155) * just after we get pointer to it from bh. So we have to be careful
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1156) * and recheck jh still belongs to our bh before we return success.
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1157) */
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1158) rcu_read_lock();
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1159) if (!buffer_jbd(bh))
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1160) goto out;
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1161) /* This should be bh2jh() but that doesn't work with inline functions */
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1162) jh = READ_ONCE(bh->b_private);
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1163) if (!jh)
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1164) goto out;
087ffd4eae992 (Junxiao Bi 2015-12-04 12:29:28 -0500 1165) /* For undo access buffer must have data copied */
087ffd4eae992 (Junxiao Bi 2015-12-04 12:29:28 -0500 1166) if (undo && !jh->b_committed_data)
087ffd4eae992 (Junxiao Bi 2015-12-04 12:29:28 -0500 1167) goto out;
6c5d911249290 (Qian Cai 2020-02-21 23:31:11 -0500 1168) if (READ_ONCE(jh->b_transaction) != handle->h_transaction &&
6c5d911249290 (Qian Cai 2020-02-21 23:31:11 -0500 1169) READ_ONCE(jh->b_next_transaction) != handle->h_transaction)
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1170) goto out;
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1171) /*
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1172) * There are two reasons for the barrier here:
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1173) * 1) Make sure to fetch b_bh after we did previous checks so that we
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1174) * detect when jh went through free, realloc, attach to transaction
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1175) * while we were checking. Paired with implicit barrier in that path.
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1176) * 2) So that access to bh done after jbd2_write_access_granted()
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1177) * doesn't get reordered and see inconsistent state of concurrent
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1178) * do_get_write_access().
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1179) */
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1180) smp_mb();
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1181) if (unlikely(jh->b_bh != bh))
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1182) goto out;
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1183) ret = true;
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1184) out:
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1185) rcu_read_unlock();
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1186) return ret;
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1187) }
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1188)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1189) /**
2bf31d94423c8 (Mauro Carvalho Chehab 2020-11-16 11:18:08 +0100 1190) * jbd2_journal_get_write_access() - notify intent to modify a buffer
2bf31d94423c8 (Mauro Carvalho Chehab 2020-11-16 11:18:08 +0100 1191) * for metadata (not data) update.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1192) * @handle: transaction to add buffer modifications to
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1193) * @bh: bh to be used for metadata writes
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1194) *
df1b560a4a04a (Mauro Carvalho Chehab 2017-05-12 07:58:23 -0300 1195) * Returns: error code or 0 on success.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1196) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1197) * In full data journalling mode the buffer may be of type BJ_AsyncData,
df1b560a4a04a (Mauro Carvalho Chehab 2017-05-12 07:58:23 -0300 1198) * because we're ``write()ing`` a buffer which is also part of a shared mapping.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1199) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1200)
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 1201) int jbd2_journal_get_write_access(handle_t *handle, struct buffer_head *bh)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1202) {
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1203) struct journal_head *jh;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1204) int rc;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1205)
8eedabfd66b68 (wangyan 2020-02-20 21:46:14 +0800 1206) if (is_handle_aborted(handle))
8eedabfd66b68 (wangyan 2020-02-20 21:46:14 +0800 1207) return -EROFS;
8eedabfd66b68 (wangyan 2020-02-20 21:46:14 +0800 1208)
087ffd4eae992 (Junxiao Bi 2015-12-04 12:29:28 -0500 1209) if (jbd2_write_access_granted(handle, bh, false))
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1210) return 0;
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1211)
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1212) jh = jbd2_journal_add_journal_head(bh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1213) /* We do not want to get caught playing with fields which the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1214) * log thread also manipulates. Make sure that the buffer
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1215) * completes any outstanding IO before proceeding. */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1216) rc = do_get_write_access(handle, jh, 0);
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 1217) jbd2_journal_put_journal_head(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1218) return rc;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1219) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1220)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1221)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1222) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1223) * When the user wants to journal a newly created buffer_head
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1224) * (ie. getblk() returned a new buffer and we are going to populate it
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1225) * manually rather than reading off disk), then we need to keep the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1226) * buffer_head locked until it has been completely filled with new
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1227) * data. In this case, we should be able to make the assertion that
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1228) * the bh is not already part of an existing transaction.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1229) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1230) * The buffer should already be locked by the caller by this point.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1231) * There is no lock ranking violation: it was a newly created,
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1232) * unlocked buffer beforehand. */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1233)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1234) /**
2bf31d94423c8 (Mauro Carvalho Chehab 2020-11-16 11:18:08 +0100 1235) * jbd2_journal_get_create_access () - notify intent to use newly created bh
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1236) * @handle: transaction to new buffer to
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1237) * @bh: new buffer.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1238) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1239) * Call this if you create a new bh.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1240) */
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 1241) int jbd2_journal_get_create_access(handle_t *handle, struct buffer_head *bh)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1242) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1243) transaction_t *transaction = handle->h_transaction;
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 1244) journal_t *journal;
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 1245) struct journal_head *jh = jbd2_journal_add_journal_head(bh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1246) int err;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1247)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1248) jbd_debug(5, "journal_head %p\n", jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1249) err = -EROFS;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1250) if (is_handle_aborted(handle))
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1251) goto out;
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 1252) journal = transaction->t_journal;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1253) err = 0;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1254)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1255) JBUFFER_TRACE(jh, "entry");
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1256) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1257) * The buffer may already belong to this transaction due to pre-zeroing
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1258) * in the filesystem's new_block code. It may also be on the previous,
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1259) * committing transaction's lists, but it HAS to be in Forget state in
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1260) * that case: the transaction must have deleted the buffer for it to be
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1261) * reused here.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1262) */
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1263) spin_lock(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1264) J_ASSERT_JH(jh, (jh->b_transaction == transaction ||
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1265) jh->b_transaction == NULL ||
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1266) (jh->b_transaction == journal->j_committing_transaction &&
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1267) jh->b_jlist == BJ_Forget)));
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1268)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1269) J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1270) J_ASSERT_JH(jh, buffer_locked(jh2bh(jh)));
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1271)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1272) if (jh->b_transaction == NULL) {
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 1273) /*
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 1274) * Previous jbd2_journal_forget() could have left the buffer
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 1275) * with jbddirty bit set because it was being committed. When
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 1276) * the commit finished, we've filed the buffer for
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 1277) * checkpointing and marked it dirty. Now we are reallocating
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 1278) * the buffer so the transaction freeing it must have
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 1279) * committed and so it's safe to clear the dirty bit.
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 1280) */
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 1281) clear_buffer_dirty(jh2bh(jh));
9fc7c63a1d6e9 (Josef Bacik 2008-04-17 10:38:59 -0400 1282) /* first access by this transaction */
9fc7c63a1d6e9 (Josef Bacik 2008-04-17 10:38:59 -0400 1283) jh->b_modified = 0;
9fc7c63a1d6e9 (Josef Bacik 2008-04-17 10:38:59 -0400 1284)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1285) JBUFFER_TRACE(jh, "file as BJ_Reserved");
6e4862a5bb9d1 (Theodore Ts'o 2014-03-09 00:46:23 -0500 1286) spin_lock(&journal->j_list_lock);
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 1287) __jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);
559cce698eaf4 (Taesoo Kim 2016-10-12 23:19:18 -0400 1288) spin_unlock(&journal->j_list_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1289) } else if (jh->b_transaction == journal->j_committing_transaction) {
9fc7c63a1d6e9 (Josef Bacik 2008-04-17 10:38:59 -0400 1290) /* first access by this transaction */
9fc7c63a1d6e9 (Josef Bacik 2008-04-17 10:38:59 -0400 1291) jh->b_modified = 0;
9fc7c63a1d6e9 (Josef Bacik 2008-04-17 10:38:59 -0400 1292)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1293) JBUFFER_TRACE(jh, "set next transaction");
6e4862a5bb9d1 (Theodore Ts'o 2014-03-09 00:46:23 -0500 1294) spin_lock(&journal->j_list_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1295) jh->b_next_transaction = transaction;
559cce698eaf4 (Taesoo Kim 2016-10-12 23:19:18 -0400 1296) spin_unlock(&journal->j_list_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1297) }
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1298) spin_unlock(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1299)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1300) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1301) * akpm: I added this. ext3_alloc_branch can pick up new indirect
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1302) * blocks which contain freed but then revoked metadata. We need
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1303) * to cancel the revoke in case we end up freeing it yet again
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1304) * and the reallocating as data - this would cause a second revoke,
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1305) * which hits an assertion error.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1306) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1307) JBUFFER_TRACE(jh, "cancelling revoke");
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 1308) jbd2_journal_cancel_revoke(handle, jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1309) out:
3991b4008cb12 (Ding Dinghua 2011-05-25 17:43:48 -0400 1310) jbd2_journal_put_journal_head(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1311) return err;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1312) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1313)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1314) /**
2bf31d94423c8 (Mauro Carvalho Chehab 2020-11-16 11:18:08 +0100 1315) * jbd2_journal_get_undo_access() - Notify intent to modify metadata with
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1316) * non-rewindable consequences
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1317) * @handle: transaction
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1318) * @bh: buffer to undo
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1319) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1320) * Sometimes there is a need to distinguish between metadata which has
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1321) * been committed to disk and that which has not. The ext3fs code uses
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1322) * this for freeing and allocating space, we have to make sure that we
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1323) * do not reuse freed space until the deallocation has been committed,
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1324) * since if we overwrote that space we would make the delete
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1325) * un-rewindable in case of a crash.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1326) *
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 1327) * To deal with that, jbd2_journal_get_undo_access requests write access to a
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1328) * buffer for parts of non-rewindable operations such as delete
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1329) * operations on the bitmaps. The journaling code must keep a copy of
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1330) * the buffer's contents prior to the undo_access call until such time
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1331) * as we know that the buffer has definitely been committed to disk.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1332) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1333) * We never need to know which transaction the committed data is part
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1334) * of, buffers touched here are guaranteed to be dirtied later and so
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1335) * will be committed to a new transaction in due course, at which point
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1336) * we can discard the old committed data pointer.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1337) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1338) * Returns error number or 0 on success.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1339) */
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 1340) int jbd2_journal_get_undo_access(handle_t *handle, struct buffer_head *bh)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1341) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1342) int err;
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1343) struct journal_head *jh;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1344) char *committed_data = NULL;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1345)
8eedabfd66b68 (wangyan 2020-02-20 21:46:14 +0800 1346) if (is_handle_aborted(handle))
8eedabfd66b68 (wangyan 2020-02-20 21:46:14 +0800 1347) return -EROFS;
8eedabfd66b68 (wangyan 2020-02-20 21:46:14 +0800 1348)
087ffd4eae992 (Junxiao Bi 2015-12-04 12:29:28 -0500 1349) if (jbd2_write_access_granted(handle, bh, true))
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1350) return 0;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1351)
de92c8caf16ca (Jan Kara 2015-06-08 12:46:37 -0400 1352) jh = jbd2_journal_add_journal_head(bh);
01215d3edb0f3 (zhangyi (F) 2019-02-21 11:24:09 -0500 1353) JBUFFER_TRACE(jh, "entry");
01215d3edb0f3 (zhangyi (F) 2019-02-21 11:24:09 -0500 1354)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1355) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1356) * Do this first --- it can drop the journal lock, so we want to
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1357) * make sure that obtaining the committed_data is done
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1358) * atomically wrt. completion of any outstanding commits.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1359) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1360) err = do_get_write_access(handle, jh, 1);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1361) if (err)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1362) goto out;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1363)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1364) repeat:
490c1b444ce65 (Michal Hocko 2016-03-13 17:38:20 -0400 1365) if (!jh->b_committed_data)
490c1b444ce65 (Michal Hocko 2016-03-13 17:38:20 -0400 1366) committed_data = jbd2_alloc(jh2bh(jh)->b_size,
490c1b444ce65 (Michal Hocko 2016-03-13 17:38:20 -0400 1367) GFP_NOFS|__GFP_NOFAIL);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1368)
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1369) spin_lock(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1370) if (!jh->b_committed_data) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1371) /* Copy out the current buffer contents into the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1372) * preserved, committed copy. */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1373) JBUFFER_TRACE(jh, "generate b_committed data");
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1374) if (!committed_data) {
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1375) spin_unlock(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1376) goto repeat;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1377) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1378)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1379) jh->b_committed_data = committed_data;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1380) committed_data = NULL;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1381) memcpy(jh->b_committed_data, bh->b_data, bh->b_size);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1382) }
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1383) spin_unlock(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1384) out:
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 1385) jbd2_journal_put_journal_head(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1386) if (unlikely(committed_data))
af1e76d6b3f37 (Mingming Cao 2007-10-16 18:38:25 -0400 1387) jbd2_free(committed_data, bh->b_size);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1388) return err;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1389) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1390)
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1391) /**
2bf31d94423c8 (Mauro Carvalho Chehab 2020-11-16 11:18:08 +0100 1392) * jbd2_journal_set_triggers() - Add triggers for commit writeout
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1393) * @bh: buffer to trigger on
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1394) * @type: struct jbd2_buffer_trigger_type containing the trigger(s).
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1395) *
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1396) * Set any triggers on this journal_head. This is always safe, because
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1397) * triggers for a committing buffer will be saved off, and triggers for
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1398) * a running transaction will match the buffer in that transaction.
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1399) *
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1400) * Call with NULL to clear the triggers.
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1401) */
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1402) void jbd2_journal_set_triggers(struct buffer_head *bh,
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1403) struct jbd2_buffer_trigger_type *type)
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1404) {
ad56edad089b5 (Jan Kara 2013-03-11 13:24:56 -0400 1405) struct journal_head *jh = jbd2_journal_grab_journal_head(bh);
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1406)
ad56edad089b5 (Jan Kara 2013-03-11 13:24:56 -0400 1407) if (WARN_ON(!jh))
ad56edad089b5 (Jan Kara 2013-03-11 13:24:56 -0400 1408) return;
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1409) jh->b_triggers = type;
ad56edad089b5 (Jan Kara 2013-03-11 13:24:56 -0400 1410) jbd2_journal_put_journal_head(jh);
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1411) }
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1412)
13ceef099edd2 (Jan Kara 2010-07-14 07:56:33 +0200 1413) void jbd2_buffer_frozen_trigger(struct journal_head *jh, void *mapped_data,
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1414) struct jbd2_buffer_trigger_type *triggers)
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1415) {
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1416) struct buffer_head *bh = jh2bh(jh);
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1417)
13ceef099edd2 (Jan Kara 2010-07-14 07:56:33 +0200 1418) if (!triggers || !triggers->t_frozen)
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1419) return;
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1420)
13ceef099edd2 (Jan Kara 2010-07-14 07:56:33 +0200 1421) triggers->t_frozen(triggers, bh, mapped_data, bh->b_size);
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1422) }
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1423)
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1424) void jbd2_buffer_abort_trigger(struct journal_head *jh,
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1425) struct jbd2_buffer_trigger_type *triggers)
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1426) {
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1427) if (!triggers || !triggers->t_abort)
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1428) return;
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1429)
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1430) triggers->t_abort(triggers, jh2bh(jh));
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1431) }
e06c8227fd94e (Joel Becker 2008-09-11 15:35:47 -0700 1432)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1433) /**
2bf31d94423c8 (Mauro Carvalho Chehab 2020-11-16 11:18:08 +0100 1434) * jbd2_journal_dirty_metadata() - mark a buffer as containing dirty metadata
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1435) * @handle: transaction to add buffer to.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1436) * @bh: buffer to mark
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1437) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1438) * mark dirty metadata which needs to be journaled as part of the current
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1439) * transaction.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1440) *
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1441) * The buffer must have previously had jbd2_journal_get_write_access()
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1442) * called so that it has a valid journal_head attached to the buffer
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1443) * head.
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1444) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1445) * The buffer is placed on the transaction's metadata list and is marked
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1446) * as belonging to the transaction.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1447) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1448) * Returns error number or 0 on success.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1449) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1450) * Special care needs to be taken if the buffer already belongs to the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1451) * current committing transaction (in which case we should have frozen
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1452) * data present for that commit). In that case, we don't relink the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1453) * buffer: that only gets done when the old transaction finally
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1454) * completes its commit.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1455) */
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 1456) int jbd2_journal_dirty_metadata(handle_t *handle, struct buffer_head *bh)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1457) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1458) transaction_t *transaction = handle->h_transaction;
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 1459) journal_t *journal;
ad56edad089b5 (Jan Kara 2013-03-11 13:24:56 -0400 1460) struct journal_head *jh;
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1461) int ret = 0;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1462)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1463) if (is_handle_aborted(handle))
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 1464) return -EROFS;
01215d3edb0f3 (zhangyi (F) 2019-02-21 11:24:09 -0500 1465) if (!buffer_jbd(bh))
01215d3edb0f3 (zhangyi (F) 2019-02-21 11:24:09 -0500 1466) return -EUCLEAN;
01215d3edb0f3 (zhangyi (F) 2019-02-21 11:24:09 -0500 1467)
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1468) /*
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1469) * We don't grab jh reference here since the buffer must be part
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1470) * of the running transaction.
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1471) */
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1472) jh = bh2jh(bh);
01215d3edb0f3 (zhangyi (F) 2019-02-21 11:24:09 -0500 1473) jbd_debug(5, "journal_head %p\n", jh);
01215d3edb0f3 (zhangyi (F) 2019-02-21 11:24:09 -0500 1474) JBUFFER_TRACE(jh, "entry");
01215d3edb0f3 (zhangyi (F) 2019-02-21 11:24:09 -0500 1475)
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1476) /*
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1477) * This and the following assertions are unreliable since we may see jh
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1478) * in inconsistent state unless we grab bh_state lock. But this is
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1479) * crucial to catch bugs so let's do a reliable check until the
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1480) * lockless handling is fully proven.
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1481) */
83fe6b18b8d04 (Jan Kara 2021-04-06 18:18:00 +0200 1482) if (data_race(jh->b_transaction != transaction &&
83fe6b18b8d04 (Jan Kara 2021-04-06 18:18:00 +0200 1483) jh->b_next_transaction != transaction)) {
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1484) spin_lock(&jh->b_state_lock);
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1485) J_ASSERT_JH(jh, jh->b_transaction == transaction ||
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1486) jh->b_next_transaction == transaction);
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1487) spin_unlock(&jh->b_state_lock);
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1488) }
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1489) if (jh->b_modified == 1) {
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1490) /* If it's in our transaction it must be in BJ_Metadata list. */
83fe6b18b8d04 (Jan Kara 2021-04-06 18:18:00 +0200 1491) if (data_race(jh->b_transaction == transaction &&
83fe6b18b8d04 (Jan Kara 2021-04-06 18:18:00 +0200 1492) jh->b_jlist != BJ_Metadata)) {
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1493) spin_lock(&jh->b_state_lock);
e09463f220ca9 (Theodore Ts'o 2018-06-16 20:21:45 -0400 1494) if (jh->b_transaction == transaction &&
e09463f220ca9 (Theodore Ts'o 2018-06-16 20:21:45 -0400 1495) jh->b_jlist != BJ_Metadata)
e09463f220ca9 (Theodore Ts'o 2018-06-16 20:21:45 -0400 1496) pr_err("JBD2: assertion failure: h_type=%u "
e09463f220ca9 (Theodore Ts'o 2018-06-16 20:21:45 -0400 1497) "h_line_no=%u block_no=%llu jlist=%u\n",
e09463f220ca9 (Theodore Ts'o 2018-06-16 20:21:45 -0400 1498) handle->h_type, handle->h_line_no,
e09463f220ca9 (Theodore Ts'o 2018-06-16 20:21:45 -0400 1499) (unsigned long long) bh->b_blocknr,
e09463f220ca9 (Theodore Ts'o 2018-06-16 20:21:45 -0400 1500) jh->b_jlist);
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1501) J_ASSERT_JH(jh, jh->b_transaction != transaction ||
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1502) jh->b_jlist == BJ_Metadata);
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1503) spin_unlock(&jh->b_state_lock);
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1504) }
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1505) goto out;
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1506) }
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1507)
6e06ae88edae7 (Jan Kara 2015-07-12 18:11:30 -0400 1508) journal = transaction->t_journal;
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1509) spin_lock(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1510)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1511) if (jh->b_modified == 0) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1512) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1513) * This buffer's got modified and becoming part
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1514) * of the transaction. This needs to be done
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1515) * once a transaction -bzzz
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1516) */
d090707edab59 (Jan Kara 2019-11-05 17:44:28 +0100 1517) if (WARN_ON_ONCE(jbd2_handle_buffer_credits(handle) <= 0)) {
f6c07cad081ba (Theodore Ts'o 2013-12-08 21:12:59 -0500 1518) ret = -ENOSPC;
f6c07cad081ba (Theodore Ts'o 2013-12-08 21:12:59 -0500 1519) goto out_unlock_bh;
f6c07cad081ba (Theodore Ts'o 2013-12-08 21:12:59 -0500 1520) }
e09463f220ca9 (Theodore Ts'o 2018-06-16 20:21:45 -0400 1521) jh->b_modified = 1;
933f1c1e0b75b (Jan Kara 2019-11-05 17:44:27 +0100 1522) handle->h_total_credits--;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1523) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1524)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1525) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1526) * fastpath, to avoid expensive locking. If this buffer is already
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1527) * on the running transaction's metadata list there is nothing to do.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1528) * Nobody can take it off again because there is a handle open.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1529) * I _think_ we're OK here with SMP barriers - a mistaken decision will
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1530) * result in this test being false, so we go in and take the locks.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1531) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1532) if (jh->b_transaction == transaction && jh->b_jlist == BJ_Metadata) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1533) JBUFFER_TRACE(jh, "fastpath");
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1534) if (unlikely(jh->b_transaction !=
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1535) journal->j_running_transaction)) {
a67c848a8b9aa (Dmitry Monakhov 2013-12-08 21:14:59 -0500 1536) printk(KERN_ERR "JBD2: %s: "
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1537) "jh->b_transaction (%llu, %p, %u) != "
66a4cb187b92c (Theodore Ts'o 2014-03-12 16:38:03 -0400 1538) "journal->j_running_transaction (%p, %u)\n",
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1539) journal->j_devname,
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1540) (unsigned long long) bh->b_blocknr,
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1541) jh->b_transaction,
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1542) jh->b_transaction ? jh->b_transaction->t_tid : 0,
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1543) journal->j_running_transaction,
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1544) journal->j_running_transaction ?
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1545) journal->j_running_transaction->t_tid : 0);
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1546) ret = -EINVAL;
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1547) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1548) goto out_unlock_bh;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1549) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1550)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1551) set_buffer_jbddirty(bh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1552)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1553) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1554) * Metadata already on the current transaction list doesn't
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1555) * need to be filed. Metadata on another transaction's list must
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1556) * be committing, and will be refiled once the commit completes:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1557) * leave it alone for now.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1558) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1559) if (jh->b_transaction != transaction) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1560) JBUFFER_TRACE(jh, "already on other transaction");
66a4cb187b92c (Theodore Ts'o 2014-03-12 16:38:03 -0400 1561) if (unlikely(((jh->b_transaction !=
66a4cb187b92c (Theodore Ts'o 2014-03-12 16:38:03 -0400 1562) journal->j_committing_transaction)) ||
66a4cb187b92c (Theodore Ts'o 2014-03-12 16:38:03 -0400 1563) (jh->b_next_transaction != transaction))) {
66a4cb187b92c (Theodore Ts'o 2014-03-12 16:38:03 -0400 1564) printk(KERN_ERR "jbd2_journal_dirty_metadata: %s: "
66a4cb187b92c (Theodore Ts'o 2014-03-12 16:38:03 -0400 1565) "bad jh for block %llu: "
66a4cb187b92c (Theodore Ts'o 2014-03-12 16:38:03 -0400 1566) "transaction (%p, %u), "
66a4cb187b92c (Theodore Ts'o 2014-03-12 16:38:03 -0400 1567) "jh->b_transaction (%p, %u), "
66a4cb187b92c (Theodore Ts'o 2014-03-12 16:38:03 -0400 1568) "jh->b_next_transaction (%p, %u), jlist %u\n",
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1569) journal->j_devname,
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1570) (unsigned long long) bh->b_blocknr,
66a4cb187b92c (Theodore Ts'o 2014-03-12 16:38:03 -0400 1571) transaction, transaction->t_tid,
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1572) jh->b_transaction,
66a4cb187b92c (Theodore Ts'o 2014-03-12 16:38:03 -0400 1573) jh->b_transaction ?
66a4cb187b92c (Theodore Ts'o 2014-03-12 16:38:03 -0400 1574) jh->b_transaction->t_tid : 0,
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1575) jh->b_next_transaction,
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1576) jh->b_next_transaction ?
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1577) jh->b_next_transaction->t_tid : 0,
66a4cb187b92c (Theodore Ts'o 2014-03-12 16:38:03 -0400 1578) jh->b_jlist);
66a4cb187b92c (Theodore Ts'o 2014-03-12 16:38:03 -0400 1579) WARN_ON(1);
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1580) ret = -EINVAL;
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1581) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1582) /* And this case is illegal: we can't reuse another
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1583) * transaction's data buffer, ever. */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1584) goto out_unlock_bh;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1585) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1586)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1587) /* That test should have eliminated the following case: */
4019191be7316 (Mingming Cao 2008-01-28 23:58:27 -0500 1588) J_ASSERT_JH(jh, jh->b_frozen_data == NULL);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1589)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1590) JBUFFER_TRACE(jh, "file as BJ_Metadata");
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1591) spin_lock(&journal->j_list_lock);
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 1592) __jbd2_journal_file_buffer(jh, transaction, BJ_Metadata);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1593) spin_unlock(&journal->j_list_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1594) out_unlock_bh:
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1595) spin_unlock(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1596) out:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1597) JBUFFER_TRACE(jh, "exit");
9ea7a0df63630 (Theodore Ts'o 2011-09-04 10:18:14 -0400 1598) return ret;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1599) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1600)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1601) /**
2bf31d94423c8 (Mauro Carvalho Chehab 2020-11-16 11:18:08 +0100 1602) * jbd2_journal_forget() - bforget() for potentially-journaled buffers.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1603) * @handle: transaction handle
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1604) * @bh: bh to 'forget'
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1605) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1606) * We can only do the bforget if there are no commits pending against the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1607) * buffer. If the buffer is dirty in the current running transaction we
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1608) * can safely unlink it.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1609) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1610) * bh may not be a journalled buffer at all - it may be a non-JBD
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1611) * buffer which came off the hashtable. Check for this.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1612) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1613) * Decrements bh->b_count by one.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1614) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1615) * Allow this call even if the handle has aborted --- it may be part of
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1616) * the caller's cleanup after an abort.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1617) */
8d6ce13679026 (Shijie Luo 2020-01-23 01:43:25 -0500 1618) int jbd2_journal_forget(handle_t *handle, struct buffer_head *bh)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1619) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1620) transaction_t *transaction = handle->h_transaction;
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 1621) journal_t *journal;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1622) struct journal_head *jh;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1623) int drop_reserve = 0;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1624) int err = 0;
1dfc3220d9633 (Josef Bacik 2008-04-17 10:38:59 -0400 1625) int was_modified = 0;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1626)
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 1627) if (is_handle_aborted(handle))
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 1628) return -EROFS;
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 1629) journal = transaction->t_journal;
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 1630)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1631) BUFFER_TRACE(bh, "entry");
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1632)
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1633) jh = jbd2_journal_grab_journal_head(bh);
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1634) if (!jh) {
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1635) __bforget(bh);
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1636) return 0;
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1637) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1638)
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1639) spin_lock(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1640)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1641) /* Critical error: attempting to delete a bitmap buffer, maybe?
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1642) * Don't do any jbd operations, and return an error. */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1643) if (!J_EXPECT_JH(jh, !jh->b_committed_data,
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1644) "inconsistent data on disk")) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1645) err = -EIO;
2e710ff03fc45 (Jan Kara 2019-08-09 14:42:31 +0200 1646) goto drop;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1647) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1648)
48fc7f7e787dd (Adam Buchbinder 2012-09-19 21:48:00 -0400 1649) /* keep track of whether or not this transaction modified us */
1dfc3220d9633 (Josef Bacik 2008-04-17 10:38:59 -0400 1650) was_modified = jh->b_modified;
1dfc3220d9633 (Josef Bacik 2008-04-17 10:38:59 -0400 1651)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1652) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1653) * The buffer's going from the transaction, we must drop
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1654) * all references -bzzz
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1655) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1656) jh->b_modified = 0;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1657)
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 1658) if (jh->b_transaction == transaction) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1659) J_ASSERT_JH(jh, !jh->b_frozen_data);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1660)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1661) /* If we are forgetting a buffer which is already part
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1662) * of this transaction, then we can just drop it from
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1663) * the transaction immediately. */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1664) clear_buffer_dirty(bh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1665) clear_buffer_jbddirty(bh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1666)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1667) JBUFFER_TRACE(jh, "belongs to current transaction: unfile");
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1668)
1dfc3220d9633 (Josef Bacik 2008-04-17 10:38:59 -0400 1669) /*
1dfc3220d9633 (Josef Bacik 2008-04-17 10:38:59 -0400 1670) * we only want to drop a reference if this transaction
1dfc3220d9633 (Josef Bacik 2008-04-17 10:38:59 -0400 1671) * modified the buffer
1dfc3220d9633 (Josef Bacik 2008-04-17 10:38:59 -0400 1672) */
1dfc3220d9633 (Josef Bacik 2008-04-17 10:38:59 -0400 1673) if (was_modified)
1dfc3220d9633 (Josef Bacik 2008-04-17 10:38:59 -0400 1674) drop_reserve = 1;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1675)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1676) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1677) * We are no longer going to journal this buffer.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1678) * However, the commit of this transaction is still
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1679) * important to the buffer: the delete that we are now
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1680) * processing might obsolete an old log entry, so by
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1681) * committing, we can satisfy the buffer's checkpoint.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1682) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1683) * So, if we have a checkpoint on the buffer, we should
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1684) * now refile the buffer on our BJ_Forget list so that
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1685) * we know to remove the checkpoint after we commit.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1686) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1687)
0bfea8118d8e4 (Theodore Ts'o 2014-03-09 00:56:58 -0500 1688) spin_lock(&journal->j_list_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1689) if (jh->b_cp_transaction) {
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 1690) __jbd2_journal_temp_unlink_buffer(jh);
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 1691) __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1692) } else {
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 1693) __jbd2_journal_unfile_buffer(jh);
93108ebb848df (Jan Kara 2019-08-09 14:42:29 +0200 1694) jbd2_journal_put_journal_head(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1695) }
0bfea8118d8e4 (Theodore Ts'o 2014-03-09 00:56:58 -0500 1696) spin_unlock(&journal->j_list_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1697) } else if (jh->b_transaction) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1698) J_ASSERT_JH(jh, (jh->b_transaction ==
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1699) journal->j_committing_transaction));
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1700) /* However, if the buffer is still owned by a prior
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1701) * (committing) transaction, we can't drop it yet... */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1702) JBUFFER_TRACE(jh, "belongs to older transaction");
904cdbd41d749 (zhangyi (F) 2019-02-10 23:23:04 -0500 1703) /* ... but we CAN drop it from the new transaction through
904cdbd41d749 (zhangyi (F) 2019-02-10 23:23:04 -0500 1704) * marking the buffer as freed and set j_next_transaction to
904cdbd41d749 (zhangyi (F) 2019-02-10 23:23:04 -0500 1705) * the new transaction, so that not only the commit code
904cdbd41d749 (zhangyi (F) 2019-02-10 23:23:04 -0500 1706) * knows it should clear dirty bits when it is done with the
904cdbd41d749 (zhangyi (F) 2019-02-10 23:23:04 -0500 1707) * buffer, but also the buffer can be checkpointed only
904cdbd41d749 (zhangyi (F) 2019-02-10 23:23:04 -0500 1708) * after the new transaction commits. */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1709)
904cdbd41d749 (zhangyi (F) 2019-02-10 23:23:04 -0500 1710) set_buffer_freed(bh);
904cdbd41d749 (zhangyi (F) 2019-02-10 23:23:04 -0500 1711)
904cdbd41d749 (zhangyi (F) 2019-02-10 23:23:04 -0500 1712) if (!jh->b_next_transaction) {
0bfea8118d8e4 (Theodore Ts'o 2014-03-09 00:56:58 -0500 1713) spin_lock(&journal->j_list_lock);
904cdbd41d749 (zhangyi (F) 2019-02-10 23:23:04 -0500 1714) jh->b_next_transaction = transaction;
0bfea8118d8e4 (Theodore Ts'o 2014-03-09 00:56:58 -0500 1715) spin_unlock(&journal->j_list_lock);
904cdbd41d749 (zhangyi (F) 2019-02-10 23:23:04 -0500 1716) } else {
904cdbd41d749 (zhangyi (F) 2019-02-10 23:23:04 -0500 1717) J_ASSERT(jh->b_next_transaction == transaction);
1dfc3220d9633 (Josef Bacik 2008-04-17 10:38:59 -0400 1718)
1dfc3220d9633 (Josef Bacik 2008-04-17 10:38:59 -0400 1719) /*
1dfc3220d9633 (Josef Bacik 2008-04-17 10:38:59 -0400 1720) * only drop a reference if this transaction modified
1dfc3220d9633 (Josef Bacik 2008-04-17 10:38:59 -0400 1721) * the buffer
1dfc3220d9633 (Josef Bacik 2008-04-17 10:38:59 -0400 1722) */
1dfc3220d9633 (Josef Bacik 2008-04-17 10:38:59 -0400 1723) if (was_modified)
1dfc3220d9633 (Josef Bacik 2008-04-17 10:38:59 -0400 1724) drop_reserve = 1;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1725) }
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1726) } else {
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1727) /*
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1728) * Finally, if the buffer is not belongs to any
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1729) * transaction, we can just drop it now if it has no
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1730) * checkpoint.
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1731) */
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1732) spin_lock(&journal->j_list_lock);
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1733) if (!jh->b_cp_transaction) {
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1734) JBUFFER_TRACE(jh, "belongs to none transaction");
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1735) spin_unlock(&journal->j_list_lock);
2e710ff03fc45 (Jan Kara 2019-08-09 14:42:31 +0200 1736) goto drop;
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1737) }
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1738)
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1739) /*
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1740) * Otherwise, if the buffer has been written to disk,
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1741) * it is safe to remove the checkpoint and drop it.
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1742) */
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1743) if (!buffer_dirty(bh)) {
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1744) __jbd2_journal_remove_checkpoint(jh);
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1745) spin_unlock(&journal->j_list_lock);
2e710ff03fc45 (Jan Kara 2019-08-09 14:42:31 +0200 1746) goto drop;
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1747) }
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1748)
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1749) /*
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1750) * The buffer is still not written to disk, we should
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1751) * attach this buffer to current transaction so that the
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1752) * buffer can be checkpointed only after the current
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1753) * transaction commits.
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1754) */
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1755) clear_buffer_dirty(bh);
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1756) __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
597599268e3b9 (zhangyi (F) 2019-02-10 23:26:06 -0500 1757) spin_unlock(&journal->j_list_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1758) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1759) drop:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1760) __brelse(bh);
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1761) spin_unlock(&jh->b_state_lock);
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1762) jbd2_journal_put_journal_head(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1763) if (drop_reserve) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1764) /* no need to reserve log space for this block -bzzz */
933f1c1e0b75b (Jan Kara 2019-11-05 17:44:27 +0100 1765) handle->h_total_credits++;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1766) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1767) return err;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1768) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1769)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1770) /**
2bf31d94423c8 (Mauro Carvalho Chehab 2020-11-16 11:18:08 +0100 1771) * jbd2_journal_stop() - complete a transaction
bd7ced98812db (Masanari Iida 2016-02-02 22:31:06 +0900 1772) * @handle: transaction to complete.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1773) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1774) * All done for a particular handle.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1775) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1776) * There is not much action needed here. We just return any remaining
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1777) * buffer credits to the transaction and remove the handle. The only
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1778) * complication is that we need to start a commit operation if the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1779) * filesystem is marked for synchronous update.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1780) *
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 1781) * jbd2_journal_stop itself will not usually return an error, but it may
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1782) * do so in unusual circumstances. In particular, expect it to
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 1783) * return -EIO if a jbd2_journal_abort has been executed since the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1784) * transaction began.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1785) */
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 1786) int jbd2_journal_stop(handle_t *handle)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1787) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1788) transaction_t *transaction = handle->h_transaction;
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 1789) journal_t *journal;
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 1790) int err = 0, wait_for_commit = 0;
a51dca9cd3bb4 (Theodore Ts'o 2010-08-02 08:43:25 -0400 1791) tid_t tid;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1792) pid_t pid;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1793)
dfaf5ffda227b (Jan Kara 2019-11-05 17:44:20 +0100 1794) if (--handle->h_ref > 0) {
dfaf5ffda227b (Jan Kara 2019-11-05 17:44:20 +0100 1795) jbd_debug(4, "h_ref %d -> %d\n", handle->h_ref + 1,
dfaf5ffda227b (Jan Kara 2019-11-05 17:44:20 +0100 1796) handle->h_ref);
dfaf5ffda227b (Jan Kara 2019-11-05 17:44:20 +0100 1797) if (is_handle_aborted(handle))
dfaf5ffda227b (Jan Kara 2019-11-05 17:44:20 +0100 1798) return -EIO;
dfaf5ffda227b (Jan Kara 2019-11-05 17:44:20 +0100 1799) return 0;
dfaf5ffda227b (Jan Kara 2019-11-05 17:44:20 +0100 1800) }
9d50659406935 (Lukas Czerner 2015-05-14 18:55:18 -0400 1801) if (!transaction) {
9d50659406935 (Lukas Czerner 2015-05-14 18:55:18 -0400 1802) /*
dfaf5ffda227b (Jan Kara 2019-11-05 17:44:20 +0100 1803) * Handle is already detached from the transaction so there is
dfaf5ffda227b (Jan Kara 2019-11-05 17:44:20 +0100 1804) * nothing to do other than free the handle.
9d50659406935 (Lukas Czerner 2015-05-14 18:55:18 -0400 1805) */
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 1806) memalloc_nofs_restore(handle->saved_alloc_context);
dfaf5ffda227b (Jan Kara 2019-11-05 17:44:20 +0100 1807) goto free_and_exit;
9d50659406935 (Lukas Czerner 2015-05-14 18:55:18 -0400 1808) }
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 1809) journal = transaction->t_journal;
dfaf5ffda227b (Jan Kara 2019-11-05 17:44:20 +0100 1810) tid = transaction->t_tid;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1811)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1812) if (is_handle_aborted(handle))
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1813) err = -EIO;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1814)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1815) jbd_debug(4, "Handle %p going down\n", handle);
343d9c283c984 (Theodore Ts'o 2013-02-08 13:00:22 -0500 1816) trace_jbd2_handle_stats(journal->j_fs_dev->bd_dev,
dfaf5ffda227b (Jan Kara 2019-11-05 17:44:20 +0100 1817) tid, handle->h_type, handle->h_line_no,
343d9c283c984 (Theodore Ts'o 2013-02-08 13:00:22 -0500 1818) jiffies - handle->h_start_jiffies,
343d9c283c984 (Theodore Ts'o 2013-02-08 13:00:22 -0500 1819) handle->h_sync, handle->h_requested_credits,
343d9c283c984 (Theodore Ts'o 2013-02-08 13:00:22 -0500 1820) (handle->h_requested_credits -
933f1c1e0b75b (Jan Kara 2019-11-05 17:44:27 +0100 1821) handle->h_total_credits));
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1822)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1823) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1824) * Implement synchronous transaction batching. If the handle
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1825) * was synchronous, don't force a commit immediately. Let's
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1826) * yield and let another thread piggyback onto this
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1827) * transaction. Keep doing that while new threads continue to
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1828) * arrive. It doesn't cost much - we're about to run a commit
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1829) * and sleep on IO anyway. Speeds up many-threaded, many-dir
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1830) * operations by 30x or more...
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1831) *
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1832) * We try and optimize the sleep time against what the
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1833) * underlying disk can do, instead of having a static sleep
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1834) * time. This is useful for the case where our storage is so
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1835) * fast that it is more optimal to go ahead and force a flush
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1836) * and wait for the transaction to be committed than it is to
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1837) * wait for an arbitrary amount of time for new writers to
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1838) * join the transaction. We achieve this by measuring how
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1839) * long it takes to commit a transaction, and compare it with
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1840) * how long this transaction has been running, and if run time
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1841) * < commit time then we sleep for the delta and commit. This
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1842) * greatly helps super fast disks that would see slowdowns as
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1843) * more threads started doing fsyncs.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1844) *
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1845) * But don't do this if this process was the most recent one
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1846) * to perform a synchronous write. We do this to detect the
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1847) * case where a single process is doing a stream of sync
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1848) * writes. No point in waiting for joiners in that case.
5dd214248f94d (Eric Sandeen 2014-07-05 19:18:22 -0400 1849) *
5dd214248f94d (Eric Sandeen 2014-07-05 19:18:22 -0400 1850) * Setting max_batch_time to 0 disables this completely.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1851) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1852) pid = current->pid;
5dd214248f94d (Eric Sandeen 2014-07-05 19:18:22 -0400 1853) if (handle->h_sync && journal->j_last_sync_writer != pid &&
5dd214248f94d (Eric Sandeen 2014-07-05 19:18:22 -0400 1854) journal->j_max_batch_time) {
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1855) u64 commit_time, trans_time;
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1856)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1857) journal->j_last_sync_writer = pid;
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1858)
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 1859) read_lock(&journal->j_state_lock);
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1860) commit_time = journal->j_average_commit_time;
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 1861) read_unlock(&journal->j_state_lock);
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1862)
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1863) trans_time = ktime_to_ns(ktime_sub(ktime_get(),
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1864) transaction->t_start_time));
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1865)
30773840c19ce (Theodore Ts'o 2009-01-03 20:27:38 -0500 1866) commit_time = max_t(u64, commit_time,
30773840c19ce (Theodore Ts'o 2009-01-03 20:27:38 -0500 1867) 1000*journal->j_min_batch_time);
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1868) commit_time = min_t(u64, commit_time,
30773840c19ce (Theodore Ts'o 2009-01-03 20:27:38 -0500 1869) 1000*journal->j_max_batch_time);
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1870)
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1871) if (trans_time < commit_time) {
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1872) ktime_t expires = ktime_add_ns(ktime_get(),
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1873) commit_time);
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1874) set_current_state(TASK_UNINTERRUPTIBLE);
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1875) schedule_hrtimeout(&expires, HRTIMER_MODE_ABS);
e07f7183a486c (Josef Bacik 2008-11-26 01:14:26 -0500 1876) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1877) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1878)
7058548cd50e5 (Theodore Ts'o 2009-03-25 23:35:46 -0400 1879) if (handle->h_sync)
7058548cd50e5 (Theodore Ts'o 2009-03-25 23:35:46 -0400 1880) transaction->t_synchronous_commit = 1;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1881)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1882) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1883) * If the handle is marked SYNC, we need to set another commit
150549ed2fcf4 (Jan Kara 2019-11-05 17:44:21 +0100 1884) * going! We also want to force a commit if the transaction is too
150549ed2fcf4 (Jan Kara 2019-11-05 17:44:21 +0100 1885) * old now.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1886) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1887) if (handle->h_sync ||
a51dca9cd3bb4 (Theodore Ts'o 2010-08-02 08:43:25 -0400 1888) time_after_eq(jiffies, transaction->t_expires)) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1889) /* Do this even for aborted journals: an abort still
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1890) * completes the commit thread, it just doesn't write
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1891) * anything to disk. */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1892)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1893) jbd_debug(2, "transaction too old, requesting commit for "
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1894) "handle %p\n", handle);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1895) /* This is non-blocking */
dfaf5ffda227b (Jan Kara 2019-11-05 17:44:20 +0100 1896) jbd2_log_start_commit(journal, tid);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1897)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1898) /*
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 1899) * Special case: JBD2_SYNC synchronous updates require us
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1900) * to wait for the commit to complete.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1901) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1902) if (handle->h_sync && !(current->flags & PF_MEMALLOC))
a51dca9cd3bb4 (Theodore Ts'o 2010-08-02 08:43:25 -0400 1903) wait_for_commit = 1;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1904) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1905)
a51dca9cd3bb4 (Theodore Ts'o 2010-08-02 08:43:25 -0400 1906) /*
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 1907) * Once stop_this_handle() drops t_updates, the transaction could start
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 1908) * committing on us and eventually disappear. So we must not
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 1909) * dereference transaction pointer again after calling
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 1910) * stop_this_handle().
a51dca9cd3bb4 (Theodore Ts'o 2010-08-02 08:43:25 -0400 1911) */
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 1912) stop_this_handle(handle);
7a4b188f0c0b4 (Jan Kara 2016-06-30 11:30:21 -0400 1913)
a51dca9cd3bb4 (Theodore Ts'o 2010-08-02 08:43:25 -0400 1914) if (wait_for_commit)
a51dca9cd3bb4 (Theodore Ts'o 2010-08-02 08:43:25 -0400 1915) err = jbd2_log_wait_commit(journal, tid);
a51dca9cd3bb4 (Theodore Ts'o 2010-08-02 08:43:25 -0400 1916)
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 1917) free_and_exit:
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 1918) if (handle->h_rsv_handle)
ec8b6f600e49d (Jan Kara 2019-11-05 17:44:23 +0100 1919) jbd2_free_handle(handle->h_rsv_handle);
af1e76d6b3f37 (Mingming Cao 2007-10-16 18:38:25 -0400 1920) jbd2_free_handle(handle);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1921) return err;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1922) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1923)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1924) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1925) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1926) * List management code snippets: various functions for manipulating the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1927) * transaction buffer lists.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1928) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1929) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1930)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1931) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1932) * Append a buffer to a transaction list, given the transaction's list head
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1933) * pointer.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1934) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1935) * j_list_lock is held.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1936) *
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1937) * jh->b_state_lock is held.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1938) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1939)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1940) static inline void
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1941) __blist_add_buffer(struct journal_head **list, struct journal_head *jh)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1942) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1943) if (!*list) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1944) jh->b_tnext = jh->b_tprev = jh;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1945) *list = jh;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1946) } else {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1947) /* Insert at the tail of the list to preserve order */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1948) struct journal_head *first = *list, *last = first->b_tprev;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1949) jh->b_tprev = last;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1950) jh->b_tnext = first;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1951) last->b_tnext = first->b_tprev = jh;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1952) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1953) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1954)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1955) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1956) * Remove a buffer from a transaction list, given the transaction's list
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1957) * head pointer.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1958) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1959) * Called with j_list_lock held, and the journal may not be locked.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1960) *
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1961) * jh->b_state_lock is held.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1962) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1963)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1964) static inline void
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1965) __blist_del_buffer(struct journal_head **list, struct journal_head *jh)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1966) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1967) if (*list == jh) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1968) *list = jh->b_tnext;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1969) if (*list == jh)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1970) *list = NULL;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1971) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1972) jh->b_tprev->b_tnext = jh->b_tnext;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1973) jh->b_tnext->b_tprev = jh->b_tprev;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1974) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1975)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1976) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1977) * Remove a buffer from the appropriate transaction list.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1978) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1979) * Note that this function can *change* the value of
f5113effc2a2e (Jan Kara 2013-06-04 12:01:45 -0400 1980) * bh->b_transaction->t_buffers, t_forget, t_shadow_list, t_log_list or
f5113effc2a2e (Jan Kara 2013-06-04 12:01:45 -0400 1981) * t_reserved_list. If the caller is holding onto a copy of one of these
f5113effc2a2e (Jan Kara 2013-06-04 12:01:45 -0400 1982) * pointers, it could go bad. Generally the caller needs to re-read the
f5113effc2a2e (Jan Kara 2013-06-04 12:01:45 -0400 1983) * pointer from the transaction_t.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1984) *
5bebccf901278 (Jan Kara 2012-03-13 22:25:06 -0400 1985) * Called under j_list_lock.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1986) */
5bebccf901278 (Jan Kara 2012-03-13 22:25:06 -0400 1987) static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1988) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1989) struct journal_head **list = NULL;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1990) transaction_t *transaction;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1991) struct buffer_head *bh = jh2bh(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1992)
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 1993) lockdep_assert_held(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1994) transaction = jh->b_transaction;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1995) if (transaction)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1996) assert_spin_locked(&transaction->t_journal->j_list_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1997)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1998) J_ASSERT_JH(jh, jh->b_jlist < BJ_Types);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 1999) if (jh->b_jlist != BJ_None)
4019191be7316 (Mingming Cao 2008-01-28 23:58:27 -0500 2000) J_ASSERT_JH(jh, transaction != NULL);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2001)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2002) switch (jh->b_jlist) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2003) case BJ_None:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2004) return;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2005) case BJ_Metadata:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2006) transaction->t_nr_buffers--;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2007) J_ASSERT_JH(jh, transaction->t_nr_buffers >= 0);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2008) list = &transaction->t_buffers;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2009) break;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2010) case BJ_Forget:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2011) list = &transaction->t_forget;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2012) break;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2013) case BJ_Shadow:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2014) list = &transaction->t_shadow_list;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2015) break;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2016) case BJ_Reserved:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2017) list = &transaction->t_reserved_list;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2018) break;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2019) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2020)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2021) __blist_del_buffer(list, jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2022) jh->b_jlist = BJ_None;
e112666b4959b (Theodore Ts'o 2017-02-04 23:14:19 -0500 2023) if (transaction && is_journal_aborted(transaction->t_journal))
e112666b4959b (Theodore Ts'o 2017-02-04 23:14:19 -0500 2024) clear_buffer_jbddirty(bh);
e112666b4959b (Theodore Ts'o 2017-02-04 23:14:19 -0500 2025) else if (test_clear_buffer_jbddirty(bh))
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2026) mark_buffer_dirty(bh); /* Expose it to the VM */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2027) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2028)
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2029) /*
93108ebb848df (Jan Kara 2019-08-09 14:42:29 +0200 2030) * Remove buffer from all transactions. The caller is responsible for dropping
93108ebb848df (Jan Kara 2019-08-09 14:42:29 +0200 2031) * the jh reference that belonged to the transaction.
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2032) *
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2033) * Called with bh_state lock and j_list_lock
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2034) */
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2035) static void __jbd2_journal_unfile_buffer(struct journal_head *jh)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2036) {
24dc9864914eb (Lukas Czerner 2020-06-17 11:25:49 +0200 2037) J_ASSERT_JH(jh, jh->b_transaction != NULL);
24dc9864914eb (Lukas Czerner 2020-06-17 11:25:49 +0200 2038) J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
24dc9864914eb (Lukas Czerner 2020-06-17 11:25:49 +0200 2039)
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 2040) __jbd2_journal_temp_unlink_buffer(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2041) jh->b_transaction = NULL;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2042) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2043)
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 2044) void jbd2_journal_unfile_buffer(journal_t *journal, struct journal_head *jh)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2045) {
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2046) struct buffer_head *bh = jh2bh(jh);
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2047)
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2048) /* Get reference so that buffer cannot be freed before we unlock it */
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2049) get_bh(bh);
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 2050) spin_lock(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2051) spin_lock(&journal->j_list_lock);
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 2052) __jbd2_journal_unfile_buffer(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2053) spin_unlock(&journal->j_list_lock);
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 2054) spin_unlock(&jh->b_state_lock);
93108ebb848df (Jan Kara 2019-08-09 14:42:29 +0200 2055) jbd2_journal_put_journal_head(jh);
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2056) __brelse(bh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2057) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2058)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2059) /*
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 2060) * Called from jbd2_journal_try_to_free_buffers().
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2061) *
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 2062) * Called under jh->b_state_lock
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2063) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2064) static void
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2065) __journal_try_to_free_buffer(journal_t *journal, struct buffer_head *bh)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2066) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2067) struct journal_head *jh;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2068)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2069) jh = bh2jh(bh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2070)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2071) if (buffer_locked(bh) || buffer_dirty(bh))
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2072) goto out;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2073)
d2eb0b998990a (Theodore Ts'o 2014-03-09 00:07:19 -0500 2074) if (jh->b_next_transaction != NULL || jh->b_transaction != NULL)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2075) goto out;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2076)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2077) spin_lock(&journal->j_list_lock);
d2eb0b998990a (Theodore Ts'o 2014-03-09 00:07:19 -0500 2078) if (jh->b_cp_transaction != NULL) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2079) /* written-back checkpointed metadata buffer */
c254c9ec14d5c (Jan Kara 2012-03-13 22:27:44 -0400 2080) JBUFFER_TRACE(jh, "remove from checkpoint list");
c254c9ec14d5c (Jan Kara 2012-03-13 22:27:44 -0400 2081) __jbd2_journal_remove_checkpoint(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2082) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2083) spin_unlock(&journal->j_list_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2084) out:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2085) return;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2086) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2087)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2088) /**
2bf31d94423c8 (Mauro Carvalho Chehab 2020-11-16 11:18:08 +0100 2089) * jbd2_journal_try_to_free_buffers() - try to free page buffers.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2090) * @journal: journal for operation
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2091) * @page: to try and free
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2092) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2093) * For all the buffers on this page,
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2094) * if they are fully written out ordered data, move them onto BUF_CLEAN
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2095) * so try_to_free_buffers() can reap them.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2096) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2097) * This function returns non-zero if we wish try_to_free_buffers()
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2098) * to be called. We do this if the page is releasable by try_to_free_buffers().
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2099) * We also do it if the page has locked or dirty buffers and the caller wants
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2100) * us to perform sync or async writeout.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2101) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2102) * This complicates JBD locking somewhat. We aren't protected by the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2103) * BKL here. We wish to remove the buffer from its committing or
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 2104) * running transaction's ->t_datalist via __jbd2_journal_unfile_buffer.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2105) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2106) * This may *change* the value of transaction_t->t_datalist, so anyone
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2107) * who looks at t_datalist needs to lock against this function.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2108) *
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 2109) * Even worse, someone may be doing a jbd2_journal_dirty_data on this
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 2110) * buffer. So we need to lock against that. jbd2_journal_dirty_data()
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2111) * will come out of the lock with the buffer dirty, which makes it
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2112) * ineligible for release here.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2113) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2114) * Who else is affected by this? hmm... Really the only contender
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2115) * is do_get_write_access() - it could be looking at the buffer while
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2116) * journal_try_to_free_buffer() is changing its state. But that
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2117) * cannot happen because we never reallocate freed data as metadata
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2118) * while the data is part of a transaction. Yes?
530576bbf379f (Mingming Cao 2008-07-13 21:06:39 -0400 2119) *
530576bbf379f (Mingming Cao 2008-07-13 21:06:39 -0400 2120) * Return 0 on failure, 1 on success
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2121) */
529a781ee07aa (zhangyi (F) 2020-06-20 10:54:27 +0800 2122) int jbd2_journal_try_to_free_buffers(journal_t *journal, struct page *page)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2123) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2124) struct buffer_head *head;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2125) struct buffer_head *bh;
c044f3d8360d2 (zhangyi (F) 2020-06-20 10:54:26 +0800 2126) bool has_write_io_error = false;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2127) int ret = 0;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2128)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2129) J_ASSERT(PageLocked(page));
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2130)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2131) head = page_buffers(page);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2132) bh = head;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2133) do {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2134) struct journal_head *jh;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2135)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2136) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2137) * We take our own ref against the journal_head here to avoid
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2138) * having to add tons of locking around each instance of
530576bbf379f (Mingming Cao 2008-07-13 21:06:39 -0400 2139) * jbd2_journal_put_journal_head().
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2140) */
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 2141) jh = jbd2_journal_grab_journal_head(bh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2142) if (!jh)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2143) continue;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2144)
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 2145) spin_lock(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2146) __journal_try_to_free_buffer(journal, bh);
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 2147) spin_unlock(&jh->b_state_lock);
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 2148) jbd2_journal_put_journal_head(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2149) if (buffer_jbd(bh))
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2150) goto busy;
c044f3d8360d2 (zhangyi (F) 2020-06-20 10:54:26 +0800 2151)
c044f3d8360d2 (zhangyi (F) 2020-06-20 10:54:26 +0800 2152) /*
c044f3d8360d2 (zhangyi (F) 2020-06-20 10:54:26 +0800 2153) * If we free a metadata buffer which has been failed to
c044f3d8360d2 (zhangyi (F) 2020-06-20 10:54:26 +0800 2154) * write out, the jbd2 checkpoint procedure will not detect
c044f3d8360d2 (zhangyi (F) 2020-06-20 10:54:26 +0800 2155) * this failure and may lead to filesystem inconsistency
c044f3d8360d2 (zhangyi (F) 2020-06-20 10:54:26 +0800 2156) * after cleanup journal tail.
c044f3d8360d2 (zhangyi (F) 2020-06-20 10:54:26 +0800 2157) */
c044f3d8360d2 (zhangyi (F) 2020-06-20 10:54:26 +0800 2158) if (buffer_write_io_error(bh)) {
c044f3d8360d2 (zhangyi (F) 2020-06-20 10:54:26 +0800 2159) pr_err("JBD2: Error while async write back metadata bh %llu.",
c044f3d8360d2 (zhangyi (F) 2020-06-20 10:54:26 +0800 2160) (unsigned long long)bh->b_blocknr);
c044f3d8360d2 (zhangyi (F) 2020-06-20 10:54:26 +0800 2161) has_write_io_error = true;
c044f3d8360d2 (zhangyi (F) 2020-06-20 10:54:26 +0800 2162) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2163) } while ((bh = bh->b_this_page) != head);
530576bbf379f (Mingming Cao 2008-07-13 21:06:39 -0400 2164)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2165) ret = try_to_free_buffers(page);
530576bbf379f (Mingming Cao 2008-07-13 21:06:39 -0400 2166)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2167) busy:
c044f3d8360d2 (zhangyi (F) 2020-06-20 10:54:26 +0800 2168) if (has_write_io_error)
c044f3d8360d2 (zhangyi (F) 2020-06-20 10:54:26 +0800 2169) jbd2_journal_abort(journal, -EIO);
c044f3d8360d2 (zhangyi (F) 2020-06-20 10:54:26 +0800 2170)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2171) return ret;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2172) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2173)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2174) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2175) * This buffer is no longer needed. If it is on an older transaction's
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2176) * checkpoint list we need to record it on this transaction's forget list
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2177) * to pin this buffer (and hence its checkpointing transaction) down until
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2178) * this transaction commits. If the buffer isn't on a checkpoint list, we
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2179) * release it.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2180) * Returns non-zero if JBD no longer has an interest in the buffer.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2181) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2182) * Called under j_list_lock.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2183) *
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 2184) * Called under jh->b_state_lock.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2185) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2186) static int __dispose_buffer(struct journal_head *jh, transaction_t *transaction)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2187) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2188) int may_free = 1;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2189) struct buffer_head *bh = jh2bh(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2190)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2191) if (jh->b_cp_transaction) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2192) JBUFFER_TRACE(jh, "on running+cp transaction");
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2193) __jbd2_journal_temp_unlink_buffer(jh);
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 2194) /*
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 2195) * We don't want to write the buffer anymore, clear the
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 2196) * bit so that we don't confuse checks in
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 2197) * __journal_file_buffer
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 2198) */
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 2199) clear_buffer_dirty(bh);
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 2200) __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2201) may_free = 0;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2202) } else {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2203) JBUFFER_TRACE(jh, "on running transaction");
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2204) __jbd2_journal_unfile_buffer(jh);
93108ebb848df (Jan Kara 2019-08-09 14:42:29 +0200 2205) jbd2_journal_put_journal_head(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2206) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2207) return may_free;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2208) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2209)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2210) /*
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 2211) * jbd2_journal_invalidatepage
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2212) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2213) * This code is tricky. It has a number of cases to deal with.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2214) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2215) * There are two invariants which this code relies on:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2216) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2217) * i_size must be updated on disk before we start calling invalidatepage on the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2218) * data.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2219) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2220) * This is done in ext3 by defining an ext3_setattr method which
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2221) * updates i_size before truncate gets going. By maintaining this
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2222) * invariant, we can be sure that it is safe to throw away any buffers
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2223) * attached to the current transaction: once the transaction commits,
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2224) * we know that the data will not be needed.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2225) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2226) * Note however that we can *not* throw away data belonging to the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2227) * previous, committing transaction!
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2228) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2229) * Any disk blocks which *are* part of the previous, committing
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2230) * transaction (and which therefore cannot be discarded immediately) are
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2231) * not going to be reused in the new running transaction
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2232) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2233) * The bitmap committed_data images guarantee this: any block which is
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2234) * allocated in one transaction and removed in the next will be marked
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2235) * as in-use in the committed_data bitmap, so cannot be reused until
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2236) * the next transaction to delete the block commits. This means that
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2237) * leaving committing buffers dirty is quite safe: the disk blocks
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2238) * cannot be reallocated to a different file and so buffer aliasing is
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2239) * not possible.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2240) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2241) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2242) * The above applies mainly to ordered data mode. In writeback mode we
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2243) * don't make guarantees about the order in which data hits disk --- in
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2244) * particular we don't guarantee that new dirty data is flushed before
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2245) * transaction commit --- so it is always safe just to discard data
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2246) * immediately in that mode. --sct
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2247) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2248)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2249) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2250) * The journal_unmap_buffer helper function returns zero if the buffer
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2251) * concerned remains pinned as an anonymous buffer belonging to an older
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2252) * transaction.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2253) *
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2254) * We're outside-transaction here. Either or both of j_running_transaction
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2255) * and j_committing_transaction may be NULL.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2256) */
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2257) static int journal_unmap_buffer(journal_t *journal, struct buffer_head *bh,
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2258) int partial_page)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2259) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2260) transaction_t *transaction;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2261) struct journal_head *jh;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2262) int may_free = 1;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2263)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2264) BUFFER_TRACE(bh, "entry");
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2265)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2266) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2267) * It is safe to proceed here without the j_list_lock because the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2268) * buffers cannot be stolen by try_to_free_buffers as long as we are
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2269) * holding the page lock. --sct
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2270) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2271)
d84560f74d852 (Thomas Gleixner 2019-08-09 14:42:27 +0200 2272) jh = jbd2_journal_grab_journal_head(bh);
d84560f74d852 (Thomas Gleixner 2019-08-09 14:42:27 +0200 2273) if (!jh)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2274) goto zap_buffer_unlocked;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2275)
87c89c232c8f7 (Jan Kara 2008-07-11 19:27:31 -0400 2276) /* OK, we have data buffer in journaled mode */
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 2277) write_lock(&journal->j_state_lock);
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 2278) spin_lock(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2279) spin_lock(&journal->j_list_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2280)
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2281) /*
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2282) * We cannot remove the buffer from checkpoint lists until the
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2283) * transaction adding inode to orphan list (let's call it T)
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2284) * is committed. Otherwise if the transaction changing the
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2285) * buffer would be cleaned from the journal before T is
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2286) * committed, a crash will cause that the correct contents of
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2287) * the buffer will be lost. On the other hand we have to
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2288) * clear the buffer dirty bit at latest at the moment when the
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2289) * transaction marking the buffer as freed in the filesystem
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2290) * structures is committed because from that moment on the
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2291) * block can be reallocated and used by a different page.
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2292) * Since the block hasn't been freed yet but the inode has
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2293) * already been added to orphan list, it is safe for us to add
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2294) * the buffer to BJ_Forget list of the newest transaction.
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2295) *
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2296) * Also we have to clear buffer_mapped flag of a truncated buffer
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2297) * because the buffer_head may be attached to the page straddling
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2298) * i_size (can happen only when blocksize < pagesize) and thus the
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2299) * buffer_head can be reused when the file is extended again. So we end
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2300) * up keeping around invalidated buffers attached to transactions'
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2301) * BJ_Forget list just to stop checkpointing code from cleaning up
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2302) * the transaction this buffer was modified in.
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2303) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2304) transaction = jh->b_transaction;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2305) if (transaction == NULL) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2306) /* First case: not on any transaction. If it
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2307) * has no checkpoint link, then we can zap it:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2308) * it's a writeback-mode buffer so we don't care
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2309) * if it hits disk safely. */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2310) if (!jh->b_cp_transaction) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2311) JBUFFER_TRACE(jh, "not on any transaction: zap");
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2312) goto zap_buffer;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2313) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2314)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2315) if (!buffer_dirty(bh)) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2316) /* bdflush has written it. We can drop it now */
bc23f0c8d7ccd (Jan Kara 2015-11-24 15:34:35 -0500 2317) __jbd2_journal_remove_checkpoint(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2318) goto zap_buffer;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2319) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2320)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2321) /* OK, it must be in the journal but still not
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2322) * written fully to disk: it's metadata or
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2323) * journaled data... */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2324)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2325) if (journal->j_running_transaction) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2326) /* ... and once the current transaction has
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2327) * committed, the buffer won't be needed any
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2328) * longer. */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2329) JBUFFER_TRACE(jh, "checkpointed: add to BJ_Forget");
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2330) may_free = __dispose_buffer(jh,
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2331) journal->j_running_transaction);
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2332) goto zap_buffer;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2333) } else {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2334) /* There is no currently-running transaction. So the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2335) * orphan record which we wrote for this file must have
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2336) * passed into commit. We must attach this buffer to
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2337) * the committing transaction, if it exists. */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2338) if (journal->j_committing_transaction) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2339) JBUFFER_TRACE(jh, "give to committing trans");
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2340) may_free = __dispose_buffer(jh,
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2341) journal->j_committing_transaction);
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2342) goto zap_buffer;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2343) } else {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2344) /* The orphan record's transaction has
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2345) * committed. We can cleanse this buffer */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2346) clear_buffer_jbddirty(bh);
bc23f0c8d7ccd (Jan Kara 2015-11-24 15:34:35 -0500 2347) __jbd2_journal_remove_checkpoint(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2348) goto zap_buffer;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2349) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2350) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2351) } else if (transaction == journal->j_committing_transaction) {
9b57988db9b2c (Eric Sandeen 2006-10-28 10:38:28 -0700 2352) JBUFFER_TRACE(jh, "on committing transaction");
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2353) /*
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2354) * The buffer is committing, we simply cannot touch
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2355) * it. If the page is straddling i_size we have to wait
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2356) * for commit and try again.
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2357) */
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2358) if (partial_page) {
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2359) spin_unlock(&journal->j_list_lock);
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 2360) spin_unlock(&jh->b_state_lock);
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2361) write_unlock(&journal->j_state_lock);
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 2362) jbd2_journal_put_journal_head(jh);
53e872681fed6 (Jan Kara 2012-12-25 13:29:52 -0500 2363) return -EBUSY;
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2364) }
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2365) /*
6a66a7ded12ba (zhangyi (F) 2020-02-13 14:38:20 +0800 2366) * OK, buffer won't be reachable after truncate. We just clear
6a66a7ded12ba (zhangyi (F) 2020-02-13 14:38:20 +0800 2367) * b_modified to not confuse transaction credit accounting, and
6a66a7ded12ba (zhangyi (F) 2020-02-13 14:38:20 +0800 2368) * set j_next_transaction to the running transaction (if there
6a66a7ded12ba (zhangyi (F) 2020-02-13 14:38:20 +0800 2369) * is one) and mark buffer as freed so that commit code knows
6a66a7ded12ba (zhangyi (F) 2020-02-13 14:38:20 +0800 2370) * it should clear dirty bits when it is done with the buffer.
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2371) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2372) set_buffer_freed(bh);
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2373) if (journal->j_running_transaction && buffer_jbddirty(bh))
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2374) jh->b_next_transaction = journal->j_running_transaction;
6a66a7ded12ba (zhangyi (F) 2020-02-13 14:38:20 +0800 2375) jh->b_modified = 0;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2376) spin_unlock(&journal->j_list_lock);
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 2377) spin_unlock(&jh->b_state_lock);
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 2378) write_unlock(&journal->j_state_lock);
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 2379) jbd2_journal_put_journal_head(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2380) return 0;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2381) } else {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2382) /* Good, the buffer belongs to the running transaction.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2383) * We are writing our own transaction's data, not any
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2384) * previous one's, so it is safe to throw it away
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2385) * (remember that we expect the filesystem to have set
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2386) * i_size already for this truncate so recovery will not
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2387) * expose the disk blocks we are discarding here.) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2388) J_ASSERT_JH(jh, transaction == journal->j_running_transaction);
9b57988db9b2c (Eric Sandeen 2006-10-28 10:38:28 -0700 2389) JBUFFER_TRACE(jh, "on running transaction");
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2390) may_free = __dispose_buffer(jh, transaction);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2391) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2392)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2393) zap_buffer:
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2394) /*
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2395) * This is tricky. Although the buffer is truncated, it may be reused
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2396) * if blocksize < pagesize and it is attached to the page straddling
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2397) * EOF. Since the buffer might have been added to BJ_Forget list of the
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2398) * running transaction, journal_get_write_access() won't clear
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2399) * b_modified and credit accounting gets confused. So clear b_modified
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2400) * here.
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2401) */
b794e7a6ebfbd (Jan Kara 2012-09-26 23:11:13 -0400 2402) jh->b_modified = 0;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2403) spin_unlock(&journal->j_list_lock);
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 2404) spin_unlock(&jh->b_state_lock);
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 2405) write_unlock(&journal->j_state_lock);
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 2406) jbd2_journal_put_journal_head(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2407) zap_buffer_unlocked:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2408) clear_buffer_dirty(bh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2409) J_ASSERT_BH(bh, !buffer_jbddirty(bh));
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2410) clear_buffer_mapped(bh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2411) clear_buffer_req(bh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2412) clear_buffer_new(bh);
15291164b22a3 (Eric Sandeen 2012-02-20 17:53:01 -0500 2413) clear_buffer_delay(bh);
15291164b22a3 (Eric Sandeen 2012-02-20 17:53:01 -0500 2414) clear_buffer_unwritten(bh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2415) bh->b_bdev = NULL;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2416) return may_free;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2417) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2418)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2419) /**
2bf31d94423c8 (Mauro Carvalho Chehab 2020-11-16 11:18:08 +0100 2420) * jbd2_journal_invalidatepage()
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2421) * @journal: journal to use for flush...
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2422) * @page: page to flush
259709b07da10 (Lukas Czerner 2013-05-21 23:20:03 -0400 2423) * @offset: start of the range to invalidate
259709b07da10 (Lukas Czerner 2013-05-21 23:20:03 -0400 2424) * @length: length of the range to invalidate
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2425) *
259709b07da10 (Lukas Czerner 2013-05-21 23:20:03 -0400 2426) * Reap page buffers containing data after in the specified range in page.
259709b07da10 (Lukas Czerner 2013-05-21 23:20:03 -0400 2427) * Can return -EBUSY if buffers are part of the committing transaction and
259709b07da10 (Lukas Czerner 2013-05-21 23:20:03 -0400 2428) * the page is straddling i_size. Caller then has to wait for current commit
259709b07da10 (Lukas Czerner 2013-05-21 23:20:03 -0400 2429) * and try again.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2430) */
53e872681fed6 (Jan Kara 2012-12-25 13:29:52 -0500 2431) int jbd2_journal_invalidatepage(journal_t *journal,
53e872681fed6 (Jan Kara 2012-12-25 13:29:52 -0500 2432) struct page *page,
259709b07da10 (Lukas Czerner 2013-05-21 23:20:03 -0400 2433) unsigned int offset,
259709b07da10 (Lukas Czerner 2013-05-21 23:20:03 -0400 2434) unsigned int length)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2435) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2436) struct buffer_head *head, *bh, *next;
259709b07da10 (Lukas Czerner 2013-05-21 23:20:03 -0400 2437) unsigned int stop = offset + length;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2438) unsigned int curr_off = 0;
09cbfeaf1a5a6 (Kirill A. Shutemov 2016-04-01 15:29:47 +0300 2439) int partial_page = (offset || length < PAGE_SIZE);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2440) int may_free = 1;
53e872681fed6 (Jan Kara 2012-12-25 13:29:52 -0500 2441) int ret = 0;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2442)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2443) if (!PageLocked(page))
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2444) BUG();
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2445) if (!page_has_buffers(page))
53e872681fed6 (Jan Kara 2012-12-25 13:29:52 -0500 2446) return 0;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2447)
09cbfeaf1a5a6 (Kirill A. Shutemov 2016-04-01 15:29:47 +0300 2448) BUG_ON(stop > PAGE_SIZE || stop < length);
259709b07da10 (Lukas Czerner 2013-05-21 23:20:03 -0400 2449)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2450) /* We will potentially be playing with lists other than just the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2451) * data lists (especially for journaled data mode), so be
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2452) * cautious in our locking. */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2453)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2454) head = bh = page_buffers(page);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2455) do {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2456) unsigned int next_off = curr_off + bh->b_size;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2457) next = bh->b_this_page;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2458)
259709b07da10 (Lukas Czerner 2013-05-21 23:20:03 -0400 2459) if (next_off > stop)
259709b07da10 (Lukas Czerner 2013-05-21 23:20:03 -0400 2460) return 0;
259709b07da10 (Lukas Czerner 2013-05-21 23:20:03 -0400 2461)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2462) if (offset <= curr_off) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2463) /* This block is wholly outside the truncation point */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2464) lock_buffer(bh);
259709b07da10 (Lukas Czerner 2013-05-21 23:20:03 -0400 2465) ret = journal_unmap_buffer(journal, bh, partial_page);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2466) unlock_buffer(bh);
53e872681fed6 (Jan Kara 2012-12-25 13:29:52 -0500 2467) if (ret < 0)
53e872681fed6 (Jan Kara 2012-12-25 13:29:52 -0500 2468) return ret;
53e872681fed6 (Jan Kara 2012-12-25 13:29:52 -0500 2469) may_free &= ret;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2470) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2471) curr_off = next_off;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2472) bh = next;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2473)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2474) } while (bh != head);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2475)
259709b07da10 (Lukas Czerner 2013-05-21 23:20:03 -0400 2476) if (!partial_page) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2477) if (may_free && try_to_free_buffers(page))
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2478) J_ASSERT(!page_has_buffers(page));
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2479) }
53e872681fed6 (Jan Kara 2012-12-25 13:29:52 -0500 2480) return 0;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2481) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2482)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2483) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2484) * File a buffer on the given transaction list.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2485) */
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 2486) void __jbd2_journal_file_buffer(struct journal_head *jh,
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2487) transaction_t *transaction, int jlist)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2488) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2489) struct journal_head **list = NULL;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2490) int was_dirty = 0;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2491) struct buffer_head *bh = jh2bh(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2492)
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 2493) lockdep_assert_held(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2494) assert_spin_locked(&transaction->t_journal->j_list_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2495)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2496) J_ASSERT_JH(jh, jh->b_jlist < BJ_Types);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2497) J_ASSERT_JH(jh, jh->b_transaction == transaction ||
4019191be7316 (Mingming Cao 2008-01-28 23:58:27 -0500 2498) jh->b_transaction == NULL);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2499)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2500) if (jh->b_transaction && jh->b_jlist == jlist)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2501) return;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2502)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2503) if (jlist == BJ_Metadata || jlist == BJ_Reserved ||
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2504) jlist == BJ_Shadow || jlist == BJ_Forget) {
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 2505) /*
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 2506) * For metadata buffers, we track dirty bit in buffer_jbddirty
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 2507) * instead of buffer_dirty. We should not see a dirty bit set
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 2508) * here because we clear it in do_get_write_access but e.g.
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 2509) * tune2fs can modify the sb and set the dirty bit at any time
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 2510) * so we try to gracefully handle that.
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 2511) */
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 2512) if (buffer_dirty(bh))
f91d1d0417102 (Jan Kara 2009-07-13 16:16:20 -0400 2513) warn_dirty_buffer(bh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2514) if (test_clear_buffer_dirty(bh) ||
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2515) test_clear_buffer_jbddirty(bh))
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2516) was_dirty = 1;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2517) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2518)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2519) if (jh->b_transaction)
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 2520) __jbd2_journal_temp_unlink_buffer(jh);
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2521) else
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2522) jbd2_journal_grab_journal_head(bh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2523) jh->b_transaction = transaction;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2524)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2525) switch (jlist) {
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2526) case BJ_None:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2527) J_ASSERT_JH(jh, !jh->b_committed_data);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2528) J_ASSERT_JH(jh, !jh->b_frozen_data);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2529) return;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2530) case BJ_Metadata:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2531) transaction->t_nr_buffers++;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2532) list = &transaction->t_buffers;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2533) break;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2534) case BJ_Forget:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2535) list = &transaction->t_forget;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2536) break;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2537) case BJ_Shadow:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2538) list = &transaction->t_shadow_list;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2539) break;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2540) case BJ_Reserved:
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2541) list = &transaction->t_reserved_list;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2542) break;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2543) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2544)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2545) __blist_add_buffer(list, jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2546) jh->b_jlist = jlist;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2547)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2548) if (was_dirty)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2549) set_buffer_jbddirty(bh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2550) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2551)
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 2552) void jbd2_journal_file_buffer(struct journal_head *jh,
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2553) transaction_t *transaction, int jlist)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2554) {
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 2555) spin_lock(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2556) spin_lock(&transaction->t_journal->j_list_lock);
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 2557) __jbd2_journal_file_buffer(jh, transaction, jlist);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2558) spin_unlock(&transaction->t_journal->j_list_lock);
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 2559) spin_unlock(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2560) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2561)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2562) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2563) * Remove a buffer from its current buffer list in preparation for
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2564) * dropping it from its current transaction entirely. If the buffer has
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2565) * already started to be used by a subsequent transaction, refile the
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2566) * buffer on that transaction's metadata list.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2567) *
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2568) * Called under j_list_lock
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 2569) * Called under jh->b_state_lock
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2570) *
93108ebb848df (Jan Kara 2019-08-09 14:42:29 +0200 2571) * When this function returns true, there's no next transaction to refile to
93108ebb848df (Jan Kara 2019-08-09 14:42:29 +0200 2572) * and the caller has to drop jh reference through
93108ebb848df (Jan Kara 2019-08-09 14:42:29 +0200 2573) * jbd2_journal_put_journal_head().
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2574) */
93108ebb848df (Jan Kara 2019-08-09 14:42:29 +0200 2575) bool __jbd2_journal_refile_buffer(struct journal_head *jh)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2576) {
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2577) int was_dirty, jlist;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2578) struct buffer_head *bh = jh2bh(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2579)
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 2580) lockdep_assert_held(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2581) if (jh->b_transaction)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2582) assert_spin_locked(&jh->b_transaction->t_journal->j_list_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2583)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2584) /* If the buffer is now unused, just drop it. */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2585) if (jh->b_next_transaction == NULL) {
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 2586) __jbd2_journal_unfile_buffer(jh);
93108ebb848df (Jan Kara 2019-08-09 14:42:29 +0200 2587) return true;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2588) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2589)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2590) /*
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2591) * It has been modified by a later transaction: add it to the new
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2592) * transaction's metadata list.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2593) */
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2594)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2595) was_dirty = test_clear_buffer_jbddirty(bh);
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 2596) __jbd2_journal_temp_unlink_buffer(jh);
24dc9864914eb (Lukas Czerner 2020-06-17 11:25:49 +0200 2597)
24dc9864914eb (Lukas Czerner 2020-06-17 11:25:49 +0200 2598) /*
24dc9864914eb (Lukas Czerner 2020-06-17 11:25:49 +0200 2599) * b_transaction must be set, otherwise the new b_transaction won't
24dc9864914eb (Lukas Czerner 2020-06-17 11:25:49 +0200 2600) * be holding jh reference
24dc9864914eb (Lukas Czerner 2020-06-17 11:25:49 +0200 2601) */
24dc9864914eb (Lukas Czerner 2020-06-17 11:25:49 +0200 2602) J_ASSERT_JH(jh, jh->b_transaction != NULL);
24dc9864914eb (Lukas Czerner 2020-06-17 11:25:49 +0200 2603)
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2604) /*
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2605) * We set b_transaction here because b_next_transaction will inherit
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2606) * our jh reference and thus __jbd2_journal_file_buffer() must not
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2607) * take a new one.
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2608) */
6c5d911249290 (Qian Cai 2020-02-21 23:31:11 -0500 2609) WRITE_ONCE(jh->b_transaction, jh->b_next_transaction);
6c5d911249290 (Qian Cai 2020-02-21 23:31:11 -0500 2610) WRITE_ONCE(jh->b_next_transaction, NULL);
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2611) if (buffer_freed(bh))
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2612) jlist = BJ_Forget;
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2613) else if (jh->b_modified)
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2614) jlist = BJ_Metadata;
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2615) else
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2616) jlist = BJ_Reserved;
ba869023eac83 (dingdinghua 2010-02-15 16:35:42 -0500 2617) __jbd2_journal_file_buffer(jh, jh->b_transaction, jlist);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2618) J_ASSERT_JH(jh, jh->b_transaction->t_state == T_RUNNING);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2619)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2620) if (was_dirty)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2621) set_buffer_jbddirty(bh);
93108ebb848df (Jan Kara 2019-08-09 14:42:29 +0200 2622) return false;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2623) }
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2624)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2625) /*
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2626) * __jbd2_journal_refile_buffer() with necessary locking added. We take our
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2627) * bh reference so that we can safely unlock bh.
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2628) *
de1b794130b13 (Jan Kara 2011-06-13 15:38:22 -0400 2629) * The jh and bh may be freed by this call.
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2630) */
f7f4bccb72984 (Mingming Cao 2006-10-11 01:20:59 -0700 2631) void jbd2_journal_refile_buffer(journal_t *journal, struct journal_head *jh)
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2632) {
93108ebb848df (Jan Kara 2019-08-09 14:42:29 +0200 2633) bool drop;
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2634)
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 2635) spin_lock(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2636) spin_lock(&journal->j_list_lock);
93108ebb848df (Jan Kara 2019-08-09 14:42:29 +0200 2637) drop = __jbd2_journal_refile_buffer(jh);
464170647b564 (Thomas Gleixner 2019-08-09 14:42:32 +0200 2638) spin_unlock(&jh->b_state_lock);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2639) spin_unlock(&journal->j_list_lock);
93108ebb848df (Jan Kara 2019-08-09 14:42:29 +0200 2640) if (drop)
93108ebb848df (Jan Kara 2019-08-09 14:42:29 +0200 2641) jbd2_journal_put_journal_head(jh);
470decc613ab2 (Dave Kleikamp 2006-10-11 01:20:57 -0700 2642) }
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2643)
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2644) /*
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2645) * File inode in the inode list of the handle's transaction
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2646) */
41617e1a8dec9 (Jan Kara 2016-04-24 00:56:07 -0400 2647) static int jbd2_journal_file_inode(handle_t *handle, struct jbd2_inode *jinode,
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2648) unsigned long flags, loff_t start_byte, loff_t end_byte)
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2649) {
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2650) transaction_t *transaction = handle->h_transaction;
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 2651) journal_t *journal;
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2652)
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2653) if (is_handle_aborted(handle))
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 2654) return -EROFS;
41a5b913197c3 (Theodore Ts'o 2013-07-01 08:12:41 -0400 2655) journal = transaction->t_journal;
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2656)
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2657) jbd_debug(4, "Adding inode %lu, tid:%d\n", jinode->i_vfs_inode->i_ino,
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2658) transaction->t_tid);
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2659)
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2660) spin_lock(&journal->j_list_lock);
41617e1a8dec9 (Jan Kara 2016-04-24 00:56:07 -0400 2661) jinode->i_flags |= flags;
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2662)
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2663) if (jinode->i_dirty_end) {
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2664) jinode->i_dirty_start = min(jinode->i_dirty_start, start_byte);
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2665) jinode->i_dirty_end = max(jinode->i_dirty_end, end_byte);
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2666) } else {
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2667) jinode->i_dirty_start = start_byte;
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2668) jinode->i_dirty_end = end_byte;
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2669) }
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2670)
41617e1a8dec9 (Jan Kara 2016-04-24 00:56:07 -0400 2671) /* Is inode already attached where we need it? */
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2672) if (jinode->i_transaction == transaction ||
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2673) jinode->i_next_transaction == transaction)
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2674) goto done;
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2675)
81be12c8179c1 (Jan Kara 2011-05-24 11:52:40 -0400 2676) /*
81be12c8179c1 (Jan Kara 2011-05-24 11:52:40 -0400 2677) * We only ever set this variable to 1 so the test is safe. Since
81be12c8179c1 (Jan Kara 2011-05-24 11:52:40 -0400 2678) * t_need_data_flush is likely to be set, we do the test to save some
81be12c8179c1 (Jan Kara 2011-05-24 11:52:40 -0400 2679) * cacheline bouncing
81be12c8179c1 (Jan Kara 2011-05-24 11:52:40 -0400 2680) */
81be12c8179c1 (Jan Kara 2011-05-24 11:52:40 -0400 2681) if (!transaction->t_need_data_flush)
81be12c8179c1 (Jan Kara 2011-05-24 11:52:40 -0400 2682) transaction->t_need_data_flush = 1;
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2683) /* On some different transaction's list - should be
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2684) * the committing one */
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2685) if (jinode->i_transaction) {
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2686) J_ASSERT(jinode->i_next_transaction == NULL);
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2687) J_ASSERT(jinode->i_transaction ==
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2688) journal->j_committing_transaction);
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2689) jinode->i_next_transaction = transaction;
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2690) goto done;
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2691) }
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2692) /* Not on any transaction list... */
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2693) J_ASSERT(!jinode->i_next_transaction);
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2694) jinode->i_transaction = transaction;
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2695) list_add(&jinode->i_list, &transaction->t_inode_list);
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2696) done:
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2697) spin_unlock(&journal->j_list_lock);
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2698)
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2699) return 0;
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2700) }
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2701)
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2702) int jbd2_journal_inode_ranged_write(handle_t *handle,
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2703) struct jbd2_inode *jinode, loff_t start_byte, loff_t length)
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2704) {
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2705) return jbd2_journal_file_inode(handle, jinode,
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2706) JI_WRITE_DATA | JI_WAIT_DATA, start_byte,
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2707) start_byte + length - 1);
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2708) }
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2709)
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2710) int jbd2_journal_inode_ranged_wait(handle_t *handle, struct jbd2_inode *jinode,
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2711) loff_t start_byte, loff_t length)
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2712) {
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2713) return jbd2_journal_file_inode(handle, jinode, JI_WAIT_DATA,
6ba0e7dc64a5a (Ross Zwisler 2019-06-20 17:24:56 -0400 2714) start_byte, start_byte + length - 1);
41617e1a8dec9 (Jan Kara 2016-04-24 00:56:07 -0400 2715) }
41617e1a8dec9 (Jan Kara 2016-04-24 00:56:07 -0400 2716)
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2717) /*
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2718) * File truncate and transaction commit interact with each other in a
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2719) * non-trivial way. If a transaction writing data block A is
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2720) * committing, we cannot discard the data by truncate until we have
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2721) * written them. Otherwise if we crashed after the transaction with
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2722) * write has committed but before the transaction with truncate has
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2723) * committed, we could see stale data in block A. This function is a
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2724) * helper to solve this problem. It starts writeout of the truncated
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2725) * part in case it is in the committing transaction.
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2726) *
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2727) * Filesystem code must call this function when inode is journaled in
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2728) * ordered mode before truncation happens and after the inode has been
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2729) * placed on orphan list with the new inode size. The second condition
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2730) * avoids the race that someone writes new data and we start
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2731) * committing the transaction after this function has been called but
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2732) * before a transaction for truncate is started (and furthermore it
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2733) * allows us to optimize the case where the addition to orphan list
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2734) * happens in the same transaction as write --- we don't have to write
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2735) * any data in such case).
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2736) */
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2737) int jbd2_journal_begin_ordered_truncate(journal_t *journal,
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2738) struct jbd2_inode *jinode,
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2739) loff_t new_size)
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2740) {
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2741) transaction_t *inode_trans, *commit_trans;
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2742) int ret = 0;
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2743)
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2744) /* This is a quick check to avoid locking if not necessary */
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2745) if (!jinode->i_transaction)
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2746) goto out;
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2747) /* Locks are here just to force reading of recent values, it is
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2748) * enough that the transaction was not committing before we started
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2749) * a transaction adding the inode to orphan list */
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 2750) read_lock(&journal->j_state_lock);
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2751) commit_trans = journal->j_committing_transaction;
a931da6ac9331 (Theodore Ts'o 2010-08-03 21:35:12 -0400 2752) read_unlock(&journal->j_state_lock);
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2753) spin_lock(&journal->j_list_lock);
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2754) inode_trans = jinode->i_transaction;
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2755) spin_unlock(&journal->j_list_lock);
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2756) if (inode_trans == commit_trans) {
7f5aa215088b8 (Jan Kara 2009-02-10 11:15:34 -0500 2757) ret = filemap_fdatawrite_range(jinode->i_vfs_inode->i_mapping,
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2758) new_size, LLONG_MAX);
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2759) if (ret)
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2760) jbd2_journal_abort(journal, ret);
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2761) }
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2762) out:
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2763) return ret;
c851ed5401737 (Jan Kara 2008-07-11 19:27:31 -0400 2764) }
VisionFive2 Linux kernel
StarFive Tech Linux Kernel for VisionFive (JH7110) boards (mirror)
More than 9999 Commits
32 Branches
54 Tags