blob: 325bc019ed8813ea00321594405e86c739dad5fb [file] [log] [blame]
Dave Kleikamp470decc2006-10-11 01:20:57 -07001/*
Uwe Kleine-König58862692007-05-09 07:51:49 +02002 * linux/fs/jbd2/transaction.c
Dave Kleikamp470decc2006-10-11 01:20:57 -07003 *
4 * Written by Stephen C. Tweedie <sct@redhat.com>, 1998
5 *
6 * Copyright 1998 Red Hat corp --- All Rights Reserved
7 *
8 * This file is part of the Linux kernel and is made available under
9 * the terms of the GNU General Public License, version 2, or at your
10 * option, any later version, incorporated herein by reference.
11 *
12 * Generic filesystem transaction handling code; part of the ext2fs
13 * journaling system.
14 *
15 * This file manages transactions (compound commits managed by the
16 * journaling code) and handles (individual atomic operations by the
17 * filesystem).
18 */
19
20#include <linux/time.h>
21#include <linux/fs.h>
Mingming Caof7f4bcc2006-10-11 01:20:59 -070022#include <linux/jbd2.h>
Dave Kleikamp470decc2006-10-11 01:20:57 -070023#include <linux/errno.h>
24#include <linux/slab.h>
25#include <linux/timer.h>
Dave Kleikamp470decc2006-10-11 01:20:57 -070026#include <linux/mm.h>
27#include <linux/highmem.h>
Josef Bacike07f7182008-11-26 01:14:26 -050028#include <linux/hrtimer.h>
Theodore Ts'o47def822010-07-27 11:56:05 -040029#include <linux/backing-dev.h>
Randy Dunlap44705752011-10-27 04:05:13 -040030#include <linux/bug.h>
Theodore Ts'o47def822010-07-27 11:56:05 -040031#include <linux/module.h>
Dave Kleikamp470decc2006-10-11 01:20:57 -070032
Theodore Ts'o343d9c22013-02-08 13:00:22 -050033#include <trace/events/jbd2.h>
34
Adrian Bunk7ddae862006-12-06 20:38:27 -080035static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh);
Jan Karade1b7942011-06-13 15:38:22 -040036static void __jbd2_journal_unfile_buffer(struct journal_head *jh);
Adrian Bunk7ddae862006-12-06 20:38:27 -080037
Yongqiang Yang0c2022e2012-02-20 17:53:02 -050038static struct kmem_cache *transaction_cache;
39int __init jbd2_journal_init_transaction_cache(void)
40{
41 J_ASSERT(!transaction_cache);
42 transaction_cache = kmem_cache_create("jbd2_transaction_s",
43 sizeof(transaction_t),
44 0,
45 SLAB_HWCACHE_ALIGN|SLAB_TEMPORARY,
46 NULL);
47 if (transaction_cache)
48 return 0;
49 return -ENOMEM;
50}
51
52void jbd2_journal_destroy_transaction_cache(void)
53{
54 if (transaction_cache) {
55 kmem_cache_destroy(transaction_cache);
56 transaction_cache = NULL;
57 }
58}
59
60void jbd2_journal_free_transaction(transaction_t *transaction)
61{
62 if (unlikely(ZERO_OR_NULL_PTR(transaction)))
63 return;
64 kmem_cache_free(transaction_cache, transaction);
65}
66
Dave Kleikamp470decc2006-10-11 01:20:57 -070067/*
Mingming Caof7f4bcc2006-10-11 01:20:59 -070068 * jbd2_get_transaction: obtain a new transaction_t object.
Dave Kleikamp470decc2006-10-11 01:20:57 -070069 *
70 * Simply allocate and initialise a new transaction. Create it in
71 * RUNNING state and add it to the current journal (which should not
72 * have an existing running transaction: we only make a new transaction
73 * once we have started to commit the old one).
74 *
75 * Preconditions:
76 * The journal MUST be locked. We don't perform atomic mallocs on the
77 * new transaction and we can't block without protecting against other
78 * processes trying to touch the journal while it is in transition.
79 *
Dave Kleikamp470decc2006-10-11 01:20:57 -070080 */
81
82static transaction_t *
Mingming Caof7f4bcc2006-10-11 01:20:59 -070083jbd2_get_transaction(journal_t *journal, transaction_t *transaction)
Dave Kleikamp470decc2006-10-11 01:20:57 -070084{
85 transaction->t_journal = journal;
86 transaction->t_state = T_RUNNING;
Josef Bacike07f7182008-11-26 01:14:26 -050087 transaction->t_start_time = ktime_get();
Dave Kleikamp470decc2006-10-11 01:20:57 -070088 transaction->t_tid = journal->j_transaction_sequence++;
89 transaction->t_expires = jiffies + journal->j_commit_interval;
90 spin_lock_init(&transaction->t_handle_lock);
Theodore Ts'oa51dca92010-08-02 08:43:25 -040091 atomic_set(&transaction->t_updates, 0);
92 atomic_set(&transaction->t_outstanding_credits, 0);
Theodore Ts'o8dd42042010-08-03 21:38:29 -040093 atomic_set(&transaction->t_handle_count, 0);
Jan Karac851ed52008-07-11 19:27:31 -040094 INIT_LIST_HEAD(&transaction->t_inode_list);
Theodore Ts'o3e624fc2008-10-16 20:00:24 -040095 INIT_LIST_HEAD(&transaction->t_private_list);
Dave Kleikamp470decc2006-10-11 01:20:57 -070096
97 /* Set up the commit timer for the new transaction. */
Andreas Dilgerb1f485f2009-08-10 22:51:53 -040098 journal->j_commit_timer.expires = round_jiffies_up(transaction->t_expires);
Dave Kleikamp470decc2006-10-11 01:20:57 -070099 add_timer(&journal->j_commit_timer);
100
101 J_ASSERT(journal->j_running_transaction == NULL);
102 journal->j_running_transaction = transaction;
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500103 transaction->t_max_wait = 0;
104 transaction->t_start = jiffies;
Theodore Ts'o9fff24a2013-02-06 22:30:23 -0500105 transaction->t_requested = 0;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700106
107 return transaction;
108}
109
110/*
111 * Handle management.
112 *
113 * A handle_t is an object which represents a single atomic update to a
114 * filesystem, and which tracks all of the modifications which form part
115 * of that one update.
116 */
117
118/*
Tao Ma28e35e42011-05-22 21:45:26 -0400119 * Update transaction's maximum wait time, if debugging is enabled.
Theodore Ts'o6d0bf002010-08-09 17:28:38 -0400120 *
121 * In order for t_max_wait to be reliable, it must be protected by a
122 * lock. But doing so will mean that start_this_handle() can not be
123 * run in parallel on SMP systems, which limits our scalability. So
124 * unless debugging is enabled, we no longer update t_max_wait, which
125 * means that maximum wait time reported by the jbd2_run_stats
126 * tracepoint will always be zero.
127 */
Tao Ma28e35e42011-05-22 21:45:26 -0400128static inline void update_t_max_wait(transaction_t *transaction,
129 unsigned long ts)
Theodore Ts'o6d0bf002010-08-09 17:28:38 -0400130{
131#ifdef CONFIG_JBD2_DEBUG
Theodore Ts'o6d0bf002010-08-09 17:28:38 -0400132 if (jbd2_journal_enable_debug &&
133 time_after(transaction->t_start, ts)) {
134 ts = jbd2_time_diff(ts, transaction->t_start);
135 spin_lock(&transaction->t_handle_lock);
136 if (ts > transaction->t_max_wait)
137 transaction->t_max_wait = ts;
138 spin_unlock(&transaction->t_handle_lock);
139 }
140#endif
141}
142
143/*
Dave Kleikamp470decc2006-10-11 01:20:57 -0700144 * start_this_handle: Given a handle, deal with any locking or stalling
145 * needed to make sure that there is enough journal space for the handle
146 * to begin. Attach the handle to a transaction and set up the
147 * transaction's buffer credits.
148 */
149
Theodore Ts'o47def822010-07-27 11:56:05 -0400150static int start_this_handle(journal_t *journal, handle_t *handle,
Dan Carpenterd2159fb2011-09-04 10:20:14 -0400151 gfp_t gfp_mask)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700152{
Theodore Ts'oe4471832011-02-12 08:18:24 -0500153 transaction_t *transaction, *new_transaction = NULL;
154 tid_t tid;
155 int needed, need_to_start;
156 int nblocks = handle->h_buffer_credits;
Tao Ma28e35e42011-05-22 21:45:26 -0400157 unsigned long ts = jiffies;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700158
159 if (nblocks > journal->j_max_transaction_buffers) {
Eryu Guanf2a44522011-11-01 19:09:18 -0400160 printk(KERN_ERR "JBD2: %s wants too many credits (%d > %d)\n",
Dave Kleikamp470decc2006-10-11 01:20:57 -0700161 current->comm, nblocks,
162 journal->j_max_transaction_buffers);
Theodore Ts'o47def822010-07-27 11:56:05 -0400163 return -ENOSPC;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700164 }
165
166alloc_transaction:
167 if (!journal->j_running_transaction) {
Wanlong Gaob2f4edb2012-06-01 00:10:32 -0400168 new_transaction = kmem_cache_zalloc(transaction_cache,
169 gfp_mask);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700170 if (!new_transaction) {
Theodore Ts'o47def822010-07-27 11:56:05 -0400171 /*
172 * If __GFP_FS is not present, then we may be
173 * being called from inside the fs writeback
174 * layer, so we MUST NOT fail. Since
175 * __GFP_NOFAIL is going away, we will arrange
176 * to retry the allocation ourselves.
177 */
178 if ((gfp_mask & __GFP_FS) == 0) {
179 congestion_wait(BLK_RW_ASYNC, HZ/50);
180 goto alloc_transaction;
181 }
182 return -ENOMEM;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700183 }
Dave Kleikamp470decc2006-10-11 01:20:57 -0700184 }
185
186 jbd_debug(3, "New handle %p going live.\n", handle);
187
Dave Kleikamp470decc2006-10-11 01:20:57 -0700188 /*
189 * We need to hold j_state_lock until t_updates has been incremented,
190 * for proper journal barrier handling
191 */
Theodore Ts'oa931da62010-08-03 21:35:12 -0400192repeat:
193 read_lock(&journal->j_state_lock);
Theodore Ts'o5c2178e2010-10-27 21:30:04 -0400194 BUG_ON(journal->j_flags & JBD2_UNMOUNT);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700195 if (is_journal_aborted(journal) ||
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700196 (journal->j_errno != 0 && !(journal->j_flags & JBD2_ACK_ERR))) {
Theodore Ts'oa931da62010-08-03 21:35:12 -0400197 read_unlock(&journal->j_state_lock);
Yongqiang Yang0c2022e2012-02-20 17:53:02 -0500198 jbd2_journal_free_transaction(new_transaction);
Theodore Ts'o47def822010-07-27 11:56:05 -0400199 return -EROFS;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700200 }
201
202 /* Wait on the journal's transaction barrier if necessary */
203 if (journal->j_barrier_count) {
Theodore Ts'oa931da62010-08-03 21:35:12 -0400204 read_unlock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700205 wait_event(journal->j_wait_transaction_locked,
206 journal->j_barrier_count == 0);
207 goto repeat;
208 }
209
210 if (!journal->j_running_transaction) {
Theodore Ts'oa931da62010-08-03 21:35:12 -0400211 read_unlock(&journal->j_state_lock);
212 if (!new_transaction)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700213 goto alloc_transaction;
Theodore Ts'oa931da62010-08-03 21:35:12 -0400214 write_lock(&journal->j_state_lock);
Jan Karad7961c72012-12-21 00:15:51 -0500215 if (!journal->j_running_transaction &&
216 !journal->j_barrier_count) {
Theodore Ts'oa931da62010-08-03 21:35:12 -0400217 jbd2_get_transaction(journal, new_transaction);
218 new_transaction = NULL;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700219 }
Theodore Ts'oa931da62010-08-03 21:35:12 -0400220 write_unlock(&journal->j_state_lock);
221 goto repeat;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700222 }
223
224 transaction = journal->j_running_transaction;
225
226 /*
227 * If the current transaction is locked down for commit, wait for the
228 * lock to be released.
229 */
230 if (transaction->t_state == T_LOCKED) {
231 DEFINE_WAIT(wait);
232
233 prepare_to_wait(&journal->j_wait_transaction_locked,
234 &wait, TASK_UNINTERRUPTIBLE);
Theodore Ts'oa931da62010-08-03 21:35:12 -0400235 read_unlock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700236 schedule();
237 finish_wait(&journal->j_wait_transaction_locked, &wait);
238 goto repeat;
239 }
240
241 /*
242 * If there is not enough space left in the log to write all potential
243 * buffers requested by this operation, we need to stall pending a log
244 * checkpoint to free some more log space.
245 */
Theodore Ts'o8dd42042010-08-03 21:38:29 -0400246 needed = atomic_add_return(nblocks,
247 &transaction->t_outstanding_credits);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700248
249 if (needed > journal->j_max_transaction_buffers) {
250 /*
251 * If the current transaction is already too large, then start
252 * to commit it: we can then go back and attach this handle to
253 * a new transaction.
254 */
255 DEFINE_WAIT(wait);
256
257 jbd_debug(2, "Handle %p starting new commit...\n", handle);
Theodore Ts'o8dd42042010-08-03 21:38:29 -0400258 atomic_sub(nblocks, &transaction->t_outstanding_credits);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700259 prepare_to_wait(&journal->j_wait_transaction_locked, &wait,
260 TASK_UNINTERRUPTIBLE);
Theodore Ts'oe4471832011-02-12 08:18:24 -0500261 tid = transaction->t_tid;
262 need_to_start = !tid_geq(journal->j_commit_request, tid);
Theodore Ts'oa931da62010-08-03 21:35:12 -0400263 read_unlock(&journal->j_state_lock);
Theodore Ts'oe4471832011-02-12 08:18:24 -0500264 if (need_to_start)
265 jbd2_log_start_commit(journal, tid);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700266 schedule();
267 finish_wait(&journal->j_wait_transaction_locked, &wait);
268 goto repeat;
269 }
270
271 /*
272 * The commit code assumes that it can get enough log space
273 * without forcing a checkpoint. This is *critical* for
274 * correctness: a checkpoint of a buffer which is also
275 * associated with a committing transaction creates a deadlock,
276 * so commit simply cannot force through checkpoints.
277 *
278 * We must therefore ensure the necessary space in the journal
279 * *before* starting to dirty potentially checkpointed buffers
280 * in the new transaction.
281 *
282 * The worst part is, any transaction currently committing can
283 * reduce the free space arbitrarily. Be careful to account for
284 * those buffers when checkpointing.
285 */
286
287 /*
288 * @@@ AKPM: This seems rather over-defensive. We're giving commit
289 * a _lot_ of headroom: 1/4 of the journal plus the size of
290 * the committing transaction. Really, we only need to give it
291 * committing_transaction->t_outstanding_credits plus "enough" for
292 * the log control blocks.
Uwe Kleine-Königa34f0b32010-12-10 14:55:42 +0100293 * Also, this test is inconsistent with the matching one in
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700294 * jbd2_journal_extend().
Dave Kleikamp470decc2006-10-11 01:20:57 -0700295 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700296 if (__jbd2_log_space_left(journal) < jbd_space_needed(journal)) {
Dave Kleikamp470decc2006-10-11 01:20:57 -0700297 jbd_debug(2, "Handle %p waiting for checkpoint...\n", handle);
Theodore Ts'o8dd42042010-08-03 21:38:29 -0400298 atomic_sub(nblocks, &transaction->t_outstanding_credits);
Theodore Ts'oa931da62010-08-03 21:35:12 -0400299 read_unlock(&journal->j_state_lock);
300 write_lock(&journal->j_state_lock);
301 if (__jbd2_log_space_left(journal) < jbd_space_needed(journal))
302 __jbd2_log_wait_for_space(journal);
303 write_unlock(&journal->j_state_lock);
304 goto repeat;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700305 }
306
307 /* OK, account for the buffers that this operation expects to
Theodore Ts'o8dd42042010-08-03 21:38:29 -0400308 * use and add the handle to the running transaction.
Theodore Ts'o8dd42042010-08-03 21:38:29 -0400309 */
Tao Ma28e35e42011-05-22 21:45:26 -0400310 update_t_max_wait(transaction, ts);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700311 handle->h_transaction = transaction;
Theodore Ts'o343d9c22013-02-08 13:00:22 -0500312 handle->h_requested_credits = nblocks;
313 handle->h_start_jiffies = jiffies;
Theodore Ts'oa51dca92010-08-02 08:43:25 -0400314 atomic_inc(&transaction->t_updates);
Theodore Ts'o8dd42042010-08-03 21:38:29 -0400315 atomic_inc(&transaction->t_handle_count);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700316 jbd_debug(4, "Handle %p given %d credits (total %d, free %d)\n",
Theodore Ts'oa51dca92010-08-02 08:43:25 -0400317 handle, nblocks,
318 atomic_read(&transaction->t_outstanding_credits),
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700319 __jbd2_log_space_left(journal));
Theodore Ts'oa931da62010-08-03 21:35:12 -0400320 read_unlock(&journal->j_state_lock);
Jan Kara9599b0e2009-08-17 21:23:17 -0400321
322 lock_map_acquire(&handle->h_lockdep_map);
Yongqiang Yang0c2022e2012-02-20 17:53:02 -0500323 jbd2_journal_free_transaction(new_transaction);
Theodore Ts'o47def822010-07-27 11:56:05 -0400324 return 0;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700325}
326
Mingming Cao7b751062008-01-28 23:58:27 -0500327static struct lock_class_key jbd2_handle_key;
328
Dave Kleikamp470decc2006-10-11 01:20:57 -0700329/* Allocate a new handle. This should probably be in a slab... */
330static handle_t *new_handle(int nblocks)
331{
Mingming Caoaf1e76d2007-10-16 18:38:25 -0400332 handle_t *handle = jbd2_alloc_handle(GFP_NOFS);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700333 if (!handle)
334 return NULL;
335 memset(handle, 0, sizeof(*handle));
336 handle->h_buffer_credits = nblocks;
337 handle->h_ref = 1;
338
Mingming Cao7b751062008-01-28 23:58:27 -0500339 lockdep_init_map(&handle->h_lockdep_map, "jbd2_handle",
340 &jbd2_handle_key, 0);
341
Dave Kleikamp470decc2006-10-11 01:20:57 -0700342 return handle;
343}
344
345/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700346 * handle_t *jbd2_journal_start() - Obtain a new handle.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700347 * @journal: Journal to start transaction on.
348 * @nblocks: number of block buffer we might modify
349 *
350 * We make sure that the transaction can guarantee at least nblocks of
351 * modified buffers in the log. We block until the log can guarantee
352 * that much space.
353 *
354 * This function is visible to journal users (like ext3fs), so is not
355 * called with the journal already locked.
356 *
Eryu Guanc8675162011-05-24 17:09:58 -0400357 * Return a pointer to a newly allocated handle, or an ERR_PTR() value
358 * on failure.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700359 */
Theodore Ts'o343d9c22013-02-08 13:00:22 -0500360handle_t *jbd2__journal_start(journal_t *journal, int nblocks, gfp_t gfp_mask,
361 unsigned int type, unsigned int line_no)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700362{
363 handle_t *handle = journal_current_handle();
364 int err;
365
366 if (!journal)
367 return ERR_PTR(-EROFS);
368
369 if (handle) {
370 J_ASSERT(handle->h_transaction->t_journal == journal);
371 handle->h_ref++;
372 return handle;
373 }
374
375 handle = new_handle(nblocks);
376 if (!handle)
377 return ERR_PTR(-ENOMEM);
378
379 current->journal_info = handle;
380
Theodore Ts'o47def822010-07-27 11:56:05 -0400381 err = start_this_handle(journal, handle, gfp_mask);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700382 if (err < 0) {
Mingming Caoaf1e76d2007-10-16 18:38:25 -0400383 jbd2_free_handle(handle);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700384 current->journal_info = NULL;
Dmitry Monakhovdf05c1b82013-03-02 17:08:46 -0500385 return ERR_PTR(err);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700386 }
Theodore Ts'o343d9c22013-02-08 13:00:22 -0500387 handle->h_type = type;
388 handle->h_line_no = line_no;
389 trace_jbd2_handle_start(journal->j_fs_dev->bd_dev,
390 handle->h_transaction->t_tid, type,
391 line_no, nblocks);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700392 return handle;
393}
Theodore Ts'o47def822010-07-27 11:56:05 -0400394EXPORT_SYMBOL(jbd2__journal_start);
395
396
397handle_t *jbd2_journal_start(journal_t *journal, int nblocks)
398{
Theodore Ts'o343d9c22013-02-08 13:00:22 -0500399 return jbd2__journal_start(journal, nblocks, GFP_NOFS, 0, 0);
Theodore Ts'o47def822010-07-27 11:56:05 -0400400}
401EXPORT_SYMBOL(jbd2_journal_start);
402
Dave Kleikamp470decc2006-10-11 01:20:57 -0700403
404/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700405 * int jbd2_journal_extend() - extend buffer credits.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700406 * @handle: handle to 'extend'
407 * @nblocks: nr blocks to try to extend by.
408 *
409 * Some transactions, such as large extends and truncates, can be done
410 * atomically all at once or in several stages. The operation requests
411 * a credit for a number of buffer modications in advance, but can
412 * extend its credit if it needs more.
413 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700414 * jbd2_journal_extend tries to give the running handle more buffer credits.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700415 * It does not guarantee that allocation - this is a best-effort only.
416 * The calling process MUST be able to deal cleanly with a failure to
417 * extend here.
418 *
419 * Return 0 on success, non-zero on failure.
420 *
421 * return code < 0 implies an error
422 * return code > 0 implies normal transaction-full status.
423 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700424int jbd2_journal_extend(handle_t *handle, int nblocks)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700425{
426 transaction_t *transaction = handle->h_transaction;
427 journal_t *journal = transaction->t_journal;
428 int result;
429 int wanted;
430
431 result = -EIO;
432 if (is_handle_aborted(handle))
433 goto out;
434
435 result = 1;
436
Theodore Ts'oa931da62010-08-03 21:35:12 -0400437 read_lock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700438
439 /* Don't extend a locked-down transaction! */
440 if (handle->h_transaction->t_state != T_RUNNING) {
441 jbd_debug(3, "denied handle %p %d blocks: "
442 "transaction not running\n", handle, nblocks);
443 goto error_out;
444 }
445
446 spin_lock(&transaction->t_handle_lock);
Theodore Ts'oa51dca92010-08-02 08:43:25 -0400447 wanted = atomic_read(&transaction->t_outstanding_credits) + nblocks;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700448
449 if (wanted > journal->j_max_transaction_buffers) {
450 jbd_debug(3, "denied handle %p %d blocks: "
451 "transaction too large\n", handle, nblocks);
452 goto unlock;
453 }
454
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700455 if (wanted > __jbd2_log_space_left(journal)) {
Dave Kleikamp470decc2006-10-11 01:20:57 -0700456 jbd_debug(3, "denied handle %p %d blocks: "
457 "insufficient log space\n", handle, nblocks);
458 goto unlock;
459 }
460
Theodore Ts'o343d9c22013-02-08 13:00:22 -0500461 trace_jbd2_handle_extend(journal->j_fs_dev->bd_dev,
462 handle->h_transaction->t_tid,
463 handle->h_type, handle->h_line_no,
464 handle->h_buffer_credits,
465 nblocks);
466
Dave Kleikamp470decc2006-10-11 01:20:57 -0700467 handle->h_buffer_credits += nblocks;
Theodore Ts'o343d9c22013-02-08 13:00:22 -0500468 handle->h_requested_credits += nblocks;
Theodore Ts'oa51dca92010-08-02 08:43:25 -0400469 atomic_add(nblocks, &transaction->t_outstanding_credits);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700470 result = 0;
471
472 jbd_debug(3, "extended handle %p by %d\n", handle, nblocks);
473unlock:
474 spin_unlock(&transaction->t_handle_lock);
475error_out:
Theodore Ts'oa931da62010-08-03 21:35:12 -0400476 read_unlock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700477out:
478 return result;
479}
480
481
482/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700483 * int jbd2_journal_restart() - restart a handle .
Dave Kleikamp470decc2006-10-11 01:20:57 -0700484 * @handle: handle to restart
485 * @nblocks: nr credits requested
486 *
487 * Restart a handle for a multi-transaction filesystem
488 * operation.
489 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700490 * If the jbd2_journal_extend() call above fails to grant new buffer credits
491 * to a running handle, a call to jbd2_journal_restart will commit the
Dave Kleikamp470decc2006-10-11 01:20:57 -0700492 * handle's transaction so far and reattach the handle to a new
493 * transaction capabable of guaranteeing the requested number of
494 * credits.
495 */
Dan Carpenterd2159fb2011-09-04 10:20:14 -0400496int jbd2__journal_restart(handle_t *handle, int nblocks, gfp_t gfp_mask)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700497{
498 transaction_t *transaction = handle->h_transaction;
499 journal_t *journal = transaction->t_journal;
Theodore Ts'oe4471832011-02-12 08:18:24 -0500500 tid_t tid;
501 int need_to_start, ret;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700502
503 /* If we've had an abort of any type, don't even think about
504 * actually doing the restart! */
505 if (is_handle_aborted(handle))
506 return 0;
507
508 /*
509 * First unlink the handle from its current transaction, and start the
510 * commit on that.
511 */
Theodore Ts'oa51dca92010-08-02 08:43:25 -0400512 J_ASSERT(atomic_read(&transaction->t_updates) > 0);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700513 J_ASSERT(journal_current_handle() == handle);
514
Theodore Ts'oa931da62010-08-03 21:35:12 -0400515 read_lock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700516 spin_lock(&transaction->t_handle_lock);
Theodore Ts'oa51dca92010-08-02 08:43:25 -0400517 atomic_sub(handle->h_buffer_credits,
518 &transaction->t_outstanding_credits);
519 if (atomic_dec_and_test(&transaction->t_updates))
Dave Kleikamp470decc2006-10-11 01:20:57 -0700520 wake_up(&journal->j_wait_updates);
521 spin_unlock(&transaction->t_handle_lock);
522
523 jbd_debug(2, "restarting handle %p\n", handle);
Theodore Ts'oe4471832011-02-12 08:18:24 -0500524 tid = transaction->t_tid;
525 need_to_start = !tid_geq(journal->j_commit_request, tid);
Theodore Ts'oa931da62010-08-03 21:35:12 -0400526 read_unlock(&journal->j_state_lock);
Theodore Ts'oe4471832011-02-12 08:18:24 -0500527 if (need_to_start)
528 jbd2_log_start_commit(journal, tid);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700529
Jan Kara9599b0e2009-08-17 21:23:17 -0400530 lock_map_release(&handle->h_lockdep_map);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700531 handle->h_buffer_credits = nblocks;
Theodore Ts'o47def822010-07-27 11:56:05 -0400532 ret = start_this_handle(journal, handle, gfp_mask);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700533 return ret;
534}
Theodore Ts'o47def822010-07-27 11:56:05 -0400535EXPORT_SYMBOL(jbd2__journal_restart);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700536
537
Theodore Ts'o47def822010-07-27 11:56:05 -0400538int jbd2_journal_restart(handle_t *handle, int nblocks)
539{
540 return jbd2__journal_restart(handle, nblocks, GFP_NOFS);
541}
542EXPORT_SYMBOL(jbd2_journal_restart);
543
Dave Kleikamp470decc2006-10-11 01:20:57 -0700544/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700545 * void jbd2_journal_lock_updates () - establish a transaction barrier.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700546 * @journal: Journal to establish a barrier on.
547 *
548 * This locks out any further updates from being started, and blocks
549 * until all existing updates have completed, returning only once the
550 * journal is in a quiescent state with no updates running.
551 *
552 * The journal lock should not be held on entry.
553 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700554void jbd2_journal_lock_updates(journal_t *journal)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700555{
556 DEFINE_WAIT(wait);
557
Theodore Ts'oa931da62010-08-03 21:35:12 -0400558 write_lock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700559 ++journal->j_barrier_count;
560
561 /* Wait until there are no running updates */
562 while (1) {
563 transaction_t *transaction = journal->j_running_transaction;
564
565 if (!transaction)
566 break;
567
568 spin_lock(&transaction->t_handle_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700569 prepare_to_wait(&journal->j_wait_updates, &wait,
570 TASK_UNINTERRUPTIBLE);
Jan Kara9837d8e2012-01-04 22:03:11 -0500571 if (!atomic_read(&transaction->t_updates)) {
572 spin_unlock(&transaction->t_handle_lock);
573 finish_wait(&journal->j_wait_updates, &wait);
574 break;
575 }
Dave Kleikamp470decc2006-10-11 01:20:57 -0700576 spin_unlock(&transaction->t_handle_lock);
Theodore Ts'oa931da62010-08-03 21:35:12 -0400577 write_unlock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700578 schedule();
579 finish_wait(&journal->j_wait_updates, &wait);
Theodore Ts'oa931da62010-08-03 21:35:12 -0400580 write_lock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700581 }
Theodore Ts'oa931da62010-08-03 21:35:12 -0400582 write_unlock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700583
584 /*
585 * We have now established a barrier against other normal updates, but
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700586 * we also need to barrier against other jbd2_journal_lock_updates() calls
Dave Kleikamp470decc2006-10-11 01:20:57 -0700587 * to make sure that we serialise special journal-locked operations
588 * too.
589 */
590 mutex_lock(&journal->j_barrier);
591}
592
593/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700594 * void jbd2_journal_unlock_updates (journal_t* journal) - release barrier
Dave Kleikamp470decc2006-10-11 01:20:57 -0700595 * @journal: Journal to release the barrier on.
596 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700597 * Release a transaction barrier obtained with jbd2_journal_lock_updates().
Dave Kleikamp470decc2006-10-11 01:20:57 -0700598 *
599 * Should be called without the journal lock held.
600 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700601void jbd2_journal_unlock_updates (journal_t *journal)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700602{
603 J_ASSERT(journal->j_barrier_count != 0);
604
605 mutex_unlock(&journal->j_barrier);
Theodore Ts'oa931da62010-08-03 21:35:12 -0400606 write_lock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700607 --journal->j_barrier_count;
Theodore Ts'oa931da62010-08-03 21:35:12 -0400608 write_unlock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700609 wake_up(&journal->j_wait_transaction_locked);
610}
611
Jan Karaf91d1d02009-07-13 16:16:20 -0400612static void warn_dirty_buffer(struct buffer_head *bh)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700613{
Jan Karaf91d1d02009-07-13 16:16:20 -0400614 char b[BDEVNAME_SIZE];
Dave Kleikamp470decc2006-10-11 01:20:57 -0700615
Jan Karaf91d1d02009-07-13 16:16:20 -0400616 printk(KERN_WARNING
Eryu Guanf2a44522011-11-01 19:09:18 -0400617 "JBD2: Spotted dirty metadata buffer (dev = %s, blocknr = %llu). "
Jan Karaf91d1d02009-07-13 16:16:20 -0400618 "There's a risk of filesystem corruption in case of system "
619 "crash.\n",
620 bdevname(bh->b_bdev, b), (unsigned long long)bh->b_blocknr);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700621}
622
623/*
624 * If the buffer is already part of the current transaction, then there
625 * is nothing we need to do. If it is already part of a prior
626 * transaction which we are still committing to disk, then we need to
627 * make sure that we do not overwrite the old copy: we do copy-out to
628 * preserve the copy going to disk. We also account the buffer against
629 * the handle's metadata buffer credits (unless the buffer is already
630 * part of the transaction, that is).
631 *
632 */
633static int
634do_get_write_access(handle_t *handle, struct journal_head *jh,
635 int force_copy)
636{
637 struct buffer_head *bh;
638 transaction_t *transaction;
639 journal_t *journal;
640 int error;
641 char *frozen_buffer = NULL;
642 int need_copy = 0;
643
644 if (is_handle_aborted(handle))
645 return -EROFS;
646
647 transaction = handle->h_transaction;
648 journal = transaction->t_journal;
649
Theodore Ts'ocfef2c62010-12-18 13:07:34 -0500650 jbd_debug(5, "journal_head %p, force_copy %d\n", jh, force_copy);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700651
652 JBUFFER_TRACE(jh, "entry");
653repeat:
654 bh = jh2bh(jh);
655
656 /* @@@ Need to check for errors here at some point. */
657
658 lock_buffer(bh);
659 jbd_lock_bh_state(bh);
660
661 /* We now hold the buffer lock so it is safe to query the buffer
662 * state. Is the buffer dirty?
663 *
664 * If so, there are two possibilities. The buffer may be
665 * non-journaled, and undergoing a quite legitimate writeback.
666 * Otherwise, it is journaled, and we don't expect dirty buffers
667 * in that state (the buffers should be marked JBD_Dirty
668 * instead.) So either the IO is being done under our own
669 * control and this is a bug, or it's a third party IO such as
670 * dump(8) (which may leave the buffer scheduled for read ---
671 * ie. locked but not dirty) or tune2fs (which may actually have
672 * the buffer dirtied, ugh.) */
673
674 if (buffer_dirty(bh)) {
675 /*
676 * First question: is this buffer already part of the current
677 * transaction or the existing committing transaction?
678 */
679 if (jh->b_transaction) {
680 J_ASSERT_JH(jh,
681 jh->b_transaction == transaction ||
682 jh->b_transaction ==
683 journal->j_committing_transaction);
684 if (jh->b_next_transaction)
685 J_ASSERT_JH(jh, jh->b_next_transaction ==
686 transaction);
Jan Karaf91d1d02009-07-13 16:16:20 -0400687 warn_dirty_buffer(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700688 }
689 /*
690 * In any case we need to clean the dirty flag and we must
691 * do it under the buffer lock to be sure we don't race
692 * with running write-out.
693 */
Jan Karaf91d1d02009-07-13 16:16:20 -0400694 JBUFFER_TRACE(jh, "Journalling dirty buffer");
695 clear_buffer_dirty(bh);
696 set_buffer_jbddirty(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700697 }
698
699 unlock_buffer(bh);
700
701 error = -EROFS;
702 if (is_handle_aborted(handle)) {
703 jbd_unlock_bh_state(bh);
704 goto out;
705 }
706 error = 0;
707
708 /*
709 * The buffer is already part of this transaction if b_transaction or
710 * b_next_transaction points to it
711 */
712 if (jh->b_transaction == transaction ||
713 jh->b_next_transaction == transaction)
714 goto done;
715
716 /*
Josef Bacik9fc7c632008-04-17 10:38:59 -0400717 * this is the first time this transaction is touching this buffer,
718 * reset the modified flag
719 */
720 jh->b_modified = 0;
721
722 /*
Dave Kleikamp470decc2006-10-11 01:20:57 -0700723 * If there is already a copy-out version of this buffer, then we don't
724 * need to make another one
725 */
726 if (jh->b_frozen_data) {
727 JBUFFER_TRACE(jh, "has frozen data");
728 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
729 jh->b_next_transaction = transaction;
730 goto done;
731 }
732
733 /* Is there data here we need to preserve? */
734
735 if (jh->b_transaction && jh->b_transaction != transaction) {
736 JBUFFER_TRACE(jh, "owned by older transaction");
737 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
738 J_ASSERT_JH(jh, jh->b_transaction ==
739 journal->j_committing_transaction);
740
741 /* There is one case we have to be very careful about.
742 * If the committing transaction is currently writing
743 * this buffer out to disk and has NOT made a copy-out,
744 * then we cannot modify the buffer contents at all
745 * right now. The essence of copy-out is that it is the
746 * extra copy, not the primary copy, which gets
747 * journaled. If the primary copy is already going to
748 * disk then we cannot do copy-out here. */
749
750 if (jh->b_jlist == BJ_Shadow) {
751 DEFINE_WAIT_BIT(wait, &bh->b_state, BH_Unshadow);
752 wait_queue_head_t *wqh;
753
754 wqh = bit_waitqueue(&bh->b_state, BH_Unshadow);
755
756 JBUFFER_TRACE(jh, "on shadow: sleep");
757 jbd_unlock_bh_state(bh);
758 /* commit wakes up all shadow buffers after IO */
759 for ( ; ; ) {
760 prepare_to_wait(wqh, &wait.wait,
761 TASK_UNINTERRUPTIBLE);
762 if (jh->b_jlist != BJ_Shadow)
763 break;
764 schedule();
765 }
766 finish_wait(wqh, &wait.wait);
767 goto repeat;
768 }
769
770 /* Only do the copy if the currently-owning transaction
771 * still needs it. If it is on the Forget list, the
772 * committing transaction is past that stage. The
773 * buffer had better remain locked during the kmalloc,
774 * but that should be true --- we hold the journal lock
775 * still and the buffer is already on the BUF_JOURNAL
776 * list so won't be flushed.
777 *
778 * Subtle point, though: if this is a get_undo_access,
779 * then we will be relying on the frozen_data to contain
780 * the new value of the committed_data record after the
781 * transaction, so we HAVE to force the frozen_data copy
782 * in that case. */
783
784 if (jh->b_jlist != BJ_Forget || force_copy) {
785 JBUFFER_TRACE(jh, "generate frozen data");
786 if (!frozen_buffer) {
787 JBUFFER_TRACE(jh, "allocate memory for buffer");
788 jbd_unlock_bh_state(bh);
789 frozen_buffer =
Mingming Caoaf1e76d2007-10-16 18:38:25 -0400790 jbd2_alloc(jh2bh(jh)->b_size,
Dave Kleikamp470decc2006-10-11 01:20:57 -0700791 GFP_NOFS);
792 if (!frozen_buffer) {
793 printk(KERN_EMERG
794 "%s: OOM for frozen_buffer\n",
Harvey Harrison329d2912008-04-17 10:38:59 -0400795 __func__);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700796 JBUFFER_TRACE(jh, "oom!");
797 error = -ENOMEM;
798 jbd_lock_bh_state(bh);
799 goto done;
800 }
801 goto repeat;
802 }
803 jh->b_frozen_data = frozen_buffer;
804 frozen_buffer = NULL;
805 need_copy = 1;
806 }
807 jh->b_next_transaction = transaction;
808 }
809
810
811 /*
812 * Finally, if the buffer is not journaled right now, we need to make
813 * sure it doesn't get written to disk before the caller actually
814 * commits the new data
815 */
816 if (!jh->b_transaction) {
817 JBUFFER_TRACE(jh, "no transaction");
818 J_ASSERT_JH(jh, !jh->b_next_transaction);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700819 JBUFFER_TRACE(jh, "file as BJ_Reserved");
820 spin_lock(&journal->j_list_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700821 __jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700822 spin_unlock(&journal->j_list_lock);
823 }
824
825done:
826 if (need_copy) {
827 struct page *page;
828 int offset;
829 char *source;
830
831 J_EXPECT_JH(jh, buffer_uptodate(jh2bh(jh)),
832 "Possible IO failure.\n");
833 page = jh2bh(jh)->b_page;
Theodore Ts'oa1dd5332010-12-18 13:13:40 -0500834 offset = offset_in_page(jh2bh(jh)->b_data);
Cong Wang303a8f22011-11-25 23:14:31 +0800835 source = kmap_atomic(page);
Jan Kara13ceef02010-07-14 07:56:33 +0200836 /* Fire data frozen trigger just before we copy the data */
837 jbd2_buffer_frozen_trigger(jh, source + offset,
838 jh->b_triggers);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700839 memcpy(jh->b_frozen_data, source+offset, jh2bh(jh)->b_size);
Cong Wang303a8f22011-11-25 23:14:31 +0800840 kunmap_atomic(source);
Joel Beckere06c8222008-09-11 15:35:47 -0700841
842 /*
843 * Now that the frozen data is saved off, we need to store
844 * any matching triggers.
845 */
846 jh->b_frozen_triggers = jh->b_triggers;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700847 }
848 jbd_unlock_bh_state(bh);
849
850 /*
851 * If we are about to journal a buffer, then any revoke pending on it is
852 * no longer valid
853 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700854 jbd2_journal_cancel_revoke(handle, jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700855
856out:
857 if (unlikely(frozen_buffer)) /* It's usually NULL */
Mingming Caoaf1e76d2007-10-16 18:38:25 -0400858 jbd2_free(frozen_buffer, bh->b_size);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700859
860 JBUFFER_TRACE(jh, "exit");
861 return error;
862}
863
864/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700865 * int jbd2_journal_get_write_access() - notify intent to modify a buffer for metadata (not data) update.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700866 * @handle: transaction to add buffer modifications to
867 * @bh: bh to be used for metadata writes
Dave Kleikamp470decc2006-10-11 01:20:57 -0700868 *
869 * Returns an error code or 0 on success.
870 *
871 * In full data journalling mode the buffer may be of type BJ_AsyncData,
872 * because we're write()ing a buffer which is also part of a shared mapping.
873 */
874
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700875int jbd2_journal_get_write_access(handle_t *handle, struct buffer_head *bh)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700876{
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700877 struct journal_head *jh = jbd2_journal_add_journal_head(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700878 int rc;
879
880 /* We do not want to get caught playing with fields which the
881 * log thread also manipulates. Make sure that the buffer
882 * completes any outstanding IO before proceeding. */
883 rc = do_get_write_access(handle, jh, 0);
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700884 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700885 return rc;
886}
887
888
889/*
890 * When the user wants to journal a newly created buffer_head
891 * (ie. getblk() returned a new buffer and we are going to populate it
892 * manually rather than reading off disk), then we need to keep the
893 * buffer_head locked until it has been completely filled with new
894 * data. In this case, we should be able to make the assertion that
895 * the bh is not already part of an existing transaction.
896 *
897 * The buffer should already be locked by the caller by this point.
898 * There is no lock ranking violation: it was a newly created,
899 * unlocked buffer beforehand. */
900
901/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700902 * int jbd2_journal_get_create_access () - notify intent to use newly created bh
Dave Kleikamp470decc2006-10-11 01:20:57 -0700903 * @handle: transaction to new buffer to
904 * @bh: new buffer.
905 *
906 * Call this if you create a new bh.
907 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700908int jbd2_journal_get_create_access(handle_t *handle, struct buffer_head *bh)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700909{
910 transaction_t *transaction = handle->h_transaction;
911 journal_t *journal = transaction->t_journal;
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700912 struct journal_head *jh = jbd2_journal_add_journal_head(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700913 int err;
914
915 jbd_debug(5, "journal_head %p\n", jh);
916 err = -EROFS;
917 if (is_handle_aborted(handle))
918 goto out;
919 err = 0;
920
921 JBUFFER_TRACE(jh, "entry");
922 /*
923 * The buffer may already belong to this transaction due to pre-zeroing
924 * in the filesystem's new_block code. It may also be on the previous,
925 * committing transaction's lists, but it HAS to be in Forget state in
926 * that case: the transaction must have deleted the buffer for it to be
927 * reused here.
928 */
929 jbd_lock_bh_state(bh);
930 spin_lock(&journal->j_list_lock);
931 J_ASSERT_JH(jh, (jh->b_transaction == transaction ||
932 jh->b_transaction == NULL ||
933 (jh->b_transaction == journal->j_committing_transaction &&
934 jh->b_jlist == BJ_Forget)));
935
936 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
937 J_ASSERT_JH(jh, buffer_locked(jh2bh(jh)));
938
939 if (jh->b_transaction == NULL) {
Jan Karaf91d1d02009-07-13 16:16:20 -0400940 /*
941 * Previous jbd2_journal_forget() could have left the buffer
942 * with jbddirty bit set because it was being committed. When
943 * the commit finished, we've filed the buffer for
944 * checkpointing and marked it dirty. Now we are reallocating
945 * the buffer so the transaction freeing it must have
946 * committed and so it's safe to clear the dirty bit.
947 */
948 clear_buffer_dirty(jh2bh(jh));
Josef Bacik9fc7c632008-04-17 10:38:59 -0400949 /* first access by this transaction */
950 jh->b_modified = 0;
951
Dave Kleikamp470decc2006-10-11 01:20:57 -0700952 JBUFFER_TRACE(jh, "file as BJ_Reserved");
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700953 __jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700954 } else if (jh->b_transaction == journal->j_committing_transaction) {
Josef Bacik9fc7c632008-04-17 10:38:59 -0400955 /* first access by this transaction */
956 jh->b_modified = 0;
957
Dave Kleikamp470decc2006-10-11 01:20:57 -0700958 JBUFFER_TRACE(jh, "set next transaction");
959 jh->b_next_transaction = transaction;
960 }
961 spin_unlock(&journal->j_list_lock);
962 jbd_unlock_bh_state(bh);
963
964 /*
965 * akpm: I added this. ext3_alloc_branch can pick up new indirect
966 * blocks which contain freed but then revoked metadata. We need
967 * to cancel the revoke in case we end up freeing it yet again
968 * and the reallocating as data - this would cause a second revoke,
969 * which hits an assertion error.
970 */
971 JBUFFER_TRACE(jh, "cancelling revoke");
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700972 jbd2_journal_cancel_revoke(handle, jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700973out:
Ding Dinghua3991b402011-05-25 17:43:48 -0400974 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700975 return err;
976}
977
978/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700979 * int jbd2_journal_get_undo_access() - Notify intent to modify metadata with
Dave Kleikamp470decc2006-10-11 01:20:57 -0700980 * non-rewindable consequences
981 * @handle: transaction
982 * @bh: buffer to undo
Dave Kleikamp470decc2006-10-11 01:20:57 -0700983 *
984 * Sometimes there is a need to distinguish between metadata which has
985 * been committed to disk and that which has not. The ext3fs code uses
986 * this for freeing and allocating space, we have to make sure that we
987 * do not reuse freed space until the deallocation has been committed,
988 * since if we overwrote that space we would make the delete
989 * un-rewindable in case of a crash.
990 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700991 * To deal with that, jbd2_journal_get_undo_access requests write access to a
Dave Kleikamp470decc2006-10-11 01:20:57 -0700992 * buffer for parts of non-rewindable operations such as delete
993 * operations on the bitmaps. The journaling code must keep a copy of
994 * the buffer's contents prior to the undo_access call until such time
995 * as we know that the buffer has definitely been committed to disk.
996 *
997 * We never need to know which transaction the committed data is part
998 * of, buffers touched here are guaranteed to be dirtied later and so
999 * will be committed to a new transaction in due course, at which point
1000 * we can discard the old committed data pointer.
1001 *
1002 * Returns error number or 0 on success.
1003 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001004int jbd2_journal_get_undo_access(handle_t *handle, struct buffer_head *bh)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001005{
1006 int err;
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001007 struct journal_head *jh = jbd2_journal_add_journal_head(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001008 char *committed_data = NULL;
1009
1010 JBUFFER_TRACE(jh, "entry");
1011
1012 /*
1013 * Do this first --- it can drop the journal lock, so we want to
1014 * make sure that obtaining the committed_data is done
1015 * atomically wrt. completion of any outstanding commits.
1016 */
1017 err = do_get_write_access(handle, jh, 1);
1018 if (err)
1019 goto out;
1020
1021repeat:
1022 if (!jh->b_committed_data) {
Mingming Caoaf1e76d2007-10-16 18:38:25 -04001023 committed_data = jbd2_alloc(jh2bh(jh)->b_size, GFP_NOFS);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001024 if (!committed_data) {
1025 printk(KERN_EMERG "%s: No memory for committed data\n",
Harvey Harrison329d2912008-04-17 10:38:59 -04001026 __func__);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001027 err = -ENOMEM;
1028 goto out;
1029 }
1030 }
1031
1032 jbd_lock_bh_state(bh);
1033 if (!jh->b_committed_data) {
1034 /* Copy out the current buffer contents into the
1035 * preserved, committed copy. */
1036 JBUFFER_TRACE(jh, "generate b_committed data");
1037 if (!committed_data) {
1038 jbd_unlock_bh_state(bh);
1039 goto repeat;
1040 }
1041
1042 jh->b_committed_data = committed_data;
1043 committed_data = NULL;
1044 memcpy(jh->b_committed_data, bh->b_data, bh->b_size);
1045 }
1046 jbd_unlock_bh_state(bh);
1047out:
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001048 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001049 if (unlikely(committed_data))
Mingming Caoaf1e76d2007-10-16 18:38:25 -04001050 jbd2_free(committed_data, bh->b_size);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001051 return err;
1052}
1053
1054/**
Joel Beckere06c8222008-09-11 15:35:47 -07001055 * void jbd2_journal_set_triggers() - Add triggers for commit writeout
1056 * @bh: buffer to trigger on
1057 * @type: struct jbd2_buffer_trigger_type containing the trigger(s).
1058 *
1059 * Set any triggers on this journal_head. This is always safe, because
1060 * triggers for a committing buffer will be saved off, and triggers for
1061 * a running transaction will match the buffer in that transaction.
1062 *
1063 * Call with NULL to clear the triggers.
1064 */
1065void jbd2_journal_set_triggers(struct buffer_head *bh,
1066 struct jbd2_buffer_trigger_type *type)
1067{
Jan Karaad56eda2013-03-11 13:24:56 -04001068 struct journal_head *jh = jbd2_journal_grab_journal_head(bh);
Joel Beckere06c8222008-09-11 15:35:47 -07001069
Jan Karaad56eda2013-03-11 13:24:56 -04001070 if (WARN_ON(!jh))
1071 return;
Joel Beckere06c8222008-09-11 15:35:47 -07001072 jh->b_triggers = type;
Jan Karaad56eda2013-03-11 13:24:56 -04001073 jbd2_journal_put_journal_head(jh);
Joel Beckere06c8222008-09-11 15:35:47 -07001074}
1075
Jan Kara13ceef02010-07-14 07:56:33 +02001076void jbd2_buffer_frozen_trigger(struct journal_head *jh, void *mapped_data,
Joel Beckere06c8222008-09-11 15:35:47 -07001077 struct jbd2_buffer_trigger_type *triggers)
1078{
1079 struct buffer_head *bh = jh2bh(jh);
1080
Jan Kara13ceef02010-07-14 07:56:33 +02001081 if (!triggers || !triggers->t_frozen)
Joel Beckere06c8222008-09-11 15:35:47 -07001082 return;
1083
Jan Kara13ceef02010-07-14 07:56:33 +02001084 triggers->t_frozen(triggers, bh, mapped_data, bh->b_size);
Joel Beckere06c8222008-09-11 15:35:47 -07001085}
1086
1087void jbd2_buffer_abort_trigger(struct journal_head *jh,
1088 struct jbd2_buffer_trigger_type *triggers)
1089{
1090 if (!triggers || !triggers->t_abort)
1091 return;
1092
1093 triggers->t_abort(triggers, jh2bh(jh));
1094}
1095
1096
1097
1098/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001099 * int jbd2_journal_dirty_metadata() - mark a buffer as containing dirty metadata
Dave Kleikamp470decc2006-10-11 01:20:57 -07001100 * @handle: transaction to add buffer to.
1101 * @bh: buffer to mark
1102 *
1103 * mark dirty metadata which needs to be journaled as part of the current
1104 * transaction.
1105 *
Theodore Ts'o9ea7a0d2011-09-04 10:18:14 -04001106 * The buffer must have previously had jbd2_journal_get_write_access()
1107 * called so that it has a valid journal_head attached to the buffer
1108 * head.
1109 *
Dave Kleikamp470decc2006-10-11 01:20:57 -07001110 * The buffer is placed on the transaction's metadata list and is marked
1111 * as belonging to the transaction.
1112 *
1113 * Returns error number or 0 on success.
1114 *
1115 * Special care needs to be taken if the buffer already belongs to the
1116 * current committing transaction (in which case we should have frozen
1117 * data present for that commit). In that case, we don't relink the
1118 * buffer: that only gets done when the old transaction finally
1119 * completes its commit.
1120 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001121int jbd2_journal_dirty_metadata(handle_t *handle, struct buffer_head *bh)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001122{
1123 transaction_t *transaction = handle->h_transaction;
1124 journal_t *journal = transaction->t_journal;
Jan Karaad56eda2013-03-11 13:24:56 -04001125 struct journal_head *jh;
Theodore Ts'o9ea7a0d2011-09-04 10:18:14 -04001126 int ret = 0;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001127
Dave Kleikamp470decc2006-10-11 01:20:57 -07001128 if (is_handle_aborted(handle))
1129 goto out;
Jan Karaad56eda2013-03-11 13:24:56 -04001130 jh = jbd2_journal_grab_journal_head(bh);
1131 if (!jh) {
Theodore Ts'o9ea7a0d2011-09-04 10:18:14 -04001132 ret = -EUCLEAN;
1133 goto out;
1134 }
Jan Karaad56eda2013-03-11 13:24:56 -04001135 jbd_debug(5, "journal_head %p\n", jh);
1136 JBUFFER_TRACE(jh, "entry");
Dave Kleikamp470decc2006-10-11 01:20:57 -07001137
1138 jbd_lock_bh_state(bh);
1139
1140 if (jh->b_modified == 0) {
1141 /*
1142 * This buffer's got modified and becoming part
1143 * of the transaction. This needs to be done
1144 * once a transaction -bzzz
1145 */
1146 jh->b_modified = 1;
1147 J_ASSERT_JH(jh, handle->h_buffer_credits > 0);
1148 handle->h_buffer_credits--;
1149 }
1150
1151 /*
1152 * fastpath, to avoid expensive locking. If this buffer is already
1153 * on the running transaction's metadata list there is nothing to do.
1154 * Nobody can take it off again because there is a handle open.
1155 * I _think_ we're OK here with SMP barriers - a mistaken decision will
1156 * result in this test being false, so we go in and take the locks.
1157 */
1158 if (jh->b_transaction == transaction && jh->b_jlist == BJ_Metadata) {
1159 JBUFFER_TRACE(jh, "fastpath");
Theodore Ts'o9ea7a0d2011-09-04 10:18:14 -04001160 if (unlikely(jh->b_transaction !=
1161 journal->j_running_transaction)) {
1162 printk(KERN_EMERG "JBD: %s: "
1163 "jh->b_transaction (%llu, %p, %u) != "
1164 "journal->j_running_transaction (%p, %u)",
1165 journal->j_devname,
1166 (unsigned long long) bh->b_blocknr,
1167 jh->b_transaction,
1168 jh->b_transaction ? jh->b_transaction->t_tid : 0,
1169 journal->j_running_transaction,
1170 journal->j_running_transaction ?
1171 journal->j_running_transaction->t_tid : 0);
1172 ret = -EINVAL;
1173 }
Dave Kleikamp470decc2006-10-11 01:20:57 -07001174 goto out_unlock_bh;
1175 }
1176
1177 set_buffer_jbddirty(bh);
1178
1179 /*
1180 * Metadata already on the current transaction list doesn't
1181 * need to be filed. Metadata on another transaction's list must
1182 * be committing, and will be refiled once the commit completes:
1183 * leave it alone for now.
1184 */
1185 if (jh->b_transaction != transaction) {
1186 JBUFFER_TRACE(jh, "already on other transaction");
Theodore Ts'o9ea7a0d2011-09-04 10:18:14 -04001187 if (unlikely(jh->b_transaction !=
1188 journal->j_committing_transaction)) {
1189 printk(KERN_EMERG "JBD: %s: "
1190 "jh->b_transaction (%llu, %p, %u) != "
1191 "journal->j_committing_transaction (%p, %u)",
1192 journal->j_devname,
1193 (unsigned long long) bh->b_blocknr,
1194 jh->b_transaction,
1195 jh->b_transaction ? jh->b_transaction->t_tid : 0,
1196 journal->j_committing_transaction,
1197 journal->j_committing_transaction ?
1198 journal->j_committing_transaction->t_tid : 0);
1199 ret = -EINVAL;
1200 }
1201 if (unlikely(jh->b_next_transaction != transaction)) {
1202 printk(KERN_EMERG "JBD: %s: "
1203 "jh->b_next_transaction (%llu, %p, %u) != "
1204 "transaction (%p, %u)",
1205 journal->j_devname,
1206 (unsigned long long) bh->b_blocknr,
1207 jh->b_next_transaction,
1208 jh->b_next_transaction ?
1209 jh->b_next_transaction->t_tid : 0,
1210 transaction, transaction->t_tid);
1211 ret = -EINVAL;
1212 }
Dave Kleikamp470decc2006-10-11 01:20:57 -07001213 /* And this case is illegal: we can't reuse another
1214 * transaction's data buffer, ever. */
1215 goto out_unlock_bh;
1216 }
1217
1218 /* That test should have eliminated the following case: */
Mingming Cao40191912008-01-28 23:58:27 -05001219 J_ASSERT_JH(jh, jh->b_frozen_data == NULL);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001220
1221 JBUFFER_TRACE(jh, "file as BJ_Metadata");
1222 spin_lock(&journal->j_list_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001223 __jbd2_journal_file_buffer(jh, handle->h_transaction, BJ_Metadata);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001224 spin_unlock(&journal->j_list_lock);
1225out_unlock_bh:
1226 jbd_unlock_bh_state(bh);
Jan Karaad56eda2013-03-11 13:24:56 -04001227 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001228out:
1229 JBUFFER_TRACE(jh, "exit");
Randy Dunlap44705752011-10-27 04:05:13 -04001230 WARN_ON(ret); /* All errors are bugs, so dump the stack */
Theodore Ts'o9ea7a0d2011-09-04 10:18:14 -04001231 return ret;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001232}
1233
Dave Kleikamp470decc2006-10-11 01:20:57 -07001234/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001235 * void jbd2_journal_forget() - bforget() for potentially-journaled buffers.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001236 * @handle: transaction handle
1237 * @bh: bh to 'forget'
1238 *
1239 * We can only do the bforget if there are no commits pending against the
1240 * buffer. If the buffer is dirty in the current running transaction we
1241 * can safely unlink it.
1242 *
1243 * bh may not be a journalled buffer at all - it may be a non-JBD
1244 * buffer which came off the hashtable. Check for this.
1245 *
1246 * Decrements bh->b_count by one.
1247 *
1248 * Allow this call even if the handle has aborted --- it may be part of
1249 * the caller's cleanup after an abort.
1250 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001251int jbd2_journal_forget (handle_t *handle, struct buffer_head *bh)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001252{
1253 transaction_t *transaction = handle->h_transaction;
1254 journal_t *journal = transaction->t_journal;
1255 struct journal_head *jh;
1256 int drop_reserve = 0;
1257 int err = 0;
Josef Bacik1dfc3222008-04-17 10:38:59 -04001258 int was_modified = 0;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001259
1260 BUFFER_TRACE(bh, "entry");
1261
1262 jbd_lock_bh_state(bh);
1263 spin_lock(&journal->j_list_lock);
1264
1265 if (!buffer_jbd(bh))
1266 goto not_jbd;
1267 jh = bh2jh(bh);
1268
1269 /* Critical error: attempting to delete a bitmap buffer, maybe?
1270 * Don't do any jbd operations, and return an error. */
1271 if (!J_EXPECT_JH(jh, !jh->b_committed_data,
1272 "inconsistent data on disk")) {
1273 err = -EIO;
1274 goto not_jbd;
1275 }
1276
Adam Buchbinder48fc7f72012-09-19 21:48:00 -04001277 /* keep track of whether or not this transaction modified us */
Josef Bacik1dfc3222008-04-17 10:38:59 -04001278 was_modified = jh->b_modified;
1279
Dave Kleikamp470decc2006-10-11 01:20:57 -07001280 /*
1281 * The buffer's going from the transaction, we must drop
1282 * all references -bzzz
1283 */
1284 jh->b_modified = 0;
1285
1286 if (jh->b_transaction == handle->h_transaction) {
1287 J_ASSERT_JH(jh, !jh->b_frozen_data);
1288
1289 /* If we are forgetting a buffer which is already part
1290 * of this transaction, then we can just drop it from
1291 * the transaction immediately. */
1292 clear_buffer_dirty(bh);
1293 clear_buffer_jbddirty(bh);
1294
1295 JBUFFER_TRACE(jh, "belongs to current transaction: unfile");
1296
Josef Bacik1dfc3222008-04-17 10:38:59 -04001297 /*
1298 * we only want to drop a reference if this transaction
1299 * modified the buffer
1300 */
1301 if (was_modified)
1302 drop_reserve = 1;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001303
1304 /*
1305 * We are no longer going to journal this buffer.
1306 * However, the commit of this transaction is still
1307 * important to the buffer: the delete that we are now
1308 * processing might obsolete an old log entry, so by
1309 * committing, we can satisfy the buffer's checkpoint.
1310 *
1311 * So, if we have a checkpoint on the buffer, we should
1312 * now refile the buffer on our BJ_Forget list so that
1313 * we know to remove the checkpoint after we commit.
1314 */
1315
1316 if (jh->b_cp_transaction) {
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001317 __jbd2_journal_temp_unlink_buffer(jh);
1318 __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001319 } else {
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001320 __jbd2_journal_unfile_buffer(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001321 if (!buffer_jbd(bh)) {
1322 spin_unlock(&journal->j_list_lock);
1323 jbd_unlock_bh_state(bh);
1324 __bforget(bh);
1325 goto drop;
1326 }
1327 }
1328 } else if (jh->b_transaction) {
1329 J_ASSERT_JH(jh, (jh->b_transaction ==
1330 journal->j_committing_transaction));
1331 /* However, if the buffer is still owned by a prior
1332 * (committing) transaction, we can't drop it yet... */
1333 JBUFFER_TRACE(jh, "belongs to older transaction");
1334 /* ... but we CAN drop it from the new transaction if we
1335 * have also modified it since the original commit. */
1336
1337 if (jh->b_next_transaction) {
1338 J_ASSERT(jh->b_next_transaction == transaction);
1339 jh->b_next_transaction = NULL;
Josef Bacik1dfc3222008-04-17 10:38:59 -04001340
1341 /*
1342 * only drop a reference if this transaction modified
1343 * the buffer
1344 */
1345 if (was_modified)
1346 drop_reserve = 1;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001347 }
1348 }
1349
1350not_jbd:
1351 spin_unlock(&journal->j_list_lock);
1352 jbd_unlock_bh_state(bh);
1353 __brelse(bh);
1354drop:
1355 if (drop_reserve) {
1356 /* no need to reserve log space for this block -bzzz */
1357 handle->h_buffer_credits++;
1358 }
1359 return err;
1360}
1361
1362/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001363 * int jbd2_journal_stop() - complete a transaction
Dave Kleikamp470decc2006-10-11 01:20:57 -07001364 * @handle: tranaction to complete.
1365 *
1366 * All done for a particular handle.
1367 *
1368 * There is not much action needed here. We just return any remaining
1369 * buffer credits to the transaction and remove the handle. The only
1370 * complication is that we need to start a commit operation if the
1371 * filesystem is marked for synchronous update.
1372 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001373 * jbd2_journal_stop itself will not usually return an error, but it may
Dave Kleikamp470decc2006-10-11 01:20:57 -07001374 * do so in unusual circumstances. In particular, expect it to
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001375 * return -EIO if a jbd2_journal_abort has been executed since the
Dave Kleikamp470decc2006-10-11 01:20:57 -07001376 * transaction began.
1377 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001378int jbd2_journal_stop(handle_t *handle)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001379{
1380 transaction_t *transaction = handle->h_transaction;
1381 journal_t *journal = transaction->t_journal;
Theodore Ts'oa51dca92010-08-02 08:43:25 -04001382 int err, wait_for_commit = 0;
1383 tid_t tid;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001384 pid_t pid;
1385
Dave Kleikamp470decc2006-10-11 01:20:57 -07001386 J_ASSERT(journal_current_handle() == handle);
1387
1388 if (is_handle_aborted(handle))
1389 err = -EIO;
OGAWA Hirofumi3e2a5322006-10-19 23:29:11 -07001390 else {
Theodore Ts'oa51dca92010-08-02 08:43:25 -04001391 J_ASSERT(atomic_read(&transaction->t_updates) > 0);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001392 err = 0;
OGAWA Hirofumi3e2a5322006-10-19 23:29:11 -07001393 }
Dave Kleikamp470decc2006-10-11 01:20:57 -07001394
1395 if (--handle->h_ref > 0) {
1396 jbd_debug(4, "h_ref %d -> %d\n", handle->h_ref + 1,
1397 handle->h_ref);
1398 return err;
1399 }
1400
1401 jbd_debug(4, "Handle %p going down\n", handle);
Theodore Ts'o343d9c22013-02-08 13:00:22 -05001402 trace_jbd2_handle_stats(journal->j_fs_dev->bd_dev,
1403 handle->h_transaction->t_tid,
1404 handle->h_type, handle->h_line_no,
1405 jiffies - handle->h_start_jiffies,
1406 handle->h_sync, handle->h_requested_credits,
1407 (handle->h_requested_credits -
1408 handle->h_buffer_credits));
Dave Kleikamp470decc2006-10-11 01:20:57 -07001409
1410 /*
1411 * Implement synchronous transaction batching. If the handle
1412 * was synchronous, don't force a commit immediately. Let's
Josef Bacike07f7182008-11-26 01:14:26 -05001413 * yield and let another thread piggyback onto this
1414 * transaction. Keep doing that while new threads continue to
1415 * arrive. It doesn't cost much - we're about to run a commit
1416 * and sleep on IO anyway. Speeds up many-threaded, many-dir
1417 * operations by 30x or more...
Dave Kleikamp470decc2006-10-11 01:20:57 -07001418 *
Josef Bacike07f7182008-11-26 01:14:26 -05001419 * We try and optimize the sleep time against what the
1420 * underlying disk can do, instead of having a static sleep
1421 * time. This is useful for the case where our storage is so
1422 * fast that it is more optimal to go ahead and force a flush
1423 * and wait for the transaction to be committed than it is to
1424 * wait for an arbitrary amount of time for new writers to
1425 * join the transaction. We achieve this by measuring how
1426 * long it takes to commit a transaction, and compare it with
1427 * how long this transaction has been running, and if run time
1428 * < commit time then we sleep for the delta and commit. This
1429 * greatly helps super fast disks that would see slowdowns as
1430 * more threads started doing fsyncs.
1431 *
1432 * But don't do this if this process was the most recent one
1433 * to perform a synchronous write. We do this to detect the
1434 * case where a single process is doing a stream of sync
1435 * writes. No point in waiting for joiners in that case.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001436 */
1437 pid = current->pid;
1438 if (handle->h_sync && journal->j_last_sync_writer != pid) {
Josef Bacike07f7182008-11-26 01:14:26 -05001439 u64 commit_time, trans_time;
1440
Dave Kleikamp470decc2006-10-11 01:20:57 -07001441 journal->j_last_sync_writer = pid;
Josef Bacike07f7182008-11-26 01:14:26 -05001442
Theodore Ts'oa931da62010-08-03 21:35:12 -04001443 read_lock(&journal->j_state_lock);
Josef Bacike07f7182008-11-26 01:14:26 -05001444 commit_time = journal->j_average_commit_time;
Theodore Ts'oa931da62010-08-03 21:35:12 -04001445 read_unlock(&journal->j_state_lock);
Josef Bacike07f7182008-11-26 01:14:26 -05001446
1447 trans_time = ktime_to_ns(ktime_sub(ktime_get(),
1448 transaction->t_start_time));
1449
Theodore Ts'o30773842009-01-03 20:27:38 -05001450 commit_time = max_t(u64, commit_time,
1451 1000*journal->j_min_batch_time);
Josef Bacike07f7182008-11-26 01:14:26 -05001452 commit_time = min_t(u64, commit_time,
Theodore Ts'o30773842009-01-03 20:27:38 -05001453 1000*journal->j_max_batch_time);
Josef Bacike07f7182008-11-26 01:14:26 -05001454
1455 if (trans_time < commit_time) {
1456 ktime_t expires = ktime_add_ns(ktime_get(),
1457 commit_time);
1458 set_current_state(TASK_UNINTERRUPTIBLE);
1459 schedule_hrtimeout(&expires, HRTIMER_MODE_ABS);
1460 }
Dave Kleikamp470decc2006-10-11 01:20:57 -07001461 }
1462
Theodore Ts'o70585482009-03-25 23:35:46 -04001463 if (handle->h_sync)
1464 transaction->t_synchronous_commit = 1;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001465 current->journal_info = NULL;
Theodore Ts'oa51dca92010-08-02 08:43:25 -04001466 atomic_sub(handle->h_buffer_credits,
1467 &transaction->t_outstanding_credits);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001468
1469 /*
1470 * If the handle is marked SYNC, we need to set another commit
1471 * going! We also want to force a commit if the current
1472 * transaction is occupying too much of the log, or if the
1473 * transaction is too old now.
1474 */
1475 if (handle->h_sync ||
Theodore Ts'oa51dca92010-08-02 08:43:25 -04001476 (atomic_read(&transaction->t_outstanding_credits) >
1477 journal->j_max_transaction_buffers) ||
1478 time_after_eq(jiffies, transaction->t_expires)) {
Dave Kleikamp470decc2006-10-11 01:20:57 -07001479 /* Do this even for aborted journals: an abort still
1480 * completes the commit thread, it just doesn't write
1481 * anything to disk. */
Dave Kleikamp470decc2006-10-11 01:20:57 -07001482
Dave Kleikamp470decc2006-10-11 01:20:57 -07001483 jbd_debug(2, "transaction too old, requesting commit for "
1484 "handle %p\n", handle);
1485 /* This is non-blocking */
Theodore Ts'oc35a56a2010-05-16 05:00:00 -04001486 jbd2_log_start_commit(journal, transaction->t_tid);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001487
1488 /*
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001489 * Special case: JBD2_SYNC synchronous updates require us
Dave Kleikamp470decc2006-10-11 01:20:57 -07001490 * to wait for the commit to complete.
1491 */
1492 if (handle->h_sync && !(current->flags & PF_MEMALLOC))
Theodore Ts'oa51dca92010-08-02 08:43:25 -04001493 wait_for_commit = 1;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001494 }
1495
Theodore Ts'oa51dca92010-08-02 08:43:25 -04001496 /*
1497 * Once we drop t_updates, if it goes to zero the transaction
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001498 * could start committing on us and eventually disappear. So
Theodore Ts'oa51dca92010-08-02 08:43:25 -04001499 * once we do this, we must not dereference transaction
1500 * pointer again.
1501 */
1502 tid = transaction->t_tid;
1503 if (atomic_dec_and_test(&transaction->t_updates)) {
1504 wake_up(&journal->j_wait_updates);
1505 if (journal->j_barrier_count)
1506 wake_up(&journal->j_wait_transaction_locked);
1507 }
1508
1509 if (wait_for_commit)
1510 err = jbd2_log_wait_commit(journal, tid);
1511
Ingo Molnar3295f0e2008-08-11 10:30:30 +02001512 lock_map_release(&handle->h_lockdep_map);
Mingming Cao7b751062008-01-28 23:58:27 -05001513
Mingming Caoaf1e76d2007-10-16 18:38:25 -04001514 jbd2_free_handle(handle);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001515 return err;
1516}
1517
Randy Dunlap5648ba52008-04-17 10:38:59 -04001518/**
1519 * int jbd2_journal_force_commit() - force any uncommitted transactions
Dave Kleikamp470decc2006-10-11 01:20:57 -07001520 * @journal: journal to force
1521 *
1522 * For synchronous operations: force any uncommitted transactions
1523 * to disk. May seem kludgy, but it reuses all the handle batching
1524 * code in a very simple manner.
1525 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001526int jbd2_journal_force_commit(journal_t *journal)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001527{
1528 handle_t *handle;
1529 int ret;
1530
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001531 handle = jbd2_journal_start(journal, 1);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001532 if (IS_ERR(handle)) {
1533 ret = PTR_ERR(handle);
1534 } else {
1535 handle->h_sync = 1;
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001536 ret = jbd2_journal_stop(handle);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001537 }
1538 return ret;
1539}
1540
1541/*
1542 *
1543 * List management code snippets: various functions for manipulating the
1544 * transaction buffer lists.
1545 *
1546 */
1547
1548/*
1549 * Append a buffer to a transaction list, given the transaction's list head
1550 * pointer.
1551 *
1552 * j_list_lock is held.
1553 *
1554 * jbd_lock_bh_state(jh2bh(jh)) is held.
1555 */
1556
1557static inline void
1558__blist_add_buffer(struct journal_head **list, struct journal_head *jh)
1559{
1560 if (!*list) {
1561 jh->b_tnext = jh->b_tprev = jh;
1562 *list = jh;
1563 } else {
1564 /* Insert at the tail of the list to preserve order */
1565 struct journal_head *first = *list, *last = first->b_tprev;
1566 jh->b_tprev = last;
1567 jh->b_tnext = first;
1568 last->b_tnext = first->b_tprev = jh;
1569 }
1570}
1571
1572/*
1573 * Remove a buffer from a transaction list, given the transaction's list
1574 * head pointer.
1575 *
1576 * Called with j_list_lock held, and the journal may not be locked.
1577 *
1578 * jbd_lock_bh_state(jh2bh(jh)) is held.
1579 */
1580
1581static inline void
1582__blist_del_buffer(struct journal_head **list, struct journal_head *jh)
1583{
1584 if (*list == jh) {
1585 *list = jh->b_tnext;
1586 if (*list == jh)
1587 *list = NULL;
1588 }
1589 jh->b_tprev->b_tnext = jh->b_tnext;
1590 jh->b_tnext->b_tprev = jh->b_tprev;
1591}
1592
1593/*
1594 * Remove a buffer from the appropriate transaction list.
1595 *
1596 * Note that this function can *change* the value of
Jan Kara87c89c22008-07-11 19:27:31 -04001597 * bh->b_transaction->t_buffers, t_forget, t_iobuf_list, t_shadow_list,
1598 * t_log_list or t_reserved_list. If the caller is holding onto a copy of one
1599 * of these pointers, it could go bad. Generally the caller needs to re-read
1600 * the pointer from the transaction_t.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001601 *
Jan Kara5bebccf2012-03-13 22:25:06 -04001602 * Called under j_list_lock.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001603 */
Jan Kara5bebccf2012-03-13 22:25:06 -04001604static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001605{
1606 struct journal_head **list = NULL;
1607 transaction_t *transaction;
1608 struct buffer_head *bh = jh2bh(jh);
1609
1610 J_ASSERT_JH(jh, jbd_is_locked_bh_state(bh));
1611 transaction = jh->b_transaction;
1612 if (transaction)
1613 assert_spin_locked(&transaction->t_journal->j_list_lock);
1614
1615 J_ASSERT_JH(jh, jh->b_jlist < BJ_Types);
1616 if (jh->b_jlist != BJ_None)
Mingming Cao40191912008-01-28 23:58:27 -05001617 J_ASSERT_JH(jh, transaction != NULL);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001618
1619 switch (jh->b_jlist) {
1620 case BJ_None:
1621 return;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001622 case BJ_Metadata:
1623 transaction->t_nr_buffers--;
1624 J_ASSERT_JH(jh, transaction->t_nr_buffers >= 0);
1625 list = &transaction->t_buffers;
1626 break;
1627 case BJ_Forget:
1628 list = &transaction->t_forget;
1629 break;
1630 case BJ_IO:
1631 list = &transaction->t_iobuf_list;
1632 break;
1633 case BJ_Shadow:
1634 list = &transaction->t_shadow_list;
1635 break;
1636 case BJ_LogCtl:
1637 list = &transaction->t_log_list;
1638 break;
1639 case BJ_Reserved:
1640 list = &transaction->t_reserved_list;
1641 break;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001642 }
1643
1644 __blist_del_buffer(list, jh);
1645 jh->b_jlist = BJ_None;
1646 if (test_clear_buffer_jbddirty(bh))
1647 mark_buffer_dirty(bh); /* Expose it to the VM */
1648}
1649
Jan Karade1b7942011-06-13 15:38:22 -04001650/*
1651 * Remove buffer from all transactions.
1652 *
1653 * Called with bh_state lock and j_list_lock
1654 *
1655 * jh and bh may be already freed when this function returns.
1656 */
1657static void __jbd2_journal_unfile_buffer(struct journal_head *jh)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001658{
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001659 __jbd2_journal_temp_unlink_buffer(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001660 jh->b_transaction = NULL;
Jan Karade1b7942011-06-13 15:38:22 -04001661 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001662}
1663
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001664void jbd2_journal_unfile_buffer(journal_t *journal, struct journal_head *jh)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001665{
Jan Karade1b7942011-06-13 15:38:22 -04001666 struct buffer_head *bh = jh2bh(jh);
1667
1668 /* Get reference so that buffer cannot be freed before we unlock it */
1669 get_bh(bh);
1670 jbd_lock_bh_state(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001671 spin_lock(&journal->j_list_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001672 __jbd2_journal_unfile_buffer(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001673 spin_unlock(&journal->j_list_lock);
Jan Karade1b7942011-06-13 15:38:22 -04001674 jbd_unlock_bh_state(bh);
1675 __brelse(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001676}
1677
1678/*
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001679 * Called from jbd2_journal_try_to_free_buffers().
Dave Kleikamp470decc2006-10-11 01:20:57 -07001680 *
1681 * Called under jbd_lock_bh_state(bh)
1682 */
1683static void
1684__journal_try_to_free_buffer(journal_t *journal, struct buffer_head *bh)
1685{
1686 struct journal_head *jh;
1687
1688 jh = bh2jh(bh);
1689
1690 if (buffer_locked(bh) || buffer_dirty(bh))
1691 goto out;
1692
Mingming Cao40191912008-01-28 23:58:27 -05001693 if (jh->b_next_transaction != NULL)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001694 goto out;
1695
1696 spin_lock(&journal->j_list_lock);
Jan Kara87c89c22008-07-11 19:27:31 -04001697 if (jh->b_cp_transaction != NULL && jh->b_transaction == NULL) {
Dave Kleikamp470decc2006-10-11 01:20:57 -07001698 /* written-back checkpointed metadata buffer */
Jan Karac254c9e2012-03-13 22:27:44 -04001699 JBUFFER_TRACE(jh, "remove from checkpoint list");
1700 __jbd2_journal_remove_checkpoint(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001701 }
1702 spin_unlock(&journal->j_list_lock);
1703out:
1704 return;
1705}
1706
Dave Kleikamp470decc2006-10-11 01:20:57 -07001707/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001708 * int jbd2_journal_try_to_free_buffers() - try to free page buffers.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001709 * @journal: journal for operation
1710 * @page: to try and free
Mingming Cao530576b2008-07-13 21:06:39 -04001711 * @gfp_mask: we use the mask to detect how hard should we try to release
1712 * buffers. If __GFP_WAIT and __GFP_FS is set, we wait for commit code to
1713 * release the buffers.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001714 *
1715 *
1716 * For all the buffers on this page,
1717 * if they are fully written out ordered data, move them onto BUF_CLEAN
1718 * so try_to_free_buffers() can reap them.
1719 *
1720 * This function returns non-zero if we wish try_to_free_buffers()
1721 * to be called. We do this if the page is releasable by try_to_free_buffers().
1722 * We also do it if the page has locked or dirty buffers and the caller wants
1723 * us to perform sync or async writeout.
1724 *
1725 * This complicates JBD locking somewhat. We aren't protected by the
1726 * BKL here. We wish to remove the buffer from its committing or
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001727 * running transaction's ->t_datalist via __jbd2_journal_unfile_buffer.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001728 *
1729 * This may *change* the value of transaction_t->t_datalist, so anyone
1730 * who looks at t_datalist needs to lock against this function.
1731 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001732 * Even worse, someone may be doing a jbd2_journal_dirty_data on this
1733 * buffer. So we need to lock against that. jbd2_journal_dirty_data()
Dave Kleikamp470decc2006-10-11 01:20:57 -07001734 * will come out of the lock with the buffer dirty, which makes it
1735 * ineligible for release here.
1736 *
1737 * Who else is affected by this? hmm... Really the only contender
1738 * is do_get_write_access() - it could be looking at the buffer while
1739 * journal_try_to_free_buffer() is changing its state. But that
1740 * cannot happen because we never reallocate freed data as metadata
1741 * while the data is part of a transaction. Yes?
Mingming Cao530576b2008-07-13 21:06:39 -04001742 *
1743 * Return 0 on failure, 1 on success
Dave Kleikamp470decc2006-10-11 01:20:57 -07001744 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001745int jbd2_journal_try_to_free_buffers(journal_t *journal,
Mingming Cao530576b2008-07-13 21:06:39 -04001746 struct page *page, gfp_t gfp_mask)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001747{
1748 struct buffer_head *head;
1749 struct buffer_head *bh;
1750 int ret = 0;
1751
1752 J_ASSERT(PageLocked(page));
1753
1754 head = page_buffers(page);
1755 bh = head;
1756 do {
1757 struct journal_head *jh;
1758
1759 /*
1760 * We take our own ref against the journal_head here to avoid
1761 * having to add tons of locking around each instance of
Mingming Cao530576b2008-07-13 21:06:39 -04001762 * jbd2_journal_put_journal_head().
Dave Kleikamp470decc2006-10-11 01:20:57 -07001763 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001764 jh = jbd2_journal_grab_journal_head(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001765 if (!jh)
1766 continue;
1767
1768 jbd_lock_bh_state(bh);
1769 __journal_try_to_free_buffer(journal, bh);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001770 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001771 jbd_unlock_bh_state(bh);
1772 if (buffer_jbd(bh))
1773 goto busy;
1774 } while ((bh = bh->b_this_page) != head);
Mingming Cao530576b2008-07-13 21:06:39 -04001775
Dave Kleikamp470decc2006-10-11 01:20:57 -07001776 ret = try_to_free_buffers(page);
Mingming Cao530576b2008-07-13 21:06:39 -04001777
Dave Kleikamp470decc2006-10-11 01:20:57 -07001778busy:
1779 return ret;
1780}
1781
1782/*
1783 * This buffer is no longer needed. If it is on an older transaction's
1784 * checkpoint list we need to record it on this transaction's forget list
1785 * to pin this buffer (and hence its checkpointing transaction) down until
1786 * this transaction commits. If the buffer isn't on a checkpoint list, we
1787 * release it.
1788 * Returns non-zero if JBD no longer has an interest in the buffer.
1789 *
1790 * Called under j_list_lock.
1791 *
1792 * Called under jbd_lock_bh_state(bh).
1793 */
1794static int __dispose_buffer(struct journal_head *jh, transaction_t *transaction)
1795{
1796 int may_free = 1;
1797 struct buffer_head *bh = jh2bh(jh);
1798
Dave Kleikamp470decc2006-10-11 01:20:57 -07001799 if (jh->b_cp_transaction) {
1800 JBUFFER_TRACE(jh, "on running+cp transaction");
Jan Karade1b7942011-06-13 15:38:22 -04001801 __jbd2_journal_temp_unlink_buffer(jh);
Jan Karaf91d1d02009-07-13 16:16:20 -04001802 /*
1803 * We don't want to write the buffer anymore, clear the
1804 * bit so that we don't confuse checks in
1805 * __journal_file_buffer
1806 */
1807 clear_buffer_dirty(bh);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001808 __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001809 may_free = 0;
1810 } else {
1811 JBUFFER_TRACE(jh, "on running transaction");
Jan Karade1b7942011-06-13 15:38:22 -04001812 __jbd2_journal_unfile_buffer(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001813 }
1814 return may_free;
1815}
1816
1817/*
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001818 * jbd2_journal_invalidatepage
Dave Kleikamp470decc2006-10-11 01:20:57 -07001819 *
1820 * This code is tricky. It has a number of cases to deal with.
1821 *
1822 * There are two invariants which this code relies on:
1823 *
1824 * i_size must be updated on disk before we start calling invalidatepage on the
1825 * data.
1826 *
1827 * This is done in ext3 by defining an ext3_setattr method which
1828 * updates i_size before truncate gets going. By maintaining this
1829 * invariant, we can be sure that it is safe to throw away any buffers
1830 * attached to the current transaction: once the transaction commits,
1831 * we know that the data will not be needed.
1832 *
1833 * Note however that we can *not* throw away data belonging to the
1834 * previous, committing transaction!
1835 *
1836 * Any disk blocks which *are* part of the previous, committing
1837 * transaction (and which therefore cannot be discarded immediately) are
1838 * not going to be reused in the new running transaction
1839 *
1840 * The bitmap committed_data images guarantee this: any block which is
1841 * allocated in one transaction and removed in the next will be marked
1842 * as in-use in the committed_data bitmap, so cannot be reused until
1843 * the next transaction to delete the block commits. This means that
1844 * leaving committing buffers dirty is quite safe: the disk blocks
1845 * cannot be reallocated to a different file and so buffer aliasing is
1846 * not possible.
1847 *
1848 *
1849 * The above applies mainly to ordered data mode. In writeback mode we
1850 * don't make guarantees about the order in which data hits disk --- in
1851 * particular we don't guarantee that new dirty data is flushed before
1852 * transaction commit --- so it is always safe just to discard data
1853 * immediately in that mode. --sct
1854 */
1855
1856/*
1857 * The journal_unmap_buffer helper function returns zero if the buffer
1858 * concerned remains pinned as an anonymous buffer belonging to an older
1859 * transaction.
1860 *
1861 * We're outside-transaction here. Either or both of j_running_transaction
1862 * and j_committing_transaction may be NULL.
1863 */
Jan Karab794e7a2012-09-26 23:11:13 -04001864static int journal_unmap_buffer(journal_t *journal, struct buffer_head *bh,
1865 int partial_page)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001866{
1867 transaction_t *transaction;
1868 struct journal_head *jh;
1869 int may_free = 1;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001870
1871 BUFFER_TRACE(bh, "entry");
1872
1873 /*
1874 * It is safe to proceed here without the j_list_lock because the
1875 * buffers cannot be stolen by try_to_free_buffers as long as we are
1876 * holding the page lock. --sct
1877 */
1878
1879 if (!buffer_jbd(bh))
1880 goto zap_buffer_unlocked;
1881
Jan Kara87c89c22008-07-11 19:27:31 -04001882 /* OK, we have data buffer in journaled mode */
Theodore Ts'oa931da62010-08-03 21:35:12 -04001883 write_lock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001884 jbd_lock_bh_state(bh);
1885 spin_lock(&journal->j_list_lock);
1886
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001887 jh = jbd2_journal_grab_journal_head(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001888 if (!jh)
1889 goto zap_buffer_no_jh;
1890
dingdinghuaba869022010-02-15 16:35:42 -05001891 /*
1892 * We cannot remove the buffer from checkpoint lists until the
1893 * transaction adding inode to orphan list (let's call it T)
1894 * is committed. Otherwise if the transaction changing the
1895 * buffer would be cleaned from the journal before T is
1896 * committed, a crash will cause that the correct contents of
1897 * the buffer will be lost. On the other hand we have to
1898 * clear the buffer dirty bit at latest at the moment when the
1899 * transaction marking the buffer as freed in the filesystem
1900 * structures is committed because from that moment on the
Jan Karab794e7a2012-09-26 23:11:13 -04001901 * block can be reallocated and used by a different page.
dingdinghuaba869022010-02-15 16:35:42 -05001902 * Since the block hasn't been freed yet but the inode has
1903 * already been added to orphan list, it is safe for us to add
1904 * the buffer to BJ_Forget list of the newest transaction.
Jan Karab794e7a2012-09-26 23:11:13 -04001905 *
1906 * Also we have to clear buffer_mapped flag of a truncated buffer
1907 * because the buffer_head may be attached to the page straddling
1908 * i_size (can happen only when blocksize < pagesize) and thus the
1909 * buffer_head can be reused when the file is extended again. So we end
1910 * up keeping around invalidated buffers attached to transactions'
1911 * BJ_Forget list just to stop checkpointing code from cleaning up
1912 * the transaction this buffer was modified in.
dingdinghuaba869022010-02-15 16:35:42 -05001913 */
Dave Kleikamp470decc2006-10-11 01:20:57 -07001914 transaction = jh->b_transaction;
1915 if (transaction == NULL) {
1916 /* First case: not on any transaction. If it
1917 * has no checkpoint link, then we can zap it:
1918 * it's a writeback-mode buffer so we don't care
1919 * if it hits disk safely. */
1920 if (!jh->b_cp_transaction) {
1921 JBUFFER_TRACE(jh, "not on any transaction: zap");
1922 goto zap_buffer;
1923 }
1924
1925 if (!buffer_dirty(bh)) {
1926 /* bdflush has written it. We can drop it now */
1927 goto zap_buffer;
1928 }
1929
1930 /* OK, it must be in the journal but still not
1931 * written fully to disk: it's metadata or
1932 * journaled data... */
1933
1934 if (journal->j_running_transaction) {
1935 /* ... and once the current transaction has
1936 * committed, the buffer won't be needed any
1937 * longer. */
1938 JBUFFER_TRACE(jh, "checkpointed: add to BJ_Forget");
Jan Karab794e7a2012-09-26 23:11:13 -04001939 may_free = __dispose_buffer(jh,
Dave Kleikamp470decc2006-10-11 01:20:57 -07001940 journal->j_running_transaction);
Jan Karab794e7a2012-09-26 23:11:13 -04001941 goto zap_buffer;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001942 } else {
1943 /* There is no currently-running transaction. So the
1944 * orphan record which we wrote for this file must have
1945 * passed into commit. We must attach this buffer to
1946 * the committing transaction, if it exists. */
1947 if (journal->j_committing_transaction) {
1948 JBUFFER_TRACE(jh, "give to committing trans");
Jan Karab794e7a2012-09-26 23:11:13 -04001949 may_free = __dispose_buffer(jh,
Dave Kleikamp470decc2006-10-11 01:20:57 -07001950 journal->j_committing_transaction);
Jan Karab794e7a2012-09-26 23:11:13 -04001951 goto zap_buffer;
Dave Kleikamp470decc2006-10-11 01:20:57 -07001952 } else {
1953 /* The orphan record's transaction has
1954 * committed. We can cleanse this buffer */
1955 clear_buffer_jbddirty(bh);
1956 goto zap_buffer;
1957 }
1958 }
1959 } else if (transaction == journal->j_committing_transaction) {
Eric Sandeen9b579882006-10-28 10:38:28 -07001960 JBUFFER_TRACE(jh, "on committing transaction");
Dave Kleikamp470decc2006-10-11 01:20:57 -07001961 /*
dingdinghuaba869022010-02-15 16:35:42 -05001962 * The buffer is committing, we simply cannot touch
Jan Karab794e7a2012-09-26 23:11:13 -04001963 * it. If the page is straddling i_size we have to wait
1964 * for commit and try again.
1965 */
1966 if (partial_page) {
Jan Karab794e7a2012-09-26 23:11:13 -04001967 jbd2_journal_put_journal_head(jh);
1968 spin_unlock(&journal->j_list_lock);
1969 jbd_unlock_bh_state(bh);
1970 write_unlock(&journal->j_state_lock);
Jan Kara53e87262012-12-25 13:29:52 -05001971 return -EBUSY;
Jan Karab794e7a2012-09-26 23:11:13 -04001972 }
1973 /*
1974 * OK, buffer won't be reachable after truncate. We just set
1975 * j_next_transaction to the running transaction (if there is
1976 * one) and mark buffer as freed so that commit code knows it
1977 * should clear dirty bits when it is done with the buffer.
dingdinghuaba869022010-02-15 16:35:42 -05001978 */
Dave Kleikamp470decc2006-10-11 01:20:57 -07001979 set_buffer_freed(bh);
dingdinghuaba869022010-02-15 16:35:42 -05001980 if (journal->j_running_transaction && buffer_jbddirty(bh))
1981 jh->b_next_transaction = journal->j_running_transaction;
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001982 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001983 spin_unlock(&journal->j_list_lock);
1984 jbd_unlock_bh_state(bh);
Theodore Ts'oa931da62010-08-03 21:35:12 -04001985 write_unlock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001986 return 0;
1987 } else {
1988 /* Good, the buffer belongs to the running transaction.
1989 * We are writing our own transaction's data, not any
1990 * previous one's, so it is safe to throw it away
1991 * (remember that we expect the filesystem to have set
1992 * i_size already for this truncate so recovery will not
1993 * expose the disk blocks we are discarding here.) */
1994 J_ASSERT_JH(jh, transaction == journal->j_running_transaction);
Eric Sandeen9b579882006-10-28 10:38:28 -07001995 JBUFFER_TRACE(jh, "on running transaction");
Dave Kleikamp470decc2006-10-11 01:20:57 -07001996 may_free = __dispose_buffer(jh, transaction);
1997 }
1998
1999zap_buffer:
Jan Karab794e7a2012-09-26 23:11:13 -04002000 /*
2001 * This is tricky. Although the buffer is truncated, it may be reused
2002 * if blocksize < pagesize and it is attached to the page straddling
2003 * EOF. Since the buffer might have been added to BJ_Forget list of the
2004 * running transaction, journal_get_write_access() won't clear
2005 * b_modified and credit accounting gets confused. So clear b_modified
2006 * here.
2007 */
2008 jh->b_modified = 0;
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002009 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002010zap_buffer_no_jh:
2011 spin_unlock(&journal->j_list_lock);
2012 jbd_unlock_bh_state(bh);
Theodore Ts'oa931da62010-08-03 21:35:12 -04002013 write_unlock(&journal->j_state_lock);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002014zap_buffer_unlocked:
2015 clear_buffer_dirty(bh);
2016 J_ASSERT_BH(bh, !buffer_jbddirty(bh));
2017 clear_buffer_mapped(bh);
2018 clear_buffer_req(bh);
2019 clear_buffer_new(bh);
Eric Sandeen15291162012-02-20 17:53:01 -05002020 clear_buffer_delay(bh);
2021 clear_buffer_unwritten(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002022 bh->b_bdev = NULL;
2023 return may_free;
2024}
2025
2026/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002027 * void jbd2_journal_invalidatepage()
Dave Kleikamp470decc2006-10-11 01:20:57 -07002028 * @journal: journal to use for flush...
2029 * @page: page to flush
2030 * @offset: length of page to invalidate.
2031 *
Jan Kara53e87262012-12-25 13:29:52 -05002032 * Reap page buffers containing data after offset in page. Can return -EBUSY
2033 * if buffers are part of the committing transaction and the page is straddling
2034 * i_size. Caller then has to wait for current commit and try again.
Dave Kleikamp470decc2006-10-11 01:20:57 -07002035 */
Jan Kara53e87262012-12-25 13:29:52 -05002036int jbd2_journal_invalidatepage(journal_t *journal,
2037 struct page *page,
2038 unsigned long offset)
Dave Kleikamp470decc2006-10-11 01:20:57 -07002039{
2040 struct buffer_head *head, *bh, *next;
2041 unsigned int curr_off = 0;
2042 int may_free = 1;
Jan Kara53e87262012-12-25 13:29:52 -05002043 int ret = 0;
Dave Kleikamp470decc2006-10-11 01:20:57 -07002044
2045 if (!PageLocked(page))
2046 BUG();
2047 if (!page_has_buffers(page))
Jan Kara53e87262012-12-25 13:29:52 -05002048 return 0;
Dave Kleikamp470decc2006-10-11 01:20:57 -07002049
2050 /* We will potentially be playing with lists other than just the
2051 * data lists (especially for journaled data mode), so be
2052 * cautious in our locking. */
2053
2054 head = bh = page_buffers(page);
2055 do {
2056 unsigned int next_off = curr_off + bh->b_size;
2057 next = bh->b_this_page;
2058
2059 if (offset <= curr_off) {
2060 /* This block is wholly outside the truncation point */
2061 lock_buffer(bh);
Jan Kara53e87262012-12-25 13:29:52 -05002062 ret = journal_unmap_buffer(journal, bh, offset > 0);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002063 unlock_buffer(bh);
Jan Kara53e87262012-12-25 13:29:52 -05002064 if (ret < 0)
2065 return ret;
2066 may_free &= ret;
Dave Kleikamp470decc2006-10-11 01:20:57 -07002067 }
2068 curr_off = next_off;
2069 bh = next;
2070
2071 } while (bh != head);
2072
2073 if (!offset) {
2074 if (may_free && try_to_free_buffers(page))
2075 J_ASSERT(!page_has_buffers(page));
2076 }
Jan Kara53e87262012-12-25 13:29:52 -05002077 return 0;
Dave Kleikamp470decc2006-10-11 01:20:57 -07002078}
2079
2080/*
2081 * File a buffer on the given transaction list.
2082 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002083void __jbd2_journal_file_buffer(struct journal_head *jh,
Dave Kleikamp470decc2006-10-11 01:20:57 -07002084 transaction_t *transaction, int jlist)
2085{
2086 struct journal_head **list = NULL;
2087 int was_dirty = 0;
2088 struct buffer_head *bh = jh2bh(jh);
2089
2090 J_ASSERT_JH(jh, jbd_is_locked_bh_state(bh));
2091 assert_spin_locked(&transaction->t_journal->j_list_lock);
2092
2093 J_ASSERT_JH(jh, jh->b_jlist < BJ_Types);
2094 J_ASSERT_JH(jh, jh->b_transaction == transaction ||
Mingming Cao40191912008-01-28 23:58:27 -05002095 jh->b_transaction == NULL);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002096
2097 if (jh->b_transaction && jh->b_jlist == jlist)
2098 return;
2099
Dave Kleikamp470decc2006-10-11 01:20:57 -07002100 if (jlist == BJ_Metadata || jlist == BJ_Reserved ||
2101 jlist == BJ_Shadow || jlist == BJ_Forget) {
Jan Karaf91d1d02009-07-13 16:16:20 -04002102 /*
2103 * For metadata buffers, we track dirty bit in buffer_jbddirty
2104 * instead of buffer_dirty. We should not see a dirty bit set
2105 * here because we clear it in do_get_write_access but e.g.
2106 * tune2fs can modify the sb and set the dirty bit at any time
2107 * so we try to gracefully handle that.
2108 */
2109 if (buffer_dirty(bh))
2110 warn_dirty_buffer(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002111 if (test_clear_buffer_dirty(bh) ||
2112 test_clear_buffer_jbddirty(bh))
2113 was_dirty = 1;
2114 }
2115
2116 if (jh->b_transaction)
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002117 __jbd2_journal_temp_unlink_buffer(jh);
Jan Karade1b7942011-06-13 15:38:22 -04002118 else
2119 jbd2_journal_grab_journal_head(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002120 jh->b_transaction = transaction;
2121
2122 switch (jlist) {
2123 case BJ_None:
2124 J_ASSERT_JH(jh, !jh->b_committed_data);
2125 J_ASSERT_JH(jh, !jh->b_frozen_data);
2126 return;
Dave Kleikamp470decc2006-10-11 01:20:57 -07002127 case BJ_Metadata:
2128 transaction->t_nr_buffers++;
2129 list = &transaction->t_buffers;
2130 break;
2131 case BJ_Forget:
2132 list = &transaction->t_forget;
2133 break;
2134 case BJ_IO:
2135 list = &transaction->t_iobuf_list;
2136 break;
2137 case BJ_Shadow:
2138 list = &transaction->t_shadow_list;
2139 break;
2140 case BJ_LogCtl:
2141 list = &transaction->t_log_list;
2142 break;
2143 case BJ_Reserved:
2144 list = &transaction->t_reserved_list;
2145 break;
Dave Kleikamp470decc2006-10-11 01:20:57 -07002146 }
2147
2148 __blist_add_buffer(list, jh);
2149 jh->b_jlist = jlist;
2150
2151 if (was_dirty)
2152 set_buffer_jbddirty(bh);
2153}
2154
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002155void jbd2_journal_file_buffer(struct journal_head *jh,
Dave Kleikamp470decc2006-10-11 01:20:57 -07002156 transaction_t *transaction, int jlist)
2157{
2158 jbd_lock_bh_state(jh2bh(jh));
2159 spin_lock(&transaction->t_journal->j_list_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002160 __jbd2_journal_file_buffer(jh, transaction, jlist);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002161 spin_unlock(&transaction->t_journal->j_list_lock);
2162 jbd_unlock_bh_state(jh2bh(jh));
2163}
2164
2165/*
2166 * Remove a buffer from its current buffer list in preparation for
2167 * dropping it from its current transaction entirely. If the buffer has
2168 * already started to be used by a subsequent transaction, refile the
2169 * buffer on that transaction's metadata list.
2170 *
Jan Karade1b7942011-06-13 15:38:22 -04002171 * Called under j_list_lock
Dave Kleikamp470decc2006-10-11 01:20:57 -07002172 * Called under jbd_lock_bh_state(jh2bh(jh))
Jan Karade1b7942011-06-13 15:38:22 -04002173 *
2174 * jh and bh may be already free when this function returns
Dave Kleikamp470decc2006-10-11 01:20:57 -07002175 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002176void __jbd2_journal_refile_buffer(struct journal_head *jh)
Dave Kleikamp470decc2006-10-11 01:20:57 -07002177{
dingdinghuaba869022010-02-15 16:35:42 -05002178 int was_dirty, jlist;
Dave Kleikamp470decc2006-10-11 01:20:57 -07002179 struct buffer_head *bh = jh2bh(jh);
2180
2181 J_ASSERT_JH(jh, jbd_is_locked_bh_state(bh));
2182 if (jh->b_transaction)
2183 assert_spin_locked(&jh->b_transaction->t_journal->j_list_lock);
2184
2185 /* If the buffer is now unused, just drop it. */
2186 if (jh->b_next_transaction == NULL) {
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002187 __jbd2_journal_unfile_buffer(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002188 return;
2189 }
2190
2191 /*
2192 * It has been modified by a later transaction: add it to the new
2193 * transaction's metadata list.
2194 */
2195
2196 was_dirty = test_clear_buffer_jbddirty(bh);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002197 __jbd2_journal_temp_unlink_buffer(jh);
Jan Karade1b7942011-06-13 15:38:22 -04002198 /*
2199 * We set b_transaction here because b_next_transaction will inherit
2200 * our jh reference and thus __jbd2_journal_file_buffer() must not
2201 * take a new one.
2202 */
Dave Kleikamp470decc2006-10-11 01:20:57 -07002203 jh->b_transaction = jh->b_next_transaction;
2204 jh->b_next_transaction = NULL;
dingdinghuaba869022010-02-15 16:35:42 -05002205 if (buffer_freed(bh))
2206 jlist = BJ_Forget;
2207 else if (jh->b_modified)
2208 jlist = BJ_Metadata;
2209 else
2210 jlist = BJ_Reserved;
2211 __jbd2_journal_file_buffer(jh, jh->b_transaction, jlist);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002212 J_ASSERT_JH(jh, jh->b_transaction->t_state == T_RUNNING);
2213
2214 if (was_dirty)
2215 set_buffer_jbddirty(bh);
2216}
2217
2218/*
Jan Karade1b7942011-06-13 15:38:22 -04002219 * __jbd2_journal_refile_buffer() with necessary locking added. We take our
2220 * bh reference so that we can safely unlock bh.
Dave Kleikamp470decc2006-10-11 01:20:57 -07002221 *
Jan Karade1b7942011-06-13 15:38:22 -04002222 * The jh and bh may be freed by this call.
Dave Kleikamp470decc2006-10-11 01:20:57 -07002223 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002224void jbd2_journal_refile_buffer(journal_t *journal, struct journal_head *jh)
Dave Kleikamp470decc2006-10-11 01:20:57 -07002225{
2226 struct buffer_head *bh = jh2bh(jh);
2227
Jan Karade1b7942011-06-13 15:38:22 -04002228 /* Get reference so that buffer cannot be freed before we unlock it */
2229 get_bh(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002230 jbd_lock_bh_state(bh);
2231 spin_lock(&journal->j_list_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002232 __jbd2_journal_refile_buffer(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002233 jbd_unlock_bh_state(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002234 spin_unlock(&journal->j_list_lock);
2235 __brelse(bh);
2236}
Jan Karac851ed52008-07-11 19:27:31 -04002237
2238/*
2239 * File inode in the inode list of the handle's transaction
2240 */
2241int jbd2_journal_file_inode(handle_t *handle, struct jbd2_inode *jinode)
2242{
2243 transaction_t *transaction = handle->h_transaction;
2244 journal_t *journal = transaction->t_journal;
2245
2246 if (is_handle_aborted(handle))
2247 return -EIO;
2248
2249 jbd_debug(4, "Adding inode %lu, tid:%d\n", jinode->i_vfs_inode->i_ino,
2250 transaction->t_tid);
2251
2252 /*
2253 * First check whether inode isn't already on the transaction's
2254 * lists without taking the lock. Note that this check is safe
2255 * without the lock as we cannot race with somebody removing inode
2256 * from the transaction. The reason is that we remove inode from the
2257 * transaction only in journal_release_jbd_inode() and when we commit
2258 * the transaction. We are guarded from the first case by holding
2259 * a reference to the inode. We are safe against the second case
2260 * because if jinode->i_transaction == transaction, commit code
2261 * cannot touch the transaction because we hold reference to it,
2262 * and if jinode->i_next_transaction == transaction, commit code
2263 * will only file the inode where we want it.
2264 */
2265 if (jinode->i_transaction == transaction ||
2266 jinode->i_next_transaction == transaction)
2267 return 0;
2268
2269 spin_lock(&journal->j_list_lock);
2270
2271 if (jinode->i_transaction == transaction ||
2272 jinode->i_next_transaction == transaction)
2273 goto done;
2274
Jan Kara81be12c2011-05-24 11:52:40 -04002275 /*
2276 * We only ever set this variable to 1 so the test is safe. Since
2277 * t_need_data_flush is likely to be set, we do the test to save some
2278 * cacheline bouncing
2279 */
2280 if (!transaction->t_need_data_flush)
2281 transaction->t_need_data_flush = 1;
Jan Karac851ed52008-07-11 19:27:31 -04002282 /* On some different transaction's list - should be
2283 * the committing one */
2284 if (jinode->i_transaction) {
2285 J_ASSERT(jinode->i_next_transaction == NULL);
2286 J_ASSERT(jinode->i_transaction ==
2287 journal->j_committing_transaction);
2288 jinode->i_next_transaction = transaction;
2289 goto done;
2290 }
2291 /* Not on any transaction list... */
2292 J_ASSERT(!jinode->i_next_transaction);
2293 jinode->i_transaction = transaction;
2294 list_add(&jinode->i_list, &transaction->t_inode_list);
2295done:
2296 spin_unlock(&journal->j_list_lock);
2297
2298 return 0;
2299}
2300
2301/*
Jan Kara7f5aa212009-02-10 11:15:34 -05002302 * File truncate and transaction commit interact with each other in a
2303 * non-trivial way. If a transaction writing data block A is
2304 * committing, we cannot discard the data by truncate until we have
2305 * written them. Otherwise if we crashed after the transaction with
2306 * write has committed but before the transaction with truncate has
2307 * committed, we could see stale data in block A. This function is a
2308 * helper to solve this problem. It starts writeout of the truncated
2309 * part in case it is in the committing transaction.
2310 *
2311 * Filesystem code must call this function when inode is journaled in
2312 * ordered mode before truncation happens and after the inode has been
2313 * placed on orphan list with the new inode size. The second condition
2314 * avoids the race that someone writes new data and we start
2315 * committing the transaction after this function has been called but
2316 * before a transaction for truncate is started (and furthermore it
2317 * allows us to optimize the case where the addition to orphan list
2318 * happens in the same transaction as write --- we don't have to write
2319 * any data in such case).
Jan Karac851ed52008-07-11 19:27:31 -04002320 */
Jan Kara7f5aa212009-02-10 11:15:34 -05002321int jbd2_journal_begin_ordered_truncate(journal_t *journal,
2322 struct jbd2_inode *jinode,
Jan Karac851ed52008-07-11 19:27:31 -04002323 loff_t new_size)
2324{
Jan Kara7f5aa212009-02-10 11:15:34 -05002325 transaction_t *inode_trans, *commit_trans;
Jan Karac851ed52008-07-11 19:27:31 -04002326 int ret = 0;
2327
Jan Kara7f5aa212009-02-10 11:15:34 -05002328 /* This is a quick check to avoid locking if not necessary */
2329 if (!jinode->i_transaction)
Jan Karac851ed52008-07-11 19:27:31 -04002330 goto out;
Jan Kara7f5aa212009-02-10 11:15:34 -05002331 /* Locks are here just to force reading of recent values, it is
2332 * enough that the transaction was not committing before we started
2333 * a transaction adding the inode to orphan list */
Theodore Ts'oa931da62010-08-03 21:35:12 -04002334 read_lock(&journal->j_state_lock);
Jan Karac851ed52008-07-11 19:27:31 -04002335 commit_trans = journal->j_committing_transaction;
Theodore Ts'oa931da62010-08-03 21:35:12 -04002336 read_unlock(&journal->j_state_lock);
Jan Kara7f5aa212009-02-10 11:15:34 -05002337 spin_lock(&journal->j_list_lock);
2338 inode_trans = jinode->i_transaction;
2339 spin_unlock(&journal->j_list_lock);
2340 if (inode_trans == commit_trans) {
2341 ret = filemap_fdatawrite_range(jinode->i_vfs_inode->i_mapping,
Jan Karac851ed52008-07-11 19:27:31 -04002342 new_size, LLONG_MAX);
2343 if (ret)
2344 jbd2_journal_abort(journal, ret);
2345 }
2346out:
2347 return ret;
2348}