blob: b9b0b6f899b91b2000cc4f34e72c97931670fe53 [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>
28
Adrian Bunk7ddae862006-12-06 20:38:27 -080029static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh);
30
Dave Kleikamp470decc2006-10-11 01:20:57 -070031/*
Mingming Caof7f4bcc2006-10-11 01:20:59 -070032 * jbd2_get_transaction: obtain a new transaction_t object.
Dave Kleikamp470decc2006-10-11 01:20:57 -070033 *
34 * Simply allocate and initialise a new transaction. Create it in
35 * RUNNING state and add it to the current journal (which should not
36 * have an existing running transaction: we only make a new transaction
37 * once we have started to commit the old one).
38 *
39 * Preconditions:
40 * The journal MUST be locked. We don't perform atomic mallocs on the
41 * new transaction and we can't block without protecting against other
42 * processes trying to touch the journal while it is in transition.
43 *
44 * Called under j_state_lock
45 */
46
47static transaction_t *
Mingming Caof7f4bcc2006-10-11 01:20:59 -070048jbd2_get_transaction(journal_t *journal, transaction_t *transaction)
Dave Kleikamp470decc2006-10-11 01:20:57 -070049{
50 transaction->t_journal = journal;
51 transaction->t_state = T_RUNNING;
52 transaction->t_tid = journal->j_transaction_sequence++;
53 transaction->t_expires = jiffies + journal->j_commit_interval;
54 spin_lock_init(&transaction->t_handle_lock);
55
56 /* Set up the commit timer for the new transaction. */
Mingming Caodb857da2008-01-28 23:58:27 -050057 journal->j_commit_timer.expires = round_jiffies(transaction->t_expires);
Dave Kleikamp470decc2006-10-11 01:20:57 -070058 add_timer(&journal->j_commit_timer);
59
60 J_ASSERT(journal->j_running_transaction == NULL);
61 journal->j_running_transaction = transaction;
Johann Lombardi8e85fb32008-01-28 23:58:27 -050062 transaction->t_max_wait = 0;
63 transaction->t_start = jiffies;
Dave Kleikamp470decc2006-10-11 01:20:57 -070064
65 return transaction;
66}
67
68/*
69 * Handle management.
70 *
71 * A handle_t is an object which represents a single atomic update to a
72 * filesystem, and which tracks all of the modifications which form part
73 * of that one update.
74 */
75
76/*
77 * start_this_handle: Given a handle, deal with any locking or stalling
78 * needed to make sure that there is enough journal space for the handle
79 * to begin. Attach the handle to a transaction and set up the
80 * transaction's buffer credits.
81 */
82
83static int start_this_handle(journal_t *journal, handle_t *handle)
84{
85 transaction_t *transaction;
86 int needed;
87 int nblocks = handle->h_buffer_credits;
88 transaction_t *new_transaction = NULL;
89 int ret = 0;
Johann Lombardi8e85fb32008-01-28 23:58:27 -050090 unsigned long ts = jiffies;
Dave Kleikamp470decc2006-10-11 01:20:57 -070091
92 if (nblocks > journal->j_max_transaction_buffers) {
93 printk(KERN_ERR "JBD: %s wants too many credits (%d > %d)\n",
94 current->comm, nblocks,
95 journal->j_max_transaction_buffers);
96 ret = -ENOSPC;
97 goto out;
98 }
99
100alloc_transaction:
101 if (!journal->j_running_transaction) {
Mingming Caod802ffa2007-10-16 18:38:25 -0400102 new_transaction = kzalloc(sizeof(*new_transaction),
Mingming Cao2d9179692007-10-16 18:38:25 -0400103 GFP_NOFS|__GFP_NOFAIL);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700104 if (!new_transaction) {
105 ret = -ENOMEM;
106 goto out;
107 }
Dave Kleikamp470decc2006-10-11 01:20:57 -0700108 }
109
110 jbd_debug(3, "New handle %p going live.\n", handle);
111
112repeat:
113
114 /*
115 * We need to hold j_state_lock until t_updates has been incremented,
116 * for proper journal barrier handling
117 */
118 spin_lock(&journal->j_state_lock);
119repeat_locked:
120 if (is_journal_aborted(journal) ||
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700121 (journal->j_errno != 0 && !(journal->j_flags & JBD2_ACK_ERR))) {
Dave Kleikamp470decc2006-10-11 01:20:57 -0700122 spin_unlock(&journal->j_state_lock);
123 ret = -EROFS;
124 goto out;
125 }
126
127 /* Wait on the journal's transaction barrier if necessary */
128 if (journal->j_barrier_count) {
129 spin_unlock(&journal->j_state_lock);
130 wait_event(journal->j_wait_transaction_locked,
131 journal->j_barrier_count == 0);
132 goto repeat;
133 }
134
135 if (!journal->j_running_transaction) {
136 if (!new_transaction) {
137 spin_unlock(&journal->j_state_lock);
138 goto alloc_transaction;
139 }
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700140 jbd2_get_transaction(journal, new_transaction);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700141 new_transaction = NULL;
142 }
143
144 transaction = journal->j_running_transaction;
145
146 /*
147 * If the current transaction is locked down for commit, wait for the
148 * lock to be released.
149 */
150 if (transaction->t_state == T_LOCKED) {
151 DEFINE_WAIT(wait);
152
153 prepare_to_wait(&journal->j_wait_transaction_locked,
154 &wait, TASK_UNINTERRUPTIBLE);
155 spin_unlock(&journal->j_state_lock);
156 schedule();
157 finish_wait(&journal->j_wait_transaction_locked, &wait);
158 goto repeat;
159 }
160
161 /*
162 * If there is not enough space left in the log to write all potential
163 * buffers requested by this operation, we need to stall pending a log
164 * checkpoint to free some more log space.
165 */
166 spin_lock(&transaction->t_handle_lock);
167 needed = transaction->t_outstanding_credits + nblocks;
168
169 if (needed > journal->j_max_transaction_buffers) {
170 /*
171 * If the current transaction is already too large, then start
172 * to commit it: we can then go back and attach this handle to
173 * a new transaction.
174 */
175 DEFINE_WAIT(wait);
176
177 jbd_debug(2, "Handle %p starting new commit...\n", handle);
178 spin_unlock(&transaction->t_handle_lock);
179 prepare_to_wait(&journal->j_wait_transaction_locked, &wait,
180 TASK_UNINTERRUPTIBLE);
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700181 __jbd2_log_start_commit(journal, transaction->t_tid);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700182 spin_unlock(&journal->j_state_lock);
183 schedule();
184 finish_wait(&journal->j_wait_transaction_locked, &wait);
185 goto repeat;
186 }
187
188 /*
189 * The commit code assumes that it can get enough log space
190 * without forcing a checkpoint. This is *critical* for
191 * correctness: a checkpoint of a buffer which is also
192 * associated with a committing transaction creates a deadlock,
193 * so commit simply cannot force through checkpoints.
194 *
195 * We must therefore ensure the necessary space in the journal
196 * *before* starting to dirty potentially checkpointed buffers
197 * in the new transaction.
198 *
199 * The worst part is, any transaction currently committing can
200 * reduce the free space arbitrarily. Be careful to account for
201 * those buffers when checkpointing.
202 */
203
204 /*
205 * @@@ AKPM: This seems rather over-defensive. We're giving commit
206 * a _lot_ of headroom: 1/4 of the journal plus the size of
207 * the committing transaction. Really, we only need to give it
208 * committing_transaction->t_outstanding_credits plus "enough" for
209 * the log control blocks.
210 * Also, this test is inconsitent with the matching one in
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700211 * jbd2_journal_extend().
Dave Kleikamp470decc2006-10-11 01:20:57 -0700212 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700213 if (__jbd2_log_space_left(journal) < jbd_space_needed(journal)) {
Dave Kleikamp470decc2006-10-11 01:20:57 -0700214 jbd_debug(2, "Handle %p waiting for checkpoint...\n", handle);
215 spin_unlock(&transaction->t_handle_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700216 __jbd2_log_wait_for_space(journal);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700217 goto repeat_locked;
218 }
219
220 /* OK, account for the buffers that this operation expects to
221 * use and add the handle to the running transaction. */
222
Johann Lombardi8e85fb32008-01-28 23:58:27 -0500223 if (time_after(transaction->t_start, ts)) {
224 ts = jbd2_time_diff(ts, transaction->t_start);
225 if (ts > transaction->t_max_wait)
226 transaction->t_max_wait = ts;
227 }
228
Dave Kleikamp470decc2006-10-11 01:20:57 -0700229 handle->h_transaction = transaction;
230 transaction->t_outstanding_credits += nblocks;
231 transaction->t_updates++;
232 transaction->t_handle_count++;
233 jbd_debug(4, "Handle %p given %d credits (total %d, free %d)\n",
234 handle, nblocks, transaction->t_outstanding_credits,
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700235 __jbd2_log_space_left(journal));
Dave Kleikamp470decc2006-10-11 01:20:57 -0700236 spin_unlock(&transaction->t_handle_lock);
237 spin_unlock(&journal->j_state_lock);
238out:
239 if (unlikely(new_transaction)) /* It's usually NULL */
240 kfree(new_transaction);
241 return ret;
242}
243
Mingming Cao7b751062008-01-28 23:58:27 -0500244static struct lock_class_key jbd2_handle_key;
245
Dave Kleikamp470decc2006-10-11 01:20:57 -0700246/* Allocate a new handle. This should probably be in a slab... */
247static handle_t *new_handle(int nblocks)
248{
Mingming Caoaf1e76d2007-10-16 18:38:25 -0400249 handle_t *handle = jbd2_alloc_handle(GFP_NOFS);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700250 if (!handle)
251 return NULL;
252 memset(handle, 0, sizeof(*handle));
253 handle->h_buffer_credits = nblocks;
254 handle->h_ref = 1;
255
Mingming Cao7b751062008-01-28 23:58:27 -0500256 lockdep_init_map(&handle->h_lockdep_map, "jbd2_handle",
257 &jbd2_handle_key, 0);
258
Dave Kleikamp470decc2006-10-11 01:20:57 -0700259 return handle;
260}
261
262/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700263 * handle_t *jbd2_journal_start() - Obtain a new handle.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700264 * @journal: Journal to start transaction on.
265 * @nblocks: number of block buffer we might modify
266 *
267 * We make sure that the transaction can guarantee at least nblocks of
268 * modified buffers in the log. We block until the log can guarantee
269 * that much space.
270 *
271 * This function is visible to journal users (like ext3fs), so is not
272 * called with the journal already locked.
273 *
274 * Return a pointer to a newly allocated handle, or NULL on failure
275 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700276handle_t *jbd2_journal_start(journal_t *journal, int nblocks)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700277{
278 handle_t *handle = journal_current_handle();
279 int err;
280
281 if (!journal)
282 return ERR_PTR(-EROFS);
283
284 if (handle) {
285 J_ASSERT(handle->h_transaction->t_journal == journal);
286 handle->h_ref++;
287 return handle;
288 }
289
290 handle = new_handle(nblocks);
291 if (!handle)
292 return ERR_PTR(-ENOMEM);
293
294 current->journal_info = handle;
295
296 err = start_this_handle(journal, handle);
297 if (err < 0) {
Mingming Caoaf1e76d2007-10-16 18:38:25 -0400298 jbd2_free_handle(handle);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700299 current->journal_info = NULL;
300 handle = ERR_PTR(err);
Mingming Cao7b751062008-01-28 23:58:27 -0500301 goto out;
Dave Kleikamp470decc2006-10-11 01:20:57 -0700302 }
Mingming Cao7b751062008-01-28 23:58:27 -0500303
304 lock_acquire(&handle->h_lockdep_map, 0, 0, 0, 2, _THIS_IP_);
305out:
Dave Kleikamp470decc2006-10-11 01:20:57 -0700306 return handle;
307}
308
309/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700310 * int jbd2_journal_extend() - extend buffer credits.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700311 * @handle: handle to 'extend'
312 * @nblocks: nr blocks to try to extend by.
313 *
314 * Some transactions, such as large extends and truncates, can be done
315 * atomically all at once or in several stages. The operation requests
316 * a credit for a number of buffer modications in advance, but can
317 * extend its credit if it needs more.
318 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700319 * jbd2_journal_extend tries to give the running handle more buffer credits.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700320 * It does not guarantee that allocation - this is a best-effort only.
321 * The calling process MUST be able to deal cleanly with a failure to
322 * extend here.
323 *
324 * Return 0 on success, non-zero on failure.
325 *
326 * return code < 0 implies an error
327 * return code > 0 implies normal transaction-full status.
328 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700329int jbd2_journal_extend(handle_t *handle, int nblocks)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700330{
331 transaction_t *transaction = handle->h_transaction;
332 journal_t *journal = transaction->t_journal;
333 int result;
334 int wanted;
335
336 result = -EIO;
337 if (is_handle_aborted(handle))
338 goto out;
339
340 result = 1;
341
342 spin_lock(&journal->j_state_lock);
343
344 /* Don't extend a locked-down transaction! */
345 if (handle->h_transaction->t_state != T_RUNNING) {
346 jbd_debug(3, "denied handle %p %d blocks: "
347 "transaction not running\n", handle, nblocks);
348 goto error_out;
349 }
350
351 spin_lock(&transaction->t_handle_lock);
352 wanted = transaction->t_outstanding_credits + nblocks;
353
354 if (wanted > journal->j_max_transaction_buffers) {
355 jbd_debug(3, "denied handle %p %d blocks: "
356 "transaction too large\n", handle, nblocks);
357 goto unlock;
358 }
359
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700360 if (wanted > __jbd2_log_space_left(journal)) {
Dave Kleikamp470decc2006-10-11 01:20:57 -0700361 jbd_debug(3, "denied handle %p %d blocks: "
362 "insufficient log space\n", handle, nblocks);
363 goto unlock;
364 }
365
366 handle->h_buffer_credits += nblocks;
367 transaction->t_outstanding_credits += nblocks;
368 result = 0;
369
370 jbd_debug(3, "extended handle %p by %d\n", handle, nblocks);
371unlock:
372 spin_unlock(&transaction->t_handle_lock);
373error_out:
374 spin_unlock(&journal->j_state_lock);
375out:
376 return result;
377}
378
379
380/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700381 * int jbd2_journal_restart() - restart a handle .
Dave Kleikamp470decc2006-10-11 01:20:57 -0700382 * @handle: handle to restart
383 * @nblocks: nr credits requested
384 *
385 * Restart a handle for a multi-transaction filesystem
386 * operation.
387 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700388 * If the jbd2_journal_extend() call above fails to grant new buffer credits
389 * to a running handle, a call to jbd2_journal_restart will commit the
Dave Kleikamp470decc2006-10-11 01:20:57 -0700390 * handle's transaction so far and reattach the handle to a new
391 * transaction capabable of guaranteeing the requested number of
392 * credits.
393 */
394
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700395int jbd2_journal_restart(handle_t *handle, int nblocks)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700396{
397 transaction_t *transaction = handle->h_transaction;
398 journal_t *journal = transaction->t_journal;
399 int ret;
400
401 /* If we've had an abort of any type, don't even think about
402 * actually doing the restart! */
403 if (is_handle_aborted(handle))
404 return 0;
405
406 /*
407 * First unlink the handle from its current transaction, and start the
408 * commit on that.
409 */
410 J_ASSERT(transaction->t_updates > 0);
411 J_ASSERT(journal_current_handle() == handle);
412
413 spin_lock(&journal->j_state_lock);
414 spin_lock(&transaction->t_handle_lock);
415 transaction->t_outstanding_credits -= handle->h_buffer_credits;
416 transaction->t_updates--;
417
418 if (!transaction->t_updates)
419 wake_up(&journal->j_wait_updates);
420 spin_unlock(&transaction->t_handle_lock);
421
422 jbd_debug(2, "restarting handle %p\n", handle);
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700423 __jbd2_log_start_commit(journal, transaction->t_tid);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700424 spin_unlock(&journal->j_state_lock);
425
426 handle->h_buffer_credits = nblocks;
427 ret = start_this_handle(journal, handle);
428 return ret;
429}
430
431
432/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700433 * void jbd2_journal_lock_updates () - establish a transaction barrier.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700434 * @journal: Journal to establish a barrier on.
435 *
436 * This locks out any further updates from being started, and blocks
437 * until all existing updates have completed, returning only once the
438 * journal is in a quiescent state with no updates running.
439 *
440 * The journal lock should not be held on entry.
441 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700442void jbd2_journal_lock_updates(journal_t *journal)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700443{
444 DEFINE_WAIT(wait);
445
446 spin_lock(&journal->j_state_lock);
447 ++journal->j_barrier_count;
448
449 /* Wait until there are no running updates */
450 while (1) {
451 transaction_t *transaction = journal->j_running_transaction;
452
453 if (!transaction)
454 break;
455
456 spin_lock(&transaction->t_handle_lock);
457 if (!transaction->t_updates) {
458 spin_unlock(&transaction->t_handle_lock);
459 break;
460 }
461 prepare_to_wait(&journal->j_wait_updates, &wait,
462 TASK_UNINTERRUPTIBLE);
463 spin_unlock(&transaction->t_handle_lock);
464 spin_unlock(&journal->j_state_lock);
465 schedule();
466 finish_wait(&journal->j_wait_updates, &wait);
467 spin_lock(&journal->j_state_lock);
468 }
469 spin_unlock(&journal->j_state_lock);
470
471 /*
472 * We have now established a barrier against other normal updates, but
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700473 * we also need to barrier against other jbd2_journal_lock_updates() calls
Dave Kleikamp470decc2006-10-11 01:20:57 -0700474 * to make sure that we serialise special journal-locked operations
475 * too.
476 */
477 mutex_lock(&journal->j_barrier);
478}
479
480/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700481 * void jbd2_journal_unlock_updates (journal_t* journal) - release barrier
Dave Kleikamp470decc2006-10-11 01:20:57 -0700482 * @journal: Journal to release the barrier on.
483 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700484 * Release a transaction barrier obtained with jbd2_journal_lock_updates().
Dave Kleikamp470decc2006-10-11 01:20:57 -0700485 *
486 * Should be called without the journal lock held.
487 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700488void jbd2_journal_unlock_updates (journal_t *journal)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700489{
490 J_ASSERT(journal->j_barrier_count != 0);
491
492 mutex_unlock(&journal->j_barrier);
493 spin_lock(&journal->j_state_lock);
494 --journal->j_barrier_count;
495 spin_unlock(&journal->j_state_lock);
496 wake_up(&journal->j_wait_transaction_locked);
497}
498
499/*
500 * Report any unexpected dirty buffers which turn up. Normally those
501 * indicate an error, but they can occur if the user is running (say)
502 * tune2fs to modify the live filesystem, so we need the option of
503 * continuing as gracefully as possible. #
504 *
505 * The caller should already hold the journal lock and
506 * j_list_lock spinlock: most callers will need those anyway
507 * in order to probe the buffer's journaling state safely.
508 */
509static void jbd_unexpected_dirty_buffer(struct journal_head *jh)
510{
511 int jlist;
512
513 /* If this buffer is one which might reasonably be dirty
514 * --- ie. data, or not part of this journal --- then
515 * we're OK to leave it alone, but otherwise we need to
516 * move the dirty bit to the journal's own internal
517 * JBDDirty bit. */
518 jlist = jh->b_jlist;
519
520 if (jlist == BJ_Metadata || jlist == BJ_Reserved ||
521 jlist == BJ_Shadow || jlist == BJ_Forget) {
522 struct buffer_head *bh = jh2bh(jh);
523
524 if (test_clear_buffer_dirty(bh))
525 set_buffer_jbddirty(bh);
526 }
527}
528
529/*
530 * If the buffer is already part of the current transaction, then there
531 * is nothing we need to do. If it is already part of a prior
532 * transaction which we are still committing to disk, then we need to
533 * make sure that we do not overwrite the old copy: we do copy-out to
534 * preserve the copy going to disk. We also account the buffer against
535 * the handle's metadata buffer credits (unless the buffer is already
536 * part of the transaction, that is).
537 *
538 */
539static int
540do_get_write_access(handle_t *handle, struct journal_head *jh,
541 int force_copy)
542{
543 struct buffer_head *bh;
544 transaction_t *transaction;
545 journal_t *journal;
546 int error;
547 char *frozen_buffer = NULL;
548 int need_copy = 0;
549
550 if (is_handle_aborted(handle))
551 return -EROFS;
552
553 transaction = handle->h_transaction;
554 journal = transaction->t_journal;
555
556 jbd_debug(5, "buffer_head %p, force_copy %d\n", jh, force_copy);
557
558 JBUFFER_TRACE(jh, "entry");
559repeat:
560 bh = jh2bh(jh);
561
562 /* @@@ Need to check for errors here at some point. */
563
564 lock_buffer(bh);
565 jbd_lock_bh_state(bh);
566
567 /* We now hold the buffer lock so it is safe to query the buffer
568 * state. Is the buffer dirty?
569 *
570 * If so, there are two possibilities. The buffer may be
571 * non-journaled, and undergoing a quite legitimate writeback.
572 * Otherwise, it is journaled, and we don't expect dirty buffers
573 * in that state (the buffers should be marked JBD_Dirty
574 * instead.) So either the IO is being done under our own
575 * control and this is a bug, or it's a third party IO such as
576 * dump(8) (which may leave the buffer scheduled for read ---
577 * ie. locked but not dirty) or tune2fs (which may actually have
578 * the buffer dirtied, ugh.) */
579
580 if (buffer_dirty(bh)) {
581 /*
582 * First question: is this buffer already part of the current
583 * transaction or the existing committing transaction?
584 */
585 if (jh->b_transaction) {
586 J_ASSERT_JH(jh,
587 jh->b_transaction == transaction ||
588 jh->b_transaction ==
589 journal->j_committing_transaction);
590 if (jh->b_next_transaction)
591 J_ASSERT_JH(jh, jh->b_next_transaction ==
592 transaction);
593 }
594 /*
595 * In any case we need to clean the dirty flag and we must
596 * do it under the buffer lock to be sure we don't race
597 * with running write-out.
598 */
599 JBUFFER_TRACE(jh, "Unexpected dirty buffer");
600 jbd_unexpected_dirty_buffer(jh);
601 }
602
603 unlock_buffer(bh);
604
605 error = -EROFS;
606 if (is_handle_aborted(handle)) {
607 jbd_unlock_bh_state(bh);
608 goto out;
609 }
610 error = 0;
611
612 /*
613 * The buffer is already part of this transaction if b_transaction or
614 * b_next_transaction points to it
615 */
616 if (jh->b_transaction == transaction ||
617 jh->b_next_transaction == transaction)
618 goto done;
619
620 /*
621 * If there is already a copy-out version of this buffer, then we don't
622 * need to make another one
623 */
624 if (jh->b_frozen_data) {
625 JBUFFER_TRACE(jh, "has frozen data");
626 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
627 jh->b_next_transaction = transaction;
628 goto done;
629 }
630
631 /* Is there data here we need to preserve? */
632
633 if (jh->b_transaction && jh->b_transaction != transaction) {
634 JBUFFER_TRACE(jh, "owned by older transaction");
635 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
636 J_ASSERT_JH(jh, jh->b_transaction ==
637 journal->j_committing_transaction);
638
639 /* There is one case we have to be very careful about.
640 * If the committing transaction is currently writing
641 * this buffer out to disk and has NOT made a copy-out,
642 * then we cannot modify the buffer contents at all
643 * right now. The essence of copy-out is that it is the
644 * extra copy, not the primary copy, which gets
645 * journaled. If the primary copy is already going to
646 * disk then we cannot do copy-out here. */
647
648 if (jh->b_jlist == BJ_Shadow) {
649 DEFINE_WAIT_BIT(wait, &bh->b_state, BH_Unshadow);
650 wait_queue_head_t *wqh;
651
652 wqh = bit_waitqueue(&bh->b_state, BH_Unshadow);
653
654 JBUFFER_TRACE(jh, "on shadow: sleep");
655 jbd_unlock_bh_state(bh);
656 /* commit wakes up all shadow buffers after IO */
657 for ( ; ; ) {
658 prepare_to_wait(wqh, &wait.wait,
659 TASK_UNINTERRUPTIBLE);
660 if (jh->b_jlist != BJ_Shadow)
661 break;
662 schedule();
663 }
664 finish_wait(wqh, &wait.wait);
665 goto repeat;
666 }
667
668 /* Only do the copy if the currently-owning transaction
669 * still needs it. If it is on the Forget list, the
670 * committing transaction is past that stage. The
671 * buffer had better remain locked during the kmalloc,
672 * but that should be true --- we hold the journal lock
673 * still and the buffer is already on the BUF_JOURNAL
674 * list so won't be flushed.
675 *
676 * Subtle point, though: if this is a get_undo_access,
677 * then we will be relying on the frozen_data to contain
678 * the new value of the committed_data record after the
679 * transaction, so we HAVE to force the frozen_data copy
680 * in that case. */
681
682 if (jh->b_jlist != BJ_Forget || force_copy) {
683 JBUFFER_TRACE(jh, "generate frozen data");
684 if (!frozen_buffer) {
685 JBUFFER_TRACE(jh, "allocate memory for buffer");
686 jbd_unlock_bh_state(bh);
687 frozen_buffer =
Mingming Caoaf1e76d2007-10-16 18:38:25 -0400688 jbd2_alloc(jh2bh(jh)->b_size,
Dave Kleikamp470decc2006-10-11 01:20:57 -0700689 GFP_NOFS);
690 if (!frozen_buffer) {
691 printk(KERN_EMERG
692 "%s: OOM for frozen_buffer\n",
693 __FUNCTION__);
694 JBUFFER_TRACE(jh, "oom!");
695 error = -ENOMEM;
696 jbd_lock_bh_state(bh);
697 goto done;
698 }
699 goto repeat;
700 }
701 jh->b_frozen_data = frozen_buffer;
702 frozen_buffer = NULL;
703 need_copy = 1;
704 }
705 jh->b_next_transaction = transaction;
706 }
707
708
709 /*
710 * Finally, if the buffer is not journaled right now, we need to make
711 * sure it doesn't get written to disk before the caller actually
712 * commits the new data
713 */
714 if (!jh->b_transaction) {
715 JBUFFER_TRACE(jh, "no transaction");
716 J_ASSERT_JH(jh, !jh->b_next_transaction);
717 jh->b_transaction = transaction;
718 JBUFFER_TRACE(jh, "file as BJ_Reserved");
719 spin_lock(&journal->j_list_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700720 __jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700721 spin_unlock(&journal->j_list_lock);
722 }
723
724done:
725 if (need_copy) {
726 struct page *page;
727 int offset;
728 char *source;
729
730 J_EXPECT_JH(jh, buffer_uptodate(jh2bh(jh)),
731 "Possible IO failure.\n");
732 page = jh2bh(jh)->b_page;
733 offset = ((unsigned long) jh2bh(jh)->b_data) & ~PAGE_MASK;
734 source = kmap_atomic(page, KM_USER0);
735 memcpy(jh->b_frozen_data, source+offset, jh2bh(jh)->b_size);
736 kunmap_atomic(source, KM_USER0);
737 }
738 jbd_unlock_bh_state(bh);
739
740 /*
741 * If we are about to journal a buffer, then any revoke pending on it is
742 * no longer valid
743 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700744 jbd2_journal_cancel_revoke(handle, jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700745
746out:
747 if (unlikely(frozen_buffer)) /* It's usually NULL */
Mingming Caoaf1e76d2007-10-16 18:38:25 -0400748 jbd2_free(frozen_buffer, bh->b_size);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700749
750 JBUFFER_TRACE(jh, "exit");
751 return error;
752}
753
754/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700755 * int jbd2_journal_get_write_access() - notify intent to modify a buffer for metadata (not data) update.
Dave Kleikamp470decc2006-10-11 01:20:57 -0700756 * @handle: transaction to add buffer modifications to
757 * @bh: bh to be used for metadata writes
758 * @credits: variable that will receive credits for the buffer
759 *
760 * Returns an error code or 0 on success.
761 *
762 * In full data journalling mode the buffer may be of type BJ_AsyncData,
763 * because we're write()ing a buffer which is also part of a shared mapping.
764 */
765
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700766int jbd2_journal_get_write_access(handle_t *handle, struct buffer_head *bh)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700767{
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700768 struct journal_head *jh = jbd2_journal_add_journal_head(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700769 int rc;
770
771 /* We do not want to get caught playing with fields which the
772 * log thread also manipulates. Make sure that the buffer
773 * completes any outstanding IO before proceeding. */
774 rc = do_get_write_access(handle, jh, 0);
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700775 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700776 return rc;
777}
778
779
780/*
781 * When the user wants to journal a newly created buffer_head
782 * (ie. getblk() returned a new buffer and we are going to populate it
783 * manually rather than reading off disk), then we need to keep the
784 * buffer_head locked until it has been completely filled with new
785 * data. In this case, we should be able to make the assertion that
786 * the bh is not already part of an existing transaction.
787 *
788 * The buffer should already be locked by the caller by this point.
789 * There is no lock ranking violation: it was a newly created,
790 * unlocked buffer beforehand. */
791
792/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700793 * int jbd2_journal_get_create_access () - notify intent to use newly created bh
Dave Kleikamp470decc2006-10-11 01:20:57 -0700794 * @handle: transaction to new buffer to
795 * @bh: new buffer.
796 *
797 * Call this if you create a new bh.
798 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700799int jbd2_journal_get_create_access(handle_t *handle, struct buffer_head *bh)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700800{
801 transaction_t *transaction = handle->h_transaction;
802 journal_t *journal = transaction->t_journal;
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700803 struct journal_head *jh = jbd2_journal_add_journal_head(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700804 int err;
805
806 jbd_debug(5, "journal_head %p\n", jh);
807 err = -EROFS;
808 if (is_handle_aborted(handle))
809 goto out;
810 err = 0;
811
812 JBUFFER_TRACE(jh, "entry");
813 /*
814 * The buffer may already belong to this transaction due to pre-zeroing
815 * in the filesystem's new_block code. It may also be on the previous,
816 * committing transaction's lists, but it HAS to be in Forget state in
817 * that case: the transaction must have deleted the buffer for it to be
818 * reused here.
819 */
820 jbd_lock_bh_state(bh);
821 spin_lock(&journal->j_list_lock);
822 J_ASSERT_JH(jh, (jh->b_transaction == transaction ||
823 jh->b_transaction == NULL ||
824 (jh->b_transaction == journal->j_committing_transaction &&
825 jh->b_jlist == BJ_Forget)));
826
827 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
828 J_ASSERT_JH(jh, buffer_locked(jh2bh(jh)));
829
830 if (jh->b_transaction == NULL) {
831 jh->b_transaction = transaction;
832 JBUFFER_TRACE(jh, "file as BJ_Reserved");
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700833 __jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700834 } else if (jh->b_transaction == journal->j_committing_transaction) {
835 JBUFFER_TRACE(jh, "set next transaction");
836 jh->b_next_transaction = transaction;
837 }
838 spin_unlock(&journal->j_list_lock);
839 jbd_unlock_bh_state(bh);
840
841 /*
842 * akpm: I added this. ext3_alloc_branch can pick up new indirect
843 * blocks which contain freed but then revoked metadata. We need
844 * to cancel the revoke in case we end up freeing it yet again
845 * and the reallocating as data - this would cause a second revoke,
846 * which hits an assertion error.
847 */
848 JBUFFER_TRACE(jh, "cancelling revoke");
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700849 jbd2_journal_cancel_revoke(handle, jh);
850 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700851out:
852 return err;
853}
854
855/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700856 * int jbd2_journal_get_undo_access() - Notify intent to modify metadata with
Dave Kleikamp470decc2006-10-11 01:20:57 -0700857 * non-rewindable consequences
858 * @handle: transaction
859 * @bh: buffer to undo
860 * @credits: store the number of taken credits here (if not NULL)
861 *
862 * Sometimes there is a need to distinguish between metadata which has
863 * been committed to disk and that which has not. The ext3fs code uses
864 * this for freeing and allocating space, we have to make sure that we
865 * do not reuse freed space until the deallocation has been committed,
866 * since if we overwrote that space we would make the delete
867 * un-rewindable in case of a crash.
868 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700869 * To deal with that, jbd2_journal_get_undo_access requests write access to a
Dave Kleikamp470decc2006-10-11 01:20:57 -0700870 * buffer for parts of non-rewindable operations such as delete
871 * operations on the bitmaps. The journaling code must keep a copy of
872 * the buffer's contents prior to the undo_access call until such time
873 * as we know that the buffer has definitely been committed to disk.
874 *
875 * We never need to know which transaction the committed data is part
876 * of, buffers touched here are guaranteed to be dirtied later and so
877 * will be committed to a new transaction in due course, at which point
878 * we can discard the old committed data pointer.
879 *
880 * Returns error number or 0 on success.
881 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700882int jbd2_journal_get_undo_access(handle_t *handle, struct buffer_head *bh)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700883{
884 int err;
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700885 struct journal_head *jh = jbd2_journal_add_journal_head(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700886 char *committed_data = NULL;
887
888 JBUFFER_TRACE(jh, "entry");
889
890 /*
891 * Do this first --- it can drop the journal lock, so we want to
892 * make sure that obtaining the committed_data is done
893 * atomically wrt. completion of any outstanding commits.
894 */
895 err = do_get_write_access(handle, jh, 1);
896 if (err)
897 goto out;
898
899repeat:
900 if (!jh->b_committed_data) {
Mingming Caoaf1e76d2007-10-16 18:38:25 -0400901 committed_data = jbd2_alloc(jh2bh(jh)->b_size, GFP_NOFS);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700902 if (!committed_data) {
903 printk(KERN_EMERG "%s: No memory for committed data\n",
904 __FUNCTION__);
905 err = -ENOMEM;
906 goto out;
907 }
908 }
909
910 jbd_lock_bh_state(bh);
911 if (!jh->b_committed_data) {
912 /* Copy out the current buffer contents into the
913 * preserved, committed copy. */
914 JBUFFER_TRACE(jh, "generate b_committed data");
915 if (!committed_data) {
916 jbd_unlock_bh_state(bh);
917 goto repeat;
918 }
919
920 jh->b_committed_data = committed_data;
921 committed_data = NULL;
922 memcpy(jh->b_committed_data, bh->b_data, bh->b_size);
923 }
924 jbd_unlock_bh_state(bh);
925out:
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700926 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700927 if (unlikely(committed_data))
Mingming Caoaf1e76d2007-10-16 18:38:25 -0400928 jbd2_free(committed_data, bh->b_size);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700929 return err;
930}
931
932/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700933 * int jbd2_journal_dirty_data() - mark a buffer as containing dirty data which
Dave Kleikamp470decc2006-10-11 01:20:57 -0700934 * needs to be flushed before we can commit the
935 * current transaction.
936 * @handle: transaction
937 * @bh: bufferhead to mark
938 *
939 * The buffer is placed on the transaction's data list and is marked as
940 * belonging to the transaction.
941 *
942 * Returns error number or 0 on success.
943 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700944 * jbd2_journal_dirty_data() can be called via page_launder->ext3_writepage
Dave Kleikamp470decc2006-10-11 01:20:57 -0700945 * by kswapd.
946 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700947int jbd2_journal_dirty_data(handle_t *handle, struct buffer_head *bh)
Dave Kleikamp470decc2006-10-11 01:20:57 -0700948{
949 journal_t *journal = handle->h_transaction->t_journal;
950 int need_brelse = 0;
951 struct journal_head *jh;
952
953 if (is_handle_aborted(handle))
954 return 0;
955
Mingming Caof7f4bcc2006-10-11 01:20:59 -0700956 jh = jbd2_journal_add_journal_head(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -0700957 JBUFFER_TRACE(jh, "entry");
958
959 /*
960 * The buffer could *already* be dirty. Writeout can start
961 * at any time.
962 */
963 jbd_debug(4, "jh: %p, tid:%d\n", jh, handle->h_transaction->t_tid);
964
965 /*
966 * What if the buffer is already part of a running transaction?
967 *
968 * There are two cases:
969 * 1) It is part of the current running transaction. Refile it,
970 * just in case we have allocated it as metadata, deallocated
971 * it, then reallocated it as data.
972 * 2) It is part of the previous, still-committing transaction.
973 * If all we want to do is to guarantee that the buffer will be
974 * written to disk before this new transaction commits, then
975 * being sure that the *previous* transaction has this same
976 * property is sufficient for us! Just leave it on its old
977 * transaction.
978 *
979 * In case (2), the buffer must not already exist as metadata
980 * --- that would violate write ordering (a transaction is free
981 * to write its data at any point, even before the previous
982 * committing transaction has committed). The caller must
983 * never, ever allow this to happen: there's nothing we can do
984 * about it in this layer.
985 */
986 jbd_lock_bh_state(bh);
987 spin_lock(&journal->j_list_lock);
Eric Sandeen9b579882006-10-28 10:38:28 -0700988
989 /* Now that we have bh_state locked, are we really still mapped? */
990 if (!buffer_mapped(bh)) {
991 JBUFFER_TRACE(jh, "unmapped buffer, bailing out");
992 goto no_journal;
993 }
994
Dave Kleikamp470decc2006-10-11 01:20:57 -0700995 if (jh->b_transaction) {
996 JBUFFER_TRACE(jh, "has transaction");
997 if (jh->b_transaction != handle->h_transaction) {
998 JBUFFER_TRACE(jh, "belongs to older transaction");
999 J_ASSERT_JH(jh, jh->b_transaction ==
1000 journal->j_committing_transaction);
1001
1002 /* @@@ IS THIS TRUE ? */
1003 /*
1004 * Not any more. Scenario: someone does a write()
1005 * in data=journal mode. The buffer's transaction has
1006 * moved into commit. Then someone does another
1007 * write() to the file. We do the frozen data copyout
1008 * and set b_next_transaction to point to j_running_t.
1009 * And while we're in that state, someone does a
1010 * writepage() in an attempt to pageout the same area
1011 * of the file via a shared mapping. At present that
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001012 * calls jbd2_journal_dirty_data(), and we get right here.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001013 * It may be too late to journal the data. Simply
1014 * falling through to the next test will suffice: the
1015 * data will be dirty and wil be checkpointed. The
1016 * ordering comments in the next comment block still
1017 * apply.
1018 */
1019 //J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
1020
1021 /*
1022 * If we're journalling data, and this buffer was
1023 * subject to a write(), it could be metadata, forget
1024 * or shadow against the committing transaction. Now,
1025 * someone has dirtied the same darn page via a mapping
1026 * and it is being writepage()'d.
1027 * We *could* just steal the page from commit, with some
1028 * fancy locking there. Instead, we just skip it -
1029 * don't tie the page's buffers to the new transaction
1030 * at all.
1031 * Implication: if we crash before the writepage() data
1032 * is written into the filesystem, recovery will replay
1033 * the write() data.
1034 */
1035 if (jh->b_jlist != BJ_None &&
1036 jh->b_jlist != BJ_SyncData &&
1037 jh->b_jlist != BJ_Locked) {
1038 JBUFFER_TRACE(jh, "Not stealing");
1039 goto no_journal;
1040 }
1041
1042 /*
1043 * This buffer may be undergoing writeout in commit. We
1044 * can't return from here and let the caller dirty it
1045 * again because that can cause the write-out loop in
1046 * commit to never terminate.
1047 */
1048 if (buffer_dirty(bh)) {
1049 get_bh(bh);
1050 spin_unlock(&journal->j_list_lock);
1051 jbd_unlock_bh_state(bh);
1052 need_brelse = 1;
1053 sync_dirty_buffer(bh);
1054 jbd_lock_bh_state(bh);
1055 spin_lock(&journal->j_list_lock);
Eric Sandeen9b579882006-10-28 10:38:28 -07001056 /* Since we dropped the lock... */
1057 if (!buffer_mapped(bh)) {
1058 JBUFFER_TRACE(jh, "buffer got unmapped");
1059 goto no_journal;
1060 }
Dave Kleikamp470decc2006-10-11 01:20:57 -07001061 /* The buffer may become locked again at any
1062 time if it is redirtied */
1063 }
1064
1065 /* journal_clean_data_list() may have got there first */
1066 if (jh->b_transaction != NULL) {
1067 JBUFFER_TRACE(jh, "unfile from commit");
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001068 __jbd2_journal_temp_unlink_buffer(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001069 /* It still points to the committing
1070 * transaction; move it to this one so
1071 * that the refile assert checks are
1072 * happy. */
1073 jh->b_transaction = handle->h_transaction;
1074 }
1075 /* The buffer will be refiled below */
1076
1077 }
1078 /*
1079 * Special case --- the buffer might actually have been
1080 * allocated and then immediately deallocated in the previous,
1081 * committing transaction, so might still be left on that
1082 * transaction's metadata lists.
1083 */
1084 if (jh->b_jlist != BJ_SyncData && jh->b_jlist != BJ_Locked) {
1085 JBUFFER_TRACE(jh, "not on correct data list: unfile");
1086 J_ASSERT_JH(jh, jh->b_jlist != BJ_Shadow);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001087 __jbd2_journal_temp_unlink_buffer(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001088 jh->b_transaction = handle->h_transaction;
1089 JBUFFER_TRACE(jh, "file as data");
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001090 __jbd2_journal_file_buffer(jh, handle->h_transaction,
Dave Kleikamp470decc2006-10-11 01:20:57 -07001091 BJ_SyncData);
1092 }
1093 } else {
1094 JBUFFER_TRACE(jh, "not on a transaction");
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001095 __jbd2_journal_file_buffer(jh, handle->h_transaction, BJ_SyncData);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001096 }
1097no_journal:
1098 spin_unlock(&journal->j_list_lock);
1099 jbd_unlock_bh_state(bh);
1100 if (need_brelse) {
1101 BUFFER_TRACE(bh, "brelse");
1102 __brelse(bh);
1103 }
1104 JBUFFER_TRACE(jh, "exit");
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001105 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001106 return 0;
1107}
1108
1109/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001110 * int jbd2_journal_dirty_metadata() - mark a buffer as containing dirty metadata
Dave Kleikamp470decc2006-10-11 01:20:57 -07001111 * @handle: transaction to add buffer to.
1112 * @bh: buffer to mark
1113 *
1114 * mark dirty metadata which needs to be journaled as part of the current
1115 * transaction.
1116 *
1117 * The buffer is placed on the transaction's metadata list and is marked
1118 * as belonging to the transaction.
1119 *
1120 * Returns error number or 0 on success.
1121 *
1122 * Special care needs to be taken if the buffer already belongs to the
1123 * current committing transaction (in which case we should have frozen
1124 * data present for that commit). In that case, we don't relink the
1125 * buffer: that only gets done when the old transaction finally
1126 * completes its commit.
1127 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001128int jbd2_journal_dirty_metadata(handle_t *handle, struct buffer_head *bh)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001129{
1130 transaction_t *transaction = handle->h_transaction;
1131 journal_t *journal = transaction->t_journal;
1132 struct journal_head *jh = bh2jh(bh);
1133
1134 jbd_debug(5, "journal_head %p\n", jh);
1135 JBUFFER_TRACE(jh, "entry");
1136 if (is_handle_aborted(handle))
1137 goto out;
1138
1139 jbd_lock_bh_state(bh);
1140
1141 if (jh->b_modified == 0) {
1142 /*
1143 * This buffer's got modified and becoming part
1144 * of the transaction. This needs to be done
1145 * once a transaction -bzzz
1146 */
1147 jh->b_modified = 1;
1148 J_ASSERT_JH(jh, handle->h_buffer_credits > 0);
1149 handle->h_buffer_credits--;
1150 }
1151
1152 /*
1153 * fastpath, to avoid expensive locking. If this buffer is already
1154 * on the running transaction's metadata list there is nothing to do.
1155 * Nobody can take it off again because there is a handle open.
1156 * I _think_ we're OK here with SMP barriers - a mistaken decision will
1157 * result in this test being false, so we go in and take the locks.
1158 */
1159 if (jh->b_transaction == transaction && jh->b_jlist == BJ_Metadata) {
1160 JBUFFER_TRACE(jh, "fastpath");
1161 J_ASSERT_JH(jh, jh->b_transaction ==
1162 journal->j_running_transaction);
1163 goto out_unlock_bh;
1164 }
1165
1166 set_buffer_jbddirty(bh);
1167
1168 /*
1169 * Metadata already on the current transaction list doesn't
1170 * need to be filed. Metadata on another transaction's list must
1171 * be committing, and will be refiled once the commit completes:
1172 * leave it alone for now.
1173 */
1174 if (jh->b_transaction != transaction) {
1175 JBUFFER_TRACE(jh, "already on other transaction");
1176 J_ASSERT_JH(jh, jh->b_transaction ==
1177 journal->j_committing_transaction);
1178 J_ASSERT_JH(jh, jh->b_next_transaction == transaction);
1179 /* And this case is illegal: we can't reuse another
1180 * transaction's data buffer, ever. */
1181 goto out_unlock_bh;
1182 }
1183
1184 /* That test should have eliminated the following case: */
Mingming Cao40191912008-01-28 23:58:27 -05001185 J_ASSERT_JH(jh, jh->b_frozen_data == NULL);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001186
1187 JBUFFER_TRACE(jh, "file as BJ_Metadata");
1188 spin_lock(&journal->j_list_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001189 __jbd2_journal_file_buffer(jh, handle->h_transaction, BJ_Metadata);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001190 spin_unlock(&journal->j_list_lock);
1191out_unlock_bh:
1192 jbd_unlock_bh_state(bh);
1193out:
1194 JBUFFER_TRACE(jh, "exit");
1195 return 0;
1196}
1197
1198/*
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001199 * jbd2_journal_release_buffer: undo a get_write_access without any buffer
Dave Kleikamp470decc2006-10-11 01:20:57 -07001200 * updates, if the update decided in the end that it didn't need access.
1201 *
1202 */
1203void
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001204jbd2_journal_release_buffer(handle_t *handle, struct buffer_head *bh)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001205{
1206 BUFFER_TRACE(bh, "entry");
1207}
1208
1209/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001210 * void jbd2_journal_forget() - bforget() for potentially-journaled buffers.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001211 * @handle: transaction handle
1212 * @bh: bh to 'forget'
1213 *
1214 * We can only do the bforget if there are no commits pending against the
1215 * buffer. If the buffer is dirty in the current running transaction we
1216 * can safely unlink it.
1217 *
1218 * bh may not be a journalled buffer at all - it may be a non-JBD
1219 * buffer which came off the hashtable. Check for this.
1220 *
1221 * Decrements bh->b_count by one.
1222 *
1223 * Allow this call even if the handle has aborted --- it may be part of
1224 * the caller's cleanup after an abort.
1225 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001226int jbd2_journal_forget (handle_t *handle, struct buffer_head *bh)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001227{
1228 transaction_t *transaction = handle->h_transaction;
1229 journal_t *journal = transaction->t_journal;
1230 struct journal_head *jh;
1231 int drop_reserve = 0;
1232 int err = 0;
1233
1234 BUFFER_TRACE(bh, "entry");
1235
1236 jbd_lock_bh_state(bh);
1237 spin_lock(&journal->j_list_lock);
1238
1239 if (!buffer_jbd(bh))
1240 goto not_jbd;
1241 jh = bh2jh(bh);
1242
1243 /* Critical error: attempting to delete a bitmap buffer, maybe?
1244 * Don't do any jbd operations, and return an error. */
1245 if (!J_EXPECT_JH(jh, !jh->b_committed_data,
1246 "inconsistent data on disk")) {
1247 err = -EIO;
1248 goto not_jbd;
1249 }
1250
1251 /*
1252 * The buffer's going from the transaction, we must drop
1253 * all references -bzzz
1254 */
1255 jh->b_modified = 0;
1256
1257 if (jh->b_transaction == handle->h_transaction) {
1258 J_ASSERT_JH(jh, !jh->b_frozen_data);
1259
1260 /* If we are forgetting a buffer which is already part
1261 * of this transaction, then we can just drop it from
1262 * the transaction immediately. */
1263 clear_buffer_dirty(bh);
1264 clear_buffer_jbddirty(bh);
1265
1266 JBUFFER_TRACE(jh, "belongs to current transaction: unfile");
1267
1268 drop_reserve = 1;
1269
1270 /*
1271 * We are no longer going to journal this buffer.
1272 * However, the commit of this transaction is still
1273 * important to the buffer: the delete that we are now
1274 * processing might obsolete an old log entry, so by
1275 * committing, we can satisfy the buffer's checkpoint.
1276 *
1277 * So, if we have a checkpoint on the buffer, we should
1278 * now refile the buffer on our BJ_Forget list so that
1279 * we know to remove the checkpoint after we commit.
1280 */
1281
1282 if (jh->b_cp_transaction) {
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001283 __jbd2_journal_temp_unlink_buffer(jh);
1284 __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001285 } else {
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001286 __jbd2_journal_unfile_buffer(jh);
1287 jbd2_journal_remove_journal_head(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001288 __brelse(bh);
1289 if (!buffer_jbd(bh)) {
1290 spin_unlock(&journal->j_list_lock);
1291 jbd_unlock_bh_state(bh);
1292 __bforget(bh);
1293 goto drop;
1294 }
1295 }
1296 } else if (jh->b_transaction) {
1297 J_ASSERT_JH(jh, (jh->b_transaction ==
1298 journal->j_committing_transaction));
1299 /* However, if the buffer is still owned by a prior
1300 * (committing) transaction, we can't drop it yet... */
1301 JBUFFER_TRACE(jh, "belongs to older transaction");
1302 /* ... but we CAN drop it from the new transaction if we
1303 * have also modified it since the original commit. */
1304
1305 if (jh->b_next_transaction) {
1306 J_ASSERT(jh->b_next_transaction == transaction);
1307 jh->b_next_transaction = NULL;
1308 drop_reserve = 1;
1309 }
1310 }
1311
1312not_jbd:
1313 spin_unlock(&journal->j_list_lock);
1314 jbd_unlock_bh_state(bh);
1315 __brelse(bh);
1316drop:
1317 if (drop_reserve) {
1318 /* no need to reserve log space for this block -bzzz */
1319 handle->h_buffer_credits++;
1320 }
1321 return err;
1322}
1323
1324/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001325 * int jbd2_journal_stop() - complete a transaction
Dave Kleikamp470decc2006-10-11 01:20:57 -07001326 * @handle: tranaction to complete.
1327 *
1328 * All done for a particular handle.
1329 *
1330 * There is not much action needed here. We just return any remaining
1331 * buffer credits to the transaction and remove the handle. The only
1332 * complication is that we need to start a commit operation if the
1333 * filesystem is marked for synchronous update.
1334 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001335 * jbd2_journal_stop itself will not usually return an error, but it may
Dave Kleikamp470decc2006-10-11 01:20:57 -07001336 * do so in unusual circumstances. In particular, expect it to
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001337 * return -EIO if a jbd2_journal_abort has been executed since the
Dave Kleikamp470decc2006-10-11 01:20:57 -07001338 * transaction began.
1339 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001340int jbd2_journal_stop(handle_t *handle)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001341{
1342 transaction_t *transaction = handle->h_transaction;
1343 journal_t *journal = transaction->t_journal;
1344 int old_handle_count, err;
1345 pid_t pid;
1346
Dave Kleikamp470decc2006-10-11 01:20:57 -07001347 J_ASSERT(journal_current_handle() == handle);
1348
1349 if (is_handle_aborted(handle))
1350 err = -EIO;
OGAWA Hirofumi3e2a5322006-10-19 23:29:11 -07001351 else {
1352 J_ASSERT(transaction->t_updates > 0);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001353 err = 0;
OGAWA Hirofumi3e2a5322006-10-19 23:29:11 -07001354 }
Dave Kleikamp470decc2006-10-11 01:20:57 -07001355
1356 if (--handle->h_ref > 0) {
1357 jbd_debug(4, "h_ref %d -> %d\n", handle->h_ref + 1,
1358 handle->h_ref);
1359 return err;
1360 }
1361
1362 jbd_debug(4, "Handle %p going down\n", handle);
1363
1364 /*
1365 * Implement synchronous transaction batching. If the handle
1366 * was synchronous, don't force a commit immediately. Let's
1367 * yield and let another thread piggyback onto this transaction.
1368 * Keep doing that while new threads continue to arrive.
1369 * It doesn't cost much - we're about to run a commit and sleep
1370 * on IO anyway. Speeds up many-threaded, many-dir operations
1371 * by 30x or more...
1372 *
1373 * But don't do this if this process was the most recent one to
1374 * perform a synchronous write. We do this to detect the case where a
1375 * single process is doing a stream of sync writes. No point in waiting
1376 * for joiners in that case.
1377 */
1378 pid = current->pid;
1379 if (handle->h_sync && journal->j_last_sync_writer != pid) {
1380 journal->j_last_sync_writer = pid;
1381 do {
1382 old_handle_count = transaction->t_handle_count;
1383 schedule_timeout_uninterruptible(1);
1384 } while (old_handle_count != transaction->t_handle_count);
1385 }
1386
1387 current->journal_info = NULL;
1388 spin_lock(&journal->j_state_lock);
1389 spin_lock(&transaction->t_handle_lock);
1390 transaction->t_outstanding_credits -= handle->h_buffer_credits;
1391 transaction->t_updates--;
1392 if (!transaction->t_updates) {
1393 wake_up(&journal->j_wait_updates);
1394 if (journal->j_barrier_count)
1395 wake_up(&journal->j_wait_transaction_locked);
1396 }
1397
1398 /*
1399 * If the handle is marked SYNC, we need to set another commit
1400 * going! We also want to force a commit if the current
1401 * transaction is occupying too much of the log, or if the
1402 * transaction is too old now.
1403 */
1404 if (handle->h_sync ||
1405 transaction->t_outstanding_credits >
1406 journal->j_max_transaction_buffers ||
1407 time_after_eq(jiffies, transaction->t_expires)) {
1408 /* Do this even for aborted journals: an abort still
1409 * completes the commit thread, it just doesn't write
1410 * anything to disk. */
1411 tid_t tid = transaction->t_tid;
1412
1413 spin_unlock(&transaction->t_handle_lock);
1414 jbd_debug(2, "transaction too old, requesting commit for "
1415 "handle %p\n", handle);
1416 /* This is non-blocking */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001417 __jbd2_log_start_commit(journal, transaction->t_tid);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001418 spin_unlock(&journal->j_state_lock);
1419
1420 /*
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001421 * Special case: JBD2_SYNC synchronous updates require us
Dave Kleikamp470decc2006-10-11 01:20:57 -07001422 * to wait for the commit to complete.
1423 */
1424 if (handle->h_sync && !(current->flags & PF_MEMALLOC))
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001425 err = jbd2_log_wait_commit(journal, tid);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001426 } else {
1427 spin_unlock(&transaction->t_handle_lock);
1428 spin_unlock(&journal->j_state_lock);
1429 }
1430
Mingming Cao7b751062008-01-28 23:58:27 -05001431 lock_release(&handle->h_lockdep_map, 1, _THIS_IP_);
1432
Mingming Caoaf1e76d2007-10-16 18:38:25 -04001433 jbd2_free_handle(handle);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001434 return err;
1435}
1436
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001437/**int jbd2_journal_force_commit() - force any uncommitted transactions
Dave Kleikamp470decc2006-10-11 01:20:57 -07001438 * @journal: journal to force
1439 *
1440 * For synchronous operations: force any uncommitted transactions
1441 * to disk. May seem kludgy, but it reuses all the handle batching
1442 * code in a very simple manner.
1443 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001444int jbd2_journal_force_commit(journal_t *journal)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001445{
1446 handle_t *handle;
1447 int ret;
1448
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001449 handle = jbd2_journal_start(journal, 1);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001450 if (IS_ERR(handle)) {
1451 ret = PTR_ERR(handle);
1452 } else {
1453 handle->h_sync = 1;
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001454 ret = jbd2_journal_stop(handle);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001455 }
1456 return ret;
1457}
1458
1459/*
1460 *
1461 * List management code snippets: various functions for manipulating the
1462 * transaction buffer lists.
1463 *
1464 */
1465
1466/*
1467 * Append a buffer to a transaction list, given the transaction's list head
1468 * pointer.
1469 *
1470 * j_list_lock is held.
1471 *
1472 * jbd_lock_bh_state(jh2bh(jh)) is held.
1473 */
1474
1475static inline void
1476__blist_add_buffer(struct journal_head **list, struct journal_head *jh)
1477{
1478 if (!*list) {
1479 jh->b_tnext = jh->b_tprev = jh;
1480 *list = jh;
1481 } else {
1482 /* Insert at the tail of the list to preserve order */
1483 struct journal_head *first = *list, *last = first->b_tprev;
1484 jh->b_tprev = last;
1485 jh->b_tnext = first;
1486 last->b_tnext = first->b_tprev = jh;
1487 }
1488}
1489
1490/*
1491 * Remove a buffer from a transaction list, given the transaction's list
1492 * head pointer.
1493 *
1494 * Called with j_list_lock held, and the journal may not be locked.
1495 *
1496 * jbd_lock_bh_state(jh2bh(jh)) is held.
1497 */
1498
1499static inline void
1500__blist_del_buffer(struct journal_head **list, struct journal_head *jh)
1501{
1502 if (*list == jh) {
1503 *list = jh->b_tnext;
1504 if (*list == jh)
1505 *list = NULL;
1506 }
1507 jh->b_tprev->b_tnext = jh->b_tnext;
1508 jh->b_tnext->b_tprev = jh->b_tprev;
1509}
1510
1511/*
1512 * Remove a buffer from the appropriate transaction list.
1513 *
1514 * Note that this function can *change* the value of
1515 * bh->b_transaction->t_sync_datalist, t_buffers, t_forget,
1516 * t_iobuf_list, t_shadow_list, t_log_list or t_reserved_list. If the caller
1517 * is holding onto a copy of one of thee pointers, it could go bad.
1518 * Generally the caller needs to re-read the pointer from the transaction_t.
1519 *
1520 * Called under j_list_lock. The journal may not be locked.
1521 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001522void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001523{
1524 struct journal_head **list = NULL;
1525 transaction_t *transaction;
1526 struct buffer_head *bh = jh2bh(jh);
1527
1528 J_ASSERT_JH(jh, jbd_is_locked_bh_state(bh));
1529 transaction = jh->b_transaction;
1530 if (transaction)
1531 assert_spin_locked(&transaction->t_journal->j_list_lock);
1532
1533 J_ASSERT_JH(jh, jh->b_jlist < BJ_Types);
1534 if (jh->b_jlist != BJ_None)
Mingming Cao40191912008-01-28 23:58:27 -05001535 J_ASSERT_JH(jh, transaction != NULL);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001536
1537 switch (jh->b_jlist) {
1538 case BJ_None:
1539 return;
1540 case BJ_SyncData:
1541 list = &transaction->t_sync_datalist;
1542 break;
1543 case BJ_Metadata:
1544 transaction->t_nr_buffers--;
1545 J_ASSERT_JH(jh, transaction->t_nr_buffers >= 0);
1546 list = &transaction->t_buffers;
1547 break;
1548 case BJ_Forget:
1549 list = &transaction->t_forget;
1550 break;
1551 case BJ_IO:
1552 list = &transaction->t_iobuf_list;
1553 break;
1554 case BJ_Shadow:
1555 list = &transaction->t_shadow_list;
1556 break;
1557 case BJ_LogCtl:
1558 list = &transaction->t_log_list;
1559 break;
1560 case BJ_Reserved:
1561 list = &transaction->t_reserved_list;
1562 break;
1563 case BJ_Locked:
1564 list = &transaction->t_locked_list;
1565 break;
1566 }
1567
1568 __blist_del_buffer(list, jh);
1569 jh->b_jlist = BJ_None;
1570 if (test_clear_buffer_jbddirty(bh))
1571 mark_buffer_dirty(bh); /* Expose it to the VM */
1572}
1573
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001574void __jbd2_journal_unfile_buffer(struct journal_head *jh)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001575{
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001576 __jbd2_journal_temp_unlink_buffer(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001577 jh->b_transaction = NULL;
1578}
1579
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001580void jbd2_journal_unfile_buffer(journal_t *journal, struct journal_head *jh)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001581{
1582 jbd_lock_bh_state(jh2bh(jh));
1583 spin_lock(&journal->j_list_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001584 __jbd2_journal_unfile_buffer(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001585 spin_unlock(&journal->j_list_lock);
1586 jbd_unlock_bh_state(jh2bh(jh));
1587}
1588
1589/*
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001590 * Called from jbd2_journal_try_to_free_buffers().
Dave Kleikamp470decc2006-10-11 01:20:57 -07001591 *
1592 * Called under jbd_lock_bh_state(bh)
1593 */
1594static void
1595__journal_try_to_free_buffer(journal_t *journal, struct buffer_head *bh)
1596{
1597 struct journal_head *jh;
1598
1599 jh = bh2jh(bh);
1600
1601 if (buffer_locked(bh) || buffer_dirty(bh))
1602 goto out;
1603
Mingming Cao40191912008-01-28 23:58:27 -05001604 if (jh->b_next_transaction != NULL)
Dave Kleikamp470decc2006-10-11 01:20:57 -07001605 goto out;
1606
1607 spin_lock(&journal->j_list_lock);
Mingming Cao40191912008-01-28 23:58:27 -05001608 if (jh->b_transaction != NULL && jh->b_cp_transaction == NULL) {
Dave Kleikamp470decc2006-10-11 01:20:57 -07001609 if (jh->b_jlist == BJ_SyncData || jh->b_jlist == BJ_Locked) {
1610 /* A written-back ordered data buffer */
1611 JBUFFER_TRACE(jh, "release data");
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001612 __jbd2_journal_unfile_buffer(jh);
1613 jbd2_journal_remove_journal_head(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001614 __brelse(bh);
1615 }
Mingming Cao40191912008-01-28 23:58:27 -05001616 } else if (jh->b_cp_transaction != NULL && jh->b_transaction == NULL) {
Dave Kleikamp470decc2006-10-11 01:20:57 -07001617 /* written-back checkpointed metadata buffer */
1618 if (jh->b_jlist == BJ_None) {
1619 JBUFFER_TRACE(jh, "remove from checkpoint list");
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001620 __jbd2_journal_remove_checkpoint(jh);
1621 jbd2_journal_remove_journal_head(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001622 __brelse(bh);
1623 }
1624 }
1625 spin_unlock(&journal->j_list_lock);
1626out:
1627 return;
1628}
1629
1630
1631/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001632 * int jbd2_journal_try_to_free_buffers() - try to free page buffers.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001633 * @journal: journal for operation
1634 * @page: to try and free
1635 * @unused_gfp_mask: unused
1636 *
1637 *
1638 * For all the buffers on this page,
1639 * if they are fully written out ordered data, move them onto BUF_CLEAN
1640 * so try_to_free_buffers() can reap them.
1641 *
1642 * This function returns non-zero if we wish try_to_free_buffers()
1643 * to be called. We do this if the page is releasable by try_to_free_buffers().
1644 * We also do it if the page has locked or dirty buffers and the caller wants
1645 * us to perform sync or async writeout.
1646 *
1647 * This complicates JBD locking somewhat. We aren't protected by the
1648 * BKL here. We wish to remove the buffer from its committing or
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001649 * running transaction's ->t_datalist via __jbd2_journal_unfile_buffer.
Dave Kleikamp470decc2006-10-11 01:20:57 -07001650 *
1651 * This may *change* the value of transaction_t->t_datalist, so anyone
1652 * who looks at t_datalist needs to lock against this function.
1653 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001654 * Even worse, someone may be doing a jbd2_journal_dirty_data on this
1655 * buffer. So we need to lock against that. jbd2_journal_dirty_data()
Dave Kleikamp470decc2006-10-11 01:20:57 -07001656 * will come out of the lock with the buffer dirty, which makes it
1657 * ineligible for release here.
1658 *
1659 * Who else is affected by this? hmm... Really the only contender
1660 * is do_get_write_access() - it could be looking at the buffer while
1661 * journal_try_to_free_buffer() is changing its state. But that
1662 * cannot happen because we never reallocate freed data as metadata
1663 * while the data is part of a transaction. Yes?
1664 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001665int jbd2_journal_try_to_free_buffers(journal_t *journal,
Dave Kleikamp470decc2006-10-11 01:20:57 -07001666 struct page *page, gfp_t unused_gfp_mask)
1667{
1668 struct buffer_head *head;
1669 struct buffer_head *bh;
1670 int ret = 0;
1671
1672 J_ASSERT(PageLocked(page));
1673
1674 head = page_buffers(page);
1675 bh = head;
1676 do {
1677 struct journal_head *jh;
1678
1679 /*
1680 * We take our own ref against the journal_head here to avoid
1681 * having to add tons of locking around each instance of
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001682 * jbd2_journal_remove_journal_head() and jbd2_journal_put_journal_head().
Dave Kleikamp470decc2006-10-11 01:20:57 -07001683 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001684 jh = jbd2_journal_grab_journal_head(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001685 if (!jh)
1686 continue;
1687
1688 jbd_lock_bh_state(bh);
1689 __journal_try_to_free_buffer(journal, bh);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001690 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001691 jbd_unlock_bh_state(bh);
1692 if (buffer_jbd(bh))
1693 goto busy;
1694 } while ((bh = bh->b_this_page) != head);
1695 ret = try_to_free_buffers(page);
1696busy:
1697 return ret;
1698}
1699
1700/*
1701 * This buffer is no longer needed. If it is on an older transaction's
1702 * checkpoint list we need to record it on this transaction's forget list
1703 * to pin this buffer (and hence its checkpointing transaction) down until
1704 * this transaction commits. If the buffer isn't on a checkpoint list, we
1705 * release it.
1706 * Returns non-zero if JBD no longer has an interest in the buffer.
1707 *
1708 * Called under j_list_lock.
1709 *
1710 * Called under jbd_lock_bh_state(bh).
1711 */
1712static int __dispose_buffer(struct journal_head *jh, transaction_t *transaction)
1713{
1714 int may_free = 1;
1715 struct buffer_head *bh = jh2bh(jh);
1716
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001717 __jbd2_journal_unfile_buffer(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001718
1719 if (jh->b_cp_transaction) {
1720 JBUFFER_TRACE(jh, "on running+cp transaction");
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001721 __jbd2_journal_file_buffer(jh, transaction, BJ_Forget);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001722 clear_buffer_jbddirty(bh);
1723 may_free = 0;
1724 } else {
1725 JBUFFER_TRACE(jh, "on running transaction");
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001726 jbd2_journal_remove_journal_head(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001727 __brelse(bh);
1728 }
1729 return may_free;
1730}
1731
1732/*
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001733 * jbd2_journal_invalidatepage
Dave Kleikamp470decc2006-10-11 01:20:57 -07001734 *
1735 * This code is tricky. It has a number of cases to deal with.
1736 *
1737 * There are two invariants which this code relies on:
1738 *
1739 * i_size must be updated on disk before we start calling invalidatepage on the
1740 * data.
1741 *
1742 * This is done in ext3 by defining an ext3_setattr method which
1743 * updates i_size before truncate gets going. By maintaining this
1744 * invariant, we can be sure that it is safe to throw away any buffers
1745 * attached to the current transaction: once the transaction commits,
1746 * we know that the data will not be needed.
1747 *
1748 * Note however that we can *not* throw away data belonging to the
1749 * previous, committing transaction!
1750 *
1751 * Any disk blocks which *are* part of the previous, committing
1752 * transaction (and which therefore cannot be discarded immediately) are
1753 * not going to be reused in the new running transaction
1754 *
1755 * The bitmap committed_data images guarantee this: any block which is
1756 * allocated in one transaction and removed in the next will be marked
1757 * as in-use in the committed_data bitmap, so cannot be reused until
1758 * the next transaction to delete the block commits. This means that
1759 * leaving committing buffers dirty is quite safe: the disk blocks
1760 * cannot be reallocated to a different file and so buffer aliasing is
1761 * not possible.
1762 *
1763 *
1764 * The above applies mainly to ordered data mode. In writeback mode we
1765 * don't make guarantees about the order in which data hits disk --- in
1766 * particular we don't guarantee that new dirty data is flushed before
1767 * transaction commit --- so it is always safe just to discard data
1768 * immediately in that mode. --sct
1769 */
1770
1771/*
1772 * The journal_unmap_buffer helper function returns zero if the buffer
1773 * concerned remains pinned as an anonymous buffer belonging to an older
1774 * transaction.
1775 *
1776 * We're outside-transaction here. Either or both of j_running_transaction
1777 * and j_committing_transaction may be NULL.
1778 */
1779static int journal_unmap_buffer(journal_t *journal, struct buffer_head *bh)
1780{
1781 transaction_t *transaction;
1782 struct journal_head *jh;
1783 int may_free = 1;
1784 int ret;
1785
1786 BUFFER_TRACE(bh, "entry");
1787
1788 /*
1789 * It is safe to proceed here without the j_list_lock because the
1790 * buffers cannot be stolen by try_to_free_buffers as long as we are
1791 * holding the page lock. --sct
1792 */
1793
1794 if (!buffer_jbd(bh))
1795 goto zap_buffer_unlocked;
1796
1797 spin_lock(&journal->j_state_lock);
1798 jbd_lock_bh_state(bh);
1799 spin_lock(&journal->j_list_lock);
1800
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001801 jh = jbd2_journal_grab_journal_head(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001802 if (!jh)
1803 goto zap_buffer_no_jh;
1804
1805 transaction = jh->b_transaction;
1806 if (transaction == NULL) {
1807 /* First case: not on any transaction. If it
1808 * has no checkpoint link, then we can zap it:
1809 * it's a writeback-mode buffer so we don't care
1810 * if it hits disk safely. */
1811 if (!jh->b_cp_transaction) {
1812 JBUFFER_TRACE(jh, "not on any transaction: zap");
1813 goto zap_buffer;
1814 }
1815
1816 if (!buffer_dirty(bh)) {
1817 /* bdflush has written it. We can drop it now */
1818 goto zap_buffer;
1819 }
1820
1821 /* OK, it must be in the journal but still not
1822 * written fully to disk: it's metadata or
1823 * journaled data... */
1824
1825 if (journal->j_running_transaction) {
1826 /* ... and once the current transaction has
1827 * committed, the buffer won't be needed any
1828 * longer. */
1829 JBUFFER_TRACE(jh, "checkpointed: add to BJ_Forget");
1830 ret = __dispose_buffer(jh,
1831 journal->j_running_transaction);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001832 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001833 spin_unlock(&journal->j_list_lock);
1834 jbd_unlock_bh_state(bh);
1835 spin_unlock(&journal->j_state_lock);
1836 return ret;
1837 } else {
1838 /* There is no currently-running transaction. So the
1839 * orphan record which we wrote for this file must have
1840 * passed into commit. We must attach this buffer to
1841 * the committing transaction, if it exists. */
1842 if (journal->j_committing_transaction) {
1843 JBUFFER_TRACE(jh, "give to committing trans");
1844 ret = __dispose_buffer(jh,
1845 journal->j_committing_transaction);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001846 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001847 spin_unlock(&journal->j_list_lock);
1848 jbd_unlock_bh_state(bh);
1849 spin_unlock(&journal->j_state_lock);
1850 return ret;
1851 } else {
1852 /* The orphan record's transaction has
1853 * committed. We can cleanse this buffer */
1854 clear_buffer_jbddirty(bh);
1855 goto zap_buffer;
1856 }
1857 }
1858 } else if (transaction == journal->j_committing_transaction) {
Eric Sandeen9b579882006-10-28 10:38:28 -07001859 JBUFFER_TRACE(jh, "on committing transaction");
Dave Kleikamp470decc2006-10-11 01:20:57 -07001860 if (jh->b_jlist == BJ_Locked) {
1861 /*
1862 * The buffer is on the committing transaction's locked
1863 * list. We have the buffer locked, so I/O has
1864 * completed. So we can nail the buffer now.
1865 */
1866 may_free = __dispose_buffer(jh, transaction);
1867 goto zap_buffer;
1868 }
1869 /*
1870 * If it is committing, we simply cannot touch it. We
1871 * can remove it's next_transaction pointer from the
1872 * running transaction if that is set, but nothing
1873 * else. */
Dave Kleikamp470decc2006-10-11 01:20:57 -07001874 set_buffer_freed(bh);
1875 if (jh->b_next_transaction) {
1876 J_ASSERT(jh->b_next_transaction ==
1877 journal->j_running_transaction);
1878 jh->b_next_transaction = NULL;
1879 }
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001880 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001881 spin_unlock(&journal->j_list_lock);
1882 jbd_unlock_bh_state(bh);
1883 spin_unlock(&journal->j_state_lock);
1884 return 0;
1885 } else {
1886 /* Good, the buffer belongs to the running transaction.
1887 * We are writing our own transaction's data, not any
1888 * previous one's, so it is safe to throw it away
1889 * (remember that we expect the filesystem to have set
1890 * i_size already for this truncate so recovery will not
1891 * expose the disk blocks we are discarding here.) */
1892 J_ASSERT_JH(jh, transaction == journal->j_running_transaction);
Eric Sandeen9b579882006-10-28 10:38:28 -07001893 JBUFFER_TRACE(jh, "on running transaction");
Dave Kleikamp470decc2006-10-11 01:20:57 -07001894 may_free = __dispose_buffer(jh, transaction);
1895 }
1896
1897zap_buffer:
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001898 jbd2_journal_put_journal_head(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001899zap_buffer_no_jh:
1900 spin_unlock(&journal->j_list_lock);
1901 jbd_unlock_bh_state(bh);
1902 spin_unlock(&journal->j_state_lock);
1903zap_buffer_unlocked:
1904 clear_buffer_dirty(bh);
1905 J_ASSERT_BH(bh, !buffer_jbddirty(bh));
1906 clear_buffer_mapped(bh);
1907 clear_buffer_req(bh);
1908 clear_buffer_new(bh);
1909 bh->b_bdev = NULL;
1910 return may_free;
1911}
1912
1913/**
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001914 * void jbd2_journal_invalidatepage()
Dave Kleikamp470decc2006-10-11 01:20:57 -07001915 * @journal: journal to use for flush...
1916 * @page: page to flush
1917 * @offset: length of page to invalidate.
1918 *
1919 * Reap page buffers containing data after offset in page.
1920 *
1921 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001922void jbd2_journal_invalidatepage(journal_t *journal,
Dave Kleikamp470decc2006-10-11 01:20:57 -07001923 struct page *page,
1924 unsigned long offset)
1925{
1926 struct buffer_head *head, *bh, *next;
1927 unsigned int curr_off = 0;
1928 int may_free = 1;
1929
1930 if (!PageLocked(page))
1931 BUG();
1932 if (!page_has_buffers(page))
1933 return;
1934
1935 /* We will potentially be playing with lists other than just the
1936 * data lists (especially for journaled data mode), so be
1937 * cautious in our locking. */
1938
1939 head = bh = page_buffers(page);
1940 do {
1941 unsigned int next_off = curr_off + bh->b_size;
1942 next = bh->b_this_page;
1943
1944 if (offset <= curr_off) {
1945 /* This block is wholly outside the truncation point */
1946 lock_buffer(bh);
1947 may_free &= journal_unmap_buffer(journal, bh);
1948 unlock_buffer(bh);
1949 }
1950 curr_off = next_off;
1951 bh = next;
1952
1953 } while (bh != head);
1954
1955 if (!offset) {
1956 if (may_free && try_to_free_buffers(page))
1957 J_ASSERT(!page_has_buffers(page));
1958 }
1959}
1960
1961/*
1962 * File a buffer on the given transaction list.
1963 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001964void __jbd2_journal_file_buffer(struct journal_head *jh,
Dave Kleikamp470decc2006-10-11 01:20:57 -07001965 transaction_t *transaction, int jlist)
1966{
1967 struct journal_head **list = NULL;
1968 int was_dirty = 0;
1969 struct buffer_head *bh = jh2bh(jh);
1970
1971 J_ASSERT_JH(jh, jbd_is_locked_bh_state(bh));
1972 assert_spin_locked(&transaction->t_journal->j_list_lock);
1973
1974 J_ASSERT_JH(jh, jh->b_jlist < BJ_Types);
1975 J_ASSERT_JH(jh, jh->b_transaction == transaction ||
Mingming Cao40191912008-01-28 23:58:27 -05001976 jh->b_transaction == NULL);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001977
1978 if (jh->b_transaction && jh->b_jlist == jlist)
1979 return;
1980
1981 /* The following list of buffer states needs to be consistent
1982 * with __jbd_unexpected_dirty_buffer()'s handling of dirty
1983 * state. */
1984
1985 if (jlist == BJ_Metadata || jlist == BJ_Reserved ||
1986 jlist == BJ_Shadow || jlist == BJ_Forget) {
1987 if (test_clear_buffer_dirty(bh) ||
1988 test_clear_buffer_jbddirty(bh))
1989 was_dirty = 1;
1990 }
1991
1992 if (jh->b_transaction)
Mingming Caof7f4bcc2006-10-11 01:20:59 -07001993 __jbd2_journal_temp_unlink_buffer(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07001994 jh->b_transaction = transaction;
1995
1996 switch (jlist) {
1997 case BJ_None:
1998 J_ASSERT_JH(jh, !jh->b_committed_data);
1999 J_ASSERT_JH(jh, !jh->b_frozen_data);
2000 return;
2001 case BJ_SyncData:
2002 list = &transaction->t_sync_datalist;
2003 break;
2004 case BJ_Metadata:
2005 transaction->t_nr_buffers++;
2006 list = &transaction->t_buffers;
2007 break;
2008 case BJ_Forget:
2009 list = &transaction->t_forget;
2010 break;
2011 case BJ_IO:
2012 list = &transaction->t_iobuf_list;
2013 break;
2014 case BJ_Shadow:
2015 list = &transaction->t_shadow_list;
2016 break;
2017 case BJ_LogCtl:
2018 list = &transaction->t_log_list;
2019 break;
2020 case BJ_Reserved:
2021 list = &transaction->t_reserved_list;
2022 break;
2023 case BJ_Locked:
2024 list = &transaction->t_locked_list;
2025 break;
2026 }
2027
2028 __blist_add_buffer(list, jh);
2029 jh->b_jlist = jlist;
2030
2031 if (was_dirty)
2032 set_buffer_jbddirty(bh);
2033}
2034
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002035void jbd2_journal_file_buffer(struct journal_head *jh,
Dave Kleikamp470decc2006-10-11 01:20:57 -07002036 transaction_t *transaction, int jlist)
2037{
2038 jbd_lock_bh_state(jh2bh(jh));
2039 spin_lock(&transaction->t_journal->j_list_lock);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002040 __jbd2_journal_file_buffer(jh, transaction, jlist);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002041 spin_unlock(&transaction->t_journal->j_list_lock);
2042 jbd_unlock_bh_state(jh2bh(jh));
2043}
2044
2045/*
2046 * Remove a buffer from its current buffer list in preparation for
2047 * dropping it from its current transaction entirely. If the buffer has
2048 * already started to be used by a subsequent transaction, refile the
2049 * buffer on that transaction's metadata list.
2050 *
2051 * Called under journal->j_list_lock
2052 *
2053 * Called under jbd_lock_bh_state(jh2bh(jh))
2054 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002055void __jbd2_journal_refile_buffer(struct journal_head *jh)
Dave Kleikamp470decc2006-10-11 01:20:57 -07002056{
2057 int was_dirty;
2058 struct buffer_head *bh = jh2bh(jh);
2059
2060 J_ASSERT_JH(jh, jbd_is_locked_bh_state(bh));
2061 if (jh->b_transaction)
2062 assert_spin_locked(&jh->b_transaction->t_journal->j_list_lock);
2063
2064 /* If the buffer is now unused, just drop it. */
2065 if (jh->b_next_transaction == NULL) {
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002066 __jbd2_journal_unfile_buffer(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002067 return;
2068 }
2069
2070 /*
2071 * It has been modified by a later transaction: add it to the new
2072 * transaction's metadata list.
2073 */
2074
2075 was_dirty = test_clear_buffer_jbddirty(bh);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002076 __jbd2_journal_temp_unlink_buffer(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002077 jh->b_transaction = jh->b_next_transaction;
2078 jh->b_next_transaction = NULL;
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002079 __jbd2_journal_file_buffer(jh, jh->b_transaction,
Dave Kleikamp470decc2006-10-11 01:20:57 -07002080 was_dirty ? BJ_Metadata : BJ_Reserved);
2081 J_ASSERT_JH(jh, jh->b_transaction->t_state == T_RUNNING);
2082
2083 if (was_dirty)
2084 set_buffer_jbddirty(bh);
2085}
2086
2087/*
2088 * For the unlocked version of this call, also make sure that any
2089 * hanging journal_head is cleaned up if necessary.
2090 *
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002091 * __jbd2_journal_refile_buffer is usually called as part of a single locked
Dave Kleikamp470decc2006-10-11 01:20:57 -07002092 * operation on a buffer_head, in which the caller is probably going to
2093 * be hooking the journal_head onto other lists. In that case it is up
2094 * to the caller to remove the journal_head if necessary. For the
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002095 * unlocked jbd2_journal_refile_buffer call, the caller isn't going to be
Dave Kleikamp470decc2006-10-11 01:20:57 -07002096 * doing anything else to the buffer so we need to do the cleanup
2097 * ourselves to avoid a jh leak.
2098 *
2099 * *** The journal_head may be freed by this call! ***
2100 */
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002101void jbd2_journal_refile_buffer(journal_t *journal, struct journal_head *jh)
Dave Kleikamp470decc2006-10-11 01:20:57 -07002102{
2103 struct buffer_head *bh = jh2bh(jh);
2104
2105 jbd_lock_bh_state(bh);
2106 spin_lock(&journal->j_list_lock);
2107
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002108 __jbd2_journal_refile_buffer(jh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002109 jbd_unlock_bh_state(bh);
Mingming Caof7f4bcc2006-10-11 01:20:59 -07002110 jbd2_journal_remove_journal_head(bh);
Dave Kleikamp470decc2006-10-11 01:20:57 -07002111
2112 spin_unlock(&journal->j_list_lock);
2113 __brelse(bh);
2114}