blob: 772b6531a2a25fe09f5499dd9d2b359e8edf18bc [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Uwe Kleine-König58862692007-05-09 07:51:49 +02002 * linux/fs/jbd/transaction.c
Mingming Caoae6ddcc2006-09-27 01:49:27 -07003 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * 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
Mingming Caoae6ddcc2006-09-27 01:49:27 -070013 * journaling system.
Linus Torvalds1da177e2005-04-16 15:20:36 -070014 *
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>
22#include <linux/jbd.h>
23#include <linux/errno.h>
24#include <linux/slab.h>
25#include <linux/timer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/mm.h>
27#include <linux/highmem.h>
28
Adrian Bunkd394e122006-12-06 20:38:26 -080029static void __journal_temp_unlink_buffer(struct journal_head *jh);
30
Linus Torvalds1da177e2005-04-16 15:20:36 -070031/*
32 * get_transaction: obtain a new transaction_t object.
33 *
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 *
48get_transaction(journal_t *journal, transaction_t *transaction)
49{
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. */
Arjan van de Ven44d306e2006-12-10 02:21:26 -080057 journal->j_commit_timer.expires = round_jiffies(transaction->t_expires);
Andrew Mortone3df1892006-03-25 03:06:53 -080058 add_timer(&journal->j_commit_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
60 J_ASSERT(journal->j_running_transaction == NULL);
61 journal->j_running_transaction = transaction;
62
63 return transaction;
64}
65
66/*
67 * Handle management.
68 *
69 * A handle_t is an object which represents a single atomic update to a
70 * filesystem, and which tracks all of the modifications which form part
71 * of that one update.
72 */
73
74/*
75 * start_this_handle: Given a handle, deal with any locking or stalling
76 * needed to make sure that there is enough journal space for the handle
77 * to begin. Attach the handle to a transaction and set up the
Mingming Caoae6ddcc2006-09-27 01:49:27 -070078 * transaction's buffer credits.
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 */
80
81static int start_this_handle(journal_t *journal, handle_t *handle)
82{
83 transaction_t *transaction;
84 int needed;
85 int nblocks = handle->h_buffer_credits;
86 transaction_t *new_transaction = NULL;
87 int ret = 0;
88
89 if (nblocks > journal->j_max_transaction_buffers) {
90 printk(KERN_ERR "JBD: %s wants too many credits (%d > %d)\n",
91 current->comm, nblocks,
92 journal->j_max_transaction_buffers);
93 ret = -ENOSPC;
94 goto out;
95 }
96
97alloc_transaction:
98 if (!journal->j_running_transaction) {
99 new_transaction = jbd_kmalloc(sizeof(*new_transaction),
100 GFP_NOFS);
101 if (!new_transaction) {
102 ret = -ENOMEM;
103 goto out;
104 }
105 memset(new_transaction, 0, sizeof(*new_transaction));
106 }
107
108 jbd_debug(3, "New handle %p going live.\n", handle);
109
110repeat:
111
112 /*
113 * We need to hold j_state_lock until t_updates has been incremented,
114 * for proper journal barrier handling
115 */
116 spin_lock(&journal->j_state_lock);
117repeat_locked:
118 if (is_journal_aborted(journal) ||
119 (journal->j_errno != 0 && !(journal->j_flags & JFS_ACK_ERR))) {
120 spin_unlock(&journal->j_state_lock);
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700121 ret = -EROFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 goto out;
123 }
124
125 /* Wait on the journal's transaction barrier if necessary */
126 if (journal->j_barrier_count) {
127 spin_unlock(&journal->j_state_lock);
128 wait_event(journal->j_wait_transaction_locked,
129 journal->j_barrier_count == 0);
130 goto repeat;
131 }
132
133 if (!journal->j_running_transaction) {
134 if (!new_transaction) {
135 spin_unlock(&journal->j_state_lock);
136 goto alloc_transaction;
137 }
138 get_transaction(journal, new_transaction);
139 new_transaction = NULL;
140 }
141
142 transaction = journal->j_running_transaction;
143
144 /*
145 * If the current transaction is locked down for commit, wait for the
146 * lock to be released.
147 */
148 if (transaction->t_state == T_LOCKED) {
149 DEFINE_WAIT(wait);
150
151 prepare_to_wait(&journal->j_wait_transaction_locked,
152 &wait, TASK_UNINTERRUPTIBLE);
153 spin_unlock(&journal->j_state_lock);
154 schedule();
155 finish_wait(&journal->j_wait_transaction_locked, &wait);
156 goto repeat;
157 }
158
159 /*
160 * If there is not enough space left in the log to write all potential
161 * buffers requested by this operation, we need to stall pending a log
162 * checkpoint to free some more log space.
163 */
164 spin_lock(&transaction->t_handle_lock);
165 needed = transaction->t_outstanding_credits + nblocks;
166
167 if (needed > journal->j_max_transaction_buffers) {
168 /*
169 * If the current transaction is already too large, then start
170 * to commit it: we can then go back and attach this handle to
171 * a new transaction.
172 */
173 DEFINE_WAIT(wait);
174
175 jbd_debug(2, "Handle %p starting new commit...\n", handle);
176 spin_unlock(&transaction->t_handle_lock);
177 prepare_to_wait(&journal->j_wait_transaction_locked, &wait,
178 TASK_UNINTERRUPTIBLE);
179 __log_start_commit(journal, transaction->t_tid);
180 spin_unlock(&journal->j_state_lock);
181 schedule();
182 finish_wait(&journal->j_wait_transaction_locked, &wait);
183 goto repeat;
184 }
185
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700186 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 * The commit code assumes that it can get enough log space
188 * without forcing a checkpoint. This is *critical* for
189 * correctness: a checkpoint of a buffer which is also
190 * associated with a committing transaction creates a deadlock,
191 * so commit simply cannot force through checkpoints.
192 *
193 * We must therefore ensure the necessary space in the journal
194 * *before* starting to dirty potentially checkpointed buffers
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700195 * in the new transaction.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 *
197 * The worst part is, any transaction currently committing can
198 * reduce the free space arbitrarily. Be careful to account for
199 * those buffers when checkpointing.
200 */
201
202 /*
203 * @@@ AKPM: This seems rather over-defensive. We're giving commit
204 * a _lot_ of headroom: 1/4 of the journal plus the size of
205 * the committing transaction. Really, we only need to give it
206 * committing_transaction->t_outstanding_credits plus "enough" for
207 * the log control blocks.
208 * Also, this test is inconsitent with the matching one in
209 * journal_extend().
210 */
211 if (__log_space_left(journal) < jbd_space_needed(journal)) {
212 jbd_debug(2, "Handle %p waiting for checkpoint...\n", handle);
213 spin_unlock(&transaction->t_handle_lock);
214 __log_wait_for_space(journal);
215 goto repeat_locked;
216 }
217
218 /* OK, account for the buffers that this operation expects to
219 * use and add the handle to the running transaction. */
220
221 handle->h_transaction = transaction;
222 transaction->t_outstanding_credits += nblocks;
223 transaction->t_updates++;
224 transaction->t_handle_count++;
225 jbd_debug(4, "Handle %p given %d credits (total %d, free %d)\n",
226 handle, nblocks, transaction->t_outstanding_credits,
227 __log_space_left(journal));
228 spin_unlock(&transaction->t_handle_lock);
229 spin_unlock(&journal->j_state_lock);
230out:
Andrew Morton304c4c82006-06-23 02:05:31 -0700231 if (unlikely(new_transaction)) /* It's usually NULL */
232 kfree(new_transaction);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 return ret;
234}
235
236/* Allocate a new handle. This should probably be in a slab... */
237static handle_t *new_handle(int nblocks)
238{
239 handle_t *handle = jbd_alloc_handle(GFP_NOFS);
240 if (!handle)
241 return NULL;
242 memset(handle, 0, sizeof(*handle));
243 handle->h_buffer_credits = nblocks;
244 handle->h_ref = 1;
245
246 return handle;
247}
248
249/**
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700250 * handle_t *journal_start() - Obtain a new handle.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 * @journal: Journal to start transaction on.
252 * @nblocks: number of block buffer we might modify
253 *
254 * We make sure that the transaction can guarantee at least nblocks of
255 * modified buffers in the log. We block until the log can guarantee
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700256 * that much space.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 *
258 * This function is visible to journal users (like ext3fs), so is not
259 * called with the journal already locked.
260 *
261 * Return a pointer to a newly allocated handle, or NULL on failure
262 */
263handle_t *journal_start(journal_t *journal, int nblocks)
264{
265 handle_t *handle = journal_current_handle();
266 int err;
267
268 if (!journal)
269 return ERR_PTR(-EROFS);
270
271 if (handle) {
272 J_ASSERT(handle->h_transaction->t_journal == journal);
273 handle->h_ref++;
274 return handle;
275 }
276
277 handle = new_handle(nblocks);
278 if (!handle)
279 return ERR_PTR(-ENOMEM);
280
281 current->journal_info = handle;
282
283 err = start_this_handle(journal, handle);
284 if (err < 0) {
285 jbd_free_handle(handle);
286 current->journal_info = NULL;
287 handle = ERR_PTR(err);
288 }
289 return handle;
290}
291
292/**
293 * int journal_extend() - extend buffer credits.
294 * @handle: handle to 'extend'
295 * @nblocks: nr blocks to try to extend by.
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700296 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 * Some transactions, such as large extends and truncates, can be done
298 * atomically all at once or in several stages. The operation requests
299 * a credit for a number of buffer modications in advance, but can
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700300 * extend its credit if it needs more.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 *
302 * journal_extend tries to give the running handle more buffer credits.
303 * It does not guarantee that allocation - this is a best-effort only.
304 * The calling process MUST be able to deal cleanly with a failure to
305 * extend here.
306 *
307 * Return 0 on success, non-zero on failure.
308 *
309 * return code < 0 implies an error
310 * return code > 0 implies normal transaction-full status.
311 */
312int journal_extend(handle_t *handle, int nblocks)
313{
314 transaction_t *transaction = handle->h_transaction;
315 journal_t *journal = transaction->t_journal;
316 int result;
317 int wanted;
318
319 result = -EIO;
320 if (is_handle_aborted(handle))
321 goto out;
322
323 result = 1;
324
325 spin_lock(&journal->j_state_lock);
326
327 /* Don't extend a locked-down transaction! */
328 if (handle->h_transaction->t_state != T_RUNNING) {
329 jbd_debug(3, "denied handle %p %d blocks: "
330 "transaction not running\n", handle, nblocks);
331 goto error_out;
332 }
333
334 spin_lock(&transaction->t_handle_lock);
335 wanted = transaction->t_outstanding_credits + nblocks;
336
337 if (wanted > journal->j_max_transaction_buffers) {
338 jbd_debug(3, "denied handle %p %d blocks: "
339 "transaction too large\n", handle, nblocks);
340 goto unlock;
341 }
342
343 if (wanted > __log_space_left(journal)) {
344 jbd_debug(3, "denied handle %p %d blocks: "
345 "insufficient log space\n", handle, nblocks);
346 goto unlock;
347 }
348
349 handle->h_buffer_credits += nblocks;
350 transaction->t_outstanding_credits += nblocks;
351 result = 0;
352
353 jbd_debug(3, "extended handle %p by %d\n", handle, nblocks);
354unlock:
355 spin_unlock(&transaction->t_handle_lock);
356error_out:
357 spin_unlock(&journal->j_state_lock);
358out:
359 return result;
360}
361
362
363/**
364 * int journal_restart() - restart a handle .
365 * @handle: handle to restart
366 * @nblocks: nr credits requested
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700367 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 * Restart a handle for a multi-transaction filesystem
369 * operation.
370 *
371 * If the journal_extend() call above fails to grant new buffer credits
372 * to a running handle, a call to journal_restart will commit the
373 * handle's transaction so far and reattach the handle to a new
374 * transaction capabable of guaranteeing the requested number of
375 * credits.
376 */
377
378int journal_restart(handle_t *handle, int nblocks)
379{
380 transaction_t *transaction = handle->h_transaction;
381 journal_t *journal = transaction->t_journal;
382 int ret;
383
384 /* If we've had an abort of any type, don't even think about
385 * actually doing the restart! */
386 if (is_handle_aborted(handle))
387 return 0;
388
389 /*
390 * First unlink the handle from its current transaction, and start the
391 * commit on that.
392 */
393 J_ASSERT(transaction->t_updates > 0);
394 J_ASSERT(journal_current_handle() == handle);
395
396 spin_lock(&journal->j_state_lock);
397 spin_lock(&transaction->t_handle_lock);
398 transaction->t_outstanding_credits -= handle->h_buffer_credits;
399 transaction->t_updates--;
400
401 if (!transaction->t_updates)
402 wake_up(&journal->j_wait_updates);
403 spin_unlock(&transaction->t_handle_lock);
404
405 jbd_debug(2, "restarting handle %p\n", handle);
406 __log_start_commit(journal, transaction->t_tid);
407 spin_unlock(&journal->j_state_lock);
408
409 handle->h_buffer_credits = nblocks;
410 ret = start_this_handle(journal, handle);
411 return ret;
412}
413
414
415/**
416 * void journal_lock_updates () - establish a transaction barrier.
417 * @journal: Journal to establish a barrier on.
418 *
419 * This locks out any further updates from being started, and blocks
420 * until all existing updates have completed, returning only once the
421 * journal is in a quiescent state with no updates running.
422 *
423 * The journal lock should not be held on entry.
424 */
425void journal_lock_updates(journal_t *journal)
426{
427 DEFINE_WAIT(wait);
428
429 spin_lock(&journal->j_state_lock);
430 ++journal->j_barrier_count;
431
432 /* Wait until there are no running updates */
433 while (1) {
434 transaction_t *transaction = journal->j_running_transaction;
435
436 if (!transaction)
437 break;
438
439 spin_lock(&transaction->t_handle_lock);
440 if (!transaction->t_updates) {
441 spin_unlock(&transaction->t_handle_lock);
442 break;
443 }
444 prepare_to_wait(&journal->j_wait_updates, &wait,
445 TASK_UNINTERRUPTIBLE);
446 spin_unlock(&transaction->t_handle_lock);
447 spin_unlock(&journal->j_state_lock);
448 schedule();
449 finish_wait(&journal->j_wait_updates, &wait);
450 spin_lock(&journal->j_state_lock);
451 }
452 spin_unlock(&journal->j_state_lock);
453
454 /*
455 * We have now established a barrier against other normal updates, but
456 * we also need to barrier against other journal_lock_updates() calls
457 * to make sure that we serialise special journal-locked operations
458 * too.
459 */
Arjan van de Ven2c68ee72006-03-23 03:00:35 -0800460 mutex_lock(&journal->j_barrier);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461}
462
463/**
464 * void journal_unlock_updates (journal_t* journal) - release barrier
465 * @journal: Journal to release the barrier on.
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700466 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 * Release a transaction barrier obtained with journal_lock_updates().
468 *
469 * Should be called without the journal lock held.
470 */
471void journal_unlock_updates (journal_t *journal)
472{
473 J_ASSERT(journal->j_barrier_count != 0);
474
Arjan van de Ven2c68ee72006-03-23 03:00:35 -0800475 mutex_unlock(&journal->j_barrier);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 spin_lock(&journal->j_state_lock);
477 --journal->j_barrier_count;
478 spin_unlock(&journal->j_state_lock);
479 wake_up(&journal->j_wait_transaction_locked);
480}
481
482/*
483 * Report any unexpected dirty buffers which turn up. Normally those
484 * indicate an error, but they can occur if the user is running (say)
485 * tune2fs to modify the live filesystem, so we need the option of
486 * continuing as gracefully as possible. #
487 *
488 * The caller should already hold the journal lock and
489 * j_list_lock spinlock: most callers will need those anyway
490 * in order to probe the buffer's journaling state safely.
491 */
492static void jbd_unexpected_dirty_buffer(struct journal_head *jh)
493{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 int jlist;
495
Jan Kara4407c2b2005-09-06 15:19:17 -0700496 /* If this buffer is one which might reasonably be dirty
497 * --- ie. data, or not part of this journal --- then
498 * we're OK to leave it alone, but otherwise we need to
499 * move the dirty bit to the journal's own internal
500 * JBDDirty bit. */
501 jlist = jh->b_jlist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502
Jan Kara4407c2b2005-09-06 15:19:17 -0700503 if (jlist == BJ_Metadata || jlist == BJ_Reserved ||
504 jlist == BJ_Shadow || jlist == BJ_Forget) {
505 struct buffer_head *bh = jh2bh(jh);
506
507 if (test_clear_buffer_dirty(bh))
508 set_buffer_jbddirty(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 }
510}
511
512/*
513 * If the buffer is already part of the current transaction, then there
514 * is nothing we need to do. If it is already part of a prior
515 * transaction which we are still committing to disk, then we need to
516 * make sure that we do not overwrite the old copy: we do copy-out to
517 * preserve the copy going to disk. We also account the buffer against
518 * the handle's metadata buffer credits (unless the buffer is already
519 * part of the transaction, that is).
520 *
521 */
522static int
523do_get_write_access(handle_t *handle, struct journal_head *jh,
524 int force_copy)
525{
526 struct buffer_head *bh;
527 transaction_t *transaction;
528 journal_t *journal;
529 int error;
530 char *frozen_buffer = NULL;
531 int need_copy = 0;
532
533 if (is_handle_aborted(handle))
534 return -EROFS;
535
536 transaction = handle->h_transaction;
537 journal = transaction->t_journal;
538
539 jbd_debug(5, "buffer_head %p, force_copy %d\n", jh, force_copy);
540
541 JBUFFER_TRACE(jh, "entry");
542repeat:
543 bh = jh2bh(jh);
544
545 /* @@@ Need to check for errors here at some point. */
546
547 lock_buffer(bh);
548 jbd_lock_bh_state(bh);
549
550 /* We now hold the buffer lock so it is safe to query the buffer
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700551 * state. Is the buffer dirty?
552 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 * If so, there are two possibilities. The buffer may be
554 * non-journaled, and undergoing a quite legitimate writeback.
555 * Otherwise, it is journaled, and we don't expect dirty buffers
556 * in that state (the buffers should be marked JBD_Dirty
557 * instead.) So either the IO is being done under our own
558 * control and this is a bug, or it's a third party IO such as
559 * dump(8) (which may leave the buffer scheduled for read ---
560 * ie. locked but not dirty) or tune2fs (which may actually have
561 * the buffer dirtied, ugh.) */
562
563 if (buffer_dirty(bh)) {
564 /*
565 * First question: is this buffer already part of the current
566 * transaction or the existing committing transaction?
567 */
568 if (jh->b_transaction) {
569 J_ASSERT_JH(jh,
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700570 jh->b_transaction == transaction ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 jh->b_transaction ==
572 journal->j_committing_transaction);
573 if (jh->b_next_transaction)
574 J_ASSERT_JH(jh, jh->b_next_transaction ==
575 transaction);
Jan Kara4407c2b2005-09-06 15:19:17 -0700576 }
577 /*
578 * In any case we need to clean the dirty flag and we must
579 * do it under the buffer lock to be sure we don't race
580 * with running write-out.
581 */
582 JBUFFER_TRACE(jh, "Unexpected dirty buffer");
583 jbd_unexpected_dirty_buffer(jh);
Dave Kleikampe9ad5622006-09-27 01:49:35 -0700584 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585
586 unlock_buffer(bh);
587
588 error = -EROFS;
589 if (is_handle_aborted(handle)) {
590 jbd_unlock_bh_state(bh);
591 goto out;
592 }
593 error = 0;
594
595 /*
596 * The buffer is already part of this transaction if b_transaction or
597 * b_next_transaction points to it
598 */
599 if (jh->b_transaction == transaction ||
600 jh->b_next_transaction == transaction)
601 goto done;
602
603 /*
604 * If there is already a copy-out version of this buffer, then we don't
605 * need to make another one
606 */
607 if (jh->b_frozen_data) {
608 JBUFFER_TRACE(jh, "has frozen data");
609 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
610 jh->b_next_transaction = transaction;
611 goto done;
612 }
613
614 /* Is there data here we need to preserve? */
615
616 if (jh->b_transaction && jh->b_transaction != transaction) {
617 JBUFFER_TRACE(jh, "owned by older transaction");
618 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
619 J_ASSERT_JH(jh, jh->b_transaction ==
620 journal->j_committing_transaction);
621
622 /* There is one case we have to be very careful about.
623 * If the committing transaction is currently writing
624 * this buffer out to disk and has NOT made a copy-out,
625 * then we cannot modify the buffer contents at all
626 * right now. The essence of copy-out is that it is the
627 * extra copy, not the primary copy, which gets
628 * journaled. If the primary copy is already going to
629 * disk then we cannot do copy-out here. */
630
631 if (jh->b_jlist == BJ_Shadow) {
632 DEFINE_WAIT_BIT(wait, &bh->b_state, BH_Unshadow);
633 wait_queue_head_t *wqh;
634
635 wqh = bit_waitqueue(&bh->b_state, BH_Unshadow);
636
637 JBUFFER_TRACE(jh, "on shadow: sleep");
638 jbd_unlock_bh_state(bh);
639 /* commit wakes up all shadow buffers after IO */
640 for ( ; ; ) {
641 prepare_to_wait(wqh, &wait.wait,
642 TASK_UNINTERRUPTIBLE);
643 if (jh->b_jlist != BJ_Shadow)
644 break;
645 schedule();
646 }
647 finish_wait(wqh, &wait.wait);
648 goto repeat;
649 }
650
651 /* Only do the copy if the currently-owning transaction
652 * still needs it. If it is on the Forget list, the
653 * committing transaction is past that stage. The
654 * buffer had better remain locked during the kmalloc,
655 * but that should be true --- we hold the journal lock
656 * still and the buffer is already on the BUF_JOURNAL
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700657 * list so won't be flushed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 *
659 * Subtle point, though: if this is a get_undo_access,
660 * then we will be relying on the frozen_data to contain
661 * the new value of the committed_data record after the
662 * transaction, so we HAVE to force the frozen_data copy
663 * in that case. */
664
665 if (jh->b_jlist != BJ_Forget || force_copy) {
666 JBUFFER_TRACE(jh, "generate frozen data");
667 if (!frozen_buffer) {
668 JBUFFER_TRACE(jh, "allocate memory for buffer");
669 jbd_unlock_bh_state(bh);
Badari Pulavartyea817392006-08-27 01:23:52 -0700670 frozen_buffer =
671 jbd_slab_alloc(jh2bh(jh)->b_size,
672 GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 if (!frozen_buffer) {
674 printk(KERN_EMERG
675 "%s: OOM for frozen_buffer\n",
676 __FUNCTION__);
677 JBUFFER_TRACE(jh, "oom!");
678 error = -ENOMEM;
679 jbd_lock_bh_state(bh);
680 goto done;
681 }
682 goto repeat;
683 }
684 jh->b_frozen_data = frozen_buffer;
685 frozen_buffer = NULL;
686 need_copy = 1;
687 }
688 jh->b_next_transaction = transaction;
689 }
690
691
692 /*
693 * Finally, if the buffer is not journaled right now, we need to make
694 * sure it doesn't get written to disk before the caller actually
695 * commits the new data
696 */
697 if (!jh->b_transaction) {
698 JBUFFER_TRACE(jh, "no transaction");
699 J_ASSERT_JH(jh, !jh->b_next_transaction);
700 jh->b_transaction = transaction;
701 JBUFFER_TRACE(jh, "file as BJ_Reserved");
702 spin_lock(&journal->j_list_lock);
703 __journal_file_buffer(jh, transaction, BJ_Reserved);
704 spin_unlock(&journal->j_list_lock);
705 }
706
707done:
708 if (need_copy) {
709 struct page *page;
710 int offset;
711 char *source;
712
713 J_EXPECT_JH(jh, buffer_uptodate(jh2bh(jh)),
714 "Possible IO failure.\n");
715 page = jh2bh(jh)->b_page;
716 offset = ((unsigned long) jh2bh(jh)->b_data) & ~PAGE_MASK;
717 source = kmap_atomic(page, KM_USER0);
718 memcpy(jh->b_frozen_data, source+offset, jh2bh(jh)->b_size);
719 kunmap_atomic(source, KM_USER0);
720 }
721 jbd_unlock_bh_state(bh);
722
723 /*
724 * If we are about to journal a buffer, then any revoke pending on it is
725 * no longer valid
726 */
727 journal_cancel_revoke(handle, jh);
728
729out:
Andrew Morton304c4c82006-06-23 02:05:31 -0700730 if (unlikely(frozen_buffer)) /* It's usually NULL */
Badari Pulavarty4cfb04a2006-08-31 21:27:54 -0700731 jbd_slab_free(frozen_buffer, bh->b_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732
733 JBUFFER_TRACE(jh, "exit");
734 return error;
735}
736
737/**
738 * int journal_get_write_access() - notify intent to modify a buffer for metadata (not data) update.
739 * @handle: transaction to add buffer modifications to
740 * @bh: bh to be used for metadata writes
741 * @credits: variable that will receive credits for the buffer
742 *
743 * Returns an error code or 0 on success.
744 *
745 * In full data journalling mode the buffer may be of type BJ_AsyncData,
746 * because we're write()ing a buffer which is also part of a shared mapping.
747 */
748
749int journal_get_write_access(handle_t *handle, struct buffer_head *bh)
750{
751 struct journal_head *jh = journal_add_journal_head(bh);
752 int rc;
753
754 /* We do not want to get caught playing with fields which the
755 * log thread also manipulates. Make sure that the buffer
756 * completes any outstanding IO before proceeding. */
757 rc = do_get_write_access(handle, jh, 0);
758 journal_put_journal_head(jh);
759 return rc;
760}
761
762
763/*
764 * When the user wants to journal a newly created buffer_head
765 * (ie. getblk() returned a new buffer and we are going to populate it
766 * manually rather than reading off disk), then we need to keep the
767 * buffer_head locked until it has been completely filled with new
768 * data. In this case, we should be able to make the assertion that
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700769 * the bh is not already part of an existing transaction.
770 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 * The buffer should already be locked by the caller by this point.
772 * There is no lock ranking violation: it was a newly created,
773 * unlocked buffer beforehand. */
774
775/**
776 * int journal_get_create_access () - notify intent to use newly created bh
777 * @handle: transaction to new buffer to
778 * @bh: new buffer.
779 *
780 * Call this if you create a new bh.
781 */
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700782int journal_get_create_access(handle_t *handle, struct buffer_head *bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783{
784 transaction_t *transaction = handle->h_transaction;
785 journal_t *journal = transaction->t_journal;
786 struct journal_head *jh = journal_add_journal_head(bh);
787 int err;
788
789 jbd_debug(5, "journal_head %p\n", jh);
790 err = -EROFS;
791 if (is_handle_aborted(handle))
792 goto out;
793 err = 0;
794
795 JBUFFER_TRACE(jh, "entry");
796 /*
797 * The buffer may already belong to this transaction due to pre-zeroing
798 * in the filesystem's new_block code. It may also be on the previous,
799 * committing transaction's lists, but it HAS to be in Forget state in
800 * that case: the transaction must have deleted the buffer for it to be
801 * reused here.
802 */
803 jbd_lock_bh_state(bh);
804 spin_lock(&journal->j_list_lock);
805 J_ASSERT_JH(jh, (jh->b_transaction == transaction ||
806 jh->b_transaction == NULL ||
807 (jh->b_transaction == journal->j_committing_transaction &&
808 jh->b_jlist == BJ_Forget)));
809
810 J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
811 J_ASSERT_JH(jh, buffer_locked(jh2bh(jh)));
812
813 if (jh->b_transaction == NULL) {
814 jh->b_transaction = transaction;
815 JBUFFER_TRACE(jh, "file as BJ_Reserved");
816 __journal_file_buffer(jh, transaction, BJ_Reserved);
817 } else if (jh->b_transaction == journal->j_committing_transaction) {
818 JBUFFER_TRACE(jh, "set next transaction");
819 jh->b_next_transaction = transaction;
820 }
821 spin_unlock(&journal->j_list_lock);
822 jbd_unlock_bh_state(bh);
823
824 /*
825 * akpm: I added this. ext3_alloc_branch can pick up new indirect
826 * blocks which contain freed but then revoked metadata. We need
827 * to cancel the revoke in case we end up freeing it yet again
828 * and the reallocating as data - this would cause a second revoke,
829 * which hits an assertion error.
830 */
831 JBUFFER_TRACE(jh, "cancelling revoke");
832 journal_cancel_revoke(handle, jh);
833 journal_put_journal_head(jh);
834out:
835 return err;
836}
837
838/**
839 * int journal_get_undo_access() - Notify intent to modify metadata with
840 * non-rewindable consequences
841 * @handle: transaction
842 * @bh: buffer to undo
843 * @credits: store the number of taken credits here (if not NULL)
844 *
845 * Sometimes there is a need to distinguish between metadata which has
846 * been committed to disk and that which has not. The ext3fs code uses
847 * this for freeing and allocating space, we have to make sure that we
848 * do not reuse freed space until the deallocation has been committed,
849 * since if we overwrote that space we would make the delete
850 * un-rewindable in case of a crash.
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700851 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 * To deal with that, journal_get_undo_access requests write access to a
853 * buffer for parts of non-rewindable operations such as delete
854 * operations on the bitmaps. The journaling code must keep a copy of
855 * the buffer's contents prior to the undo_access call until such time
856 * as we know that the buffer has definitely been committed to disk.
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700857 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 * We never need to know which transaction the committed data is part
859 * of, buffers touched here are guaranteed to be dirtied later and so
860 * will be committed to a new transaction in due course, at which point
861 * we can discard the old committed data pointer.
862 *
863 * Returns error number or 0 on success.
864 */
865int journal_get_undo_access(handle_t *handle, struct buffer_head *bh)
866{
867 int err;
868 struct journal_head *jh = journal_add_journal_head(bh);
869 char *committed_data = NULL;
870
871 JBUFFER_TRACE(jh, "entry");
872
873 /*
874 * Do this first --- it can drop the journal lock, so we want to
875 * make sure that obtaining the committed_data is done
876 * atomically wrt. completion of any outstanding commits.
877 */
878 err = do_get_write_access(handle, jh, 1);
879 if (err)
880 goto out;
881
882repeat:
883 if (!jh->b_committed_data) {
Badari Pulavartyea817392006-08-27 01:23:52 -0700884 committed_data = jbd_slab_alloc(jh2bh(jh)->b_size, GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 if (!committed_data) {
886 printk(KERN_EMERG "%s: No memory for committed data\n",
887 __FUNCTION__);
888 err = -ENOMEM;
889 goto out;
890 }
891 }
892
893 jbd_lock_bh_state(bh);
894 if (!jh->b_committed_data) {
895 /* Copy out the current buffer contents into the
896 * preserved, committed copy. */
897 JBUFFER_TRACE(jh, "generate b_committed data");
898 if (!committed_data) {
899 jbd_unlock_bh_state(bh);
900 goto repeat;
901 }
902
903 jh->b_committed_data = committed_data;
904 committed_data = NULL;
905 memcpy(jh->b_committed_data, bh->b_data, bh->b_size);
906 }
907 jbd_unlock_bh_state(bh);
908out:
909 journal_put_journal_head(jh);
Andrew Morton304c4c82006-06-23 02:05:31 -0700910 if (unlikely(committed_data))
Badari Pulavartyea817392006-08-27 01:23:52 -0700911 jbd_slab_free(committed_data, bh->b_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 return err;
913}
914
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700915/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 * int journal_dirty_data() - mark a buffer as containing dirty data which
917 * needs to be flushed before we can commit the
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700918 * current transaction.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 * @handle: transaction
920 * @bh: bufferhead to mark
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700921 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 * The buffer is placed on the transaction's data list and is marked as
923 * belonging to the transaction.
924 *
925 * Returns error number or 0 on success.
926 *
927 * journal_dirty_data() can be called via page_launder->ext3_writepage
928 * by kswapd.
929 */
930int journal_dirty_data(handle_t *handle, struct buffer_head *bh)
931{
932 journal_t *journal = handle->h_transaction->t_journal;
933 int need_brelse = 0;
934 struct journal_head *jh;
935
936 if (is_handle_aborted(handle))
937 return 0;
938
939 jh = journal_add_journal_head(bh);
940 JBUFFER_TRACE(jh, "entry");
941
942 /*
943 * The buffer could *already* be dirty. Writeout can start
944 * at any time.
945 */
946 jbd_debug(4, "jh: %p, tid:%d\n", jh, handle->h_transaction->t_tid);
947
948 /*
949 * What if the buffer is already part of a running transaction?
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700950 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 * There are two cases:
952 * 1) It is part of the current running transaction. Refile it,
953 * just in case we have allocated it as metadata, deallocated
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700954 * it, then reallocated it as data.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 * 2) It is part of the previous, still-committing transaction.
956 * If all we want to do is to guarantee that the buffer will be
957 * written to disk before this new transaction commits, then
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700958 * being sure that the *previous* transaction has this same
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 * property is sufficient for us! Just leave it on its old
960 * transaction.
961 *
962 * In case (2), the buffer must not already exist as metadata
963 * --- that would violate write ordering (a transaction is free
964 * to write its data at any point, even before the previous
965 * committing transaction has committed). The caller must
966 * never, ever allow this to happen: there's nothing we can do
967 * about it in this layer.
968 */
969 jbd_lock_bh_state(bh);
970 spin_lock(&journal->j_list_lock);
Eric Sandeenf58a74d2006-10-28 10:38:27 -0700971
972 /* Now that we have bh_state locked, are we really still mapped? */
973 if (!buffer_mapped(bh)) {
974 JBUFFER_TRACE(jh, "unmapped buffer, bailing out");
975 goto no_journal;
976 }
977
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 if (jh->b_transaction) {
979 JBUFFER_TRACE(jh, "has transaction");
980 if (jh->b_transaction != handle->h_transaction) {
981 JBUFFER_TRACE(jh, "belongs to older transaction");
982 J_ASSERT_JH(jh, jh->b_transaction ==
983 journal->j_committing_transaction);
984
985 /* @@@ IS THIS TRUE ? */
986 /*
987 * Not any more. Scenario: someone does a write()
988 * in data=journal mode. The buffer's transaction has
989 * moved into commit. Then someone does another
990 * write() to the file. We do the frozen data copyout
991 * and set b_next_transaction to point to j_running_t.
992 * And while we're in that state, someone does a
993 * writepage() in an attempt to pageout the same area
994 * of the file via a shared mapping. At present that
995 * calls journal_dirty_data(), and we get right here.
996 * It may be too late to journal the data. Simply
997 * falling through to the next test will suffice: the
998 * data will be dirty and wil be checkpointed. The
999 * ordering comments in the next comment block still
1000 * apply.
1001 */
1002 //J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
1003
1004 /*
1005 * If we're journalling data, and this buffer was
1006 * subject to a write(), it could be metadata, forget
1007 * or shadow against the committing transaction. Now,
1008 * someone has dirtied the same darn page via a mapping
1009 * and it is being writepage()'d.
1010 * We *could* just steal the page from commit, with some
1011 * fancy locking there. Instead, we just skip it -
1012 * don't tie the page's buffers to the new transaction
1013 * at all.
1014 * Implication: if we crash before the writepage() data
1015 * is written into the filesystem, recovery will replay
1016 * the write() data.
1017 */
1018 if (jh->b_jlist != BJ_None &&
1019 jh->b_jlist != BJ_SyncData &&
1020 jh->b_jlist != BJ_Locked) {
1021 JBUFFER_TRACE(jh, "Not stealing");
1022 goto no_journal;
1023 }
1024
1025 /*
1026 * This buffer may be undergoing writeout in commit. We
1027 * can't return from here and let the caller dirty it
1028 * again because that can cause the write-out loop in
1029 * commit to never terminate.
1030 */
1031 if (buffer_dirty(bh)) {
1032 get_bh(bh);
1033 spin_unlock(&journal->j_list_lock);
1034 jbd_unlock_bh_state(bh);
1035 need_brelse = 1;
1036 sync_dirty_buffer(bh);
1037 jbd_lock_bh_state(bh);
1038 spin_lock(&journal->j_list_lock);
Eric Sandeenf58a74d2006-10-28 10:38:27 -07001039 /* Since we dropped the lock... */
1040 if (!buffer_mapped(bh)) {
1041 JBUFFER_TRACE(jh, "buffer got unmapped");
1042 goto no_journal;
1043 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 /* The buffer may become locked again at any
1045 time if it is redirtied */
1046 }
1047
1048 /* journal_clean_data_list() may have got there first */
1049 if (jh->b_transaction != NULL) {
1050 JBUFFER_TRACE(jh, "unfile from commit");
1051 __journal_temp_unlink_buffer(jh);
1052 /* It still points to the committing
1053 * transaction; move it to this one so
1054 * that the refile assert checks are
1055 * happy. */
1056 jh->b_transaction = handle->h_transaction;
1057 }
1058 /* The buffer will be refiled below */
1059
1060 }
1061 /*
1062 * Special case --- the buffer might actually have been
1063 * allocated and then immediately deallocated in the previous,
1064 * committing transaction, so might still be left on that
1065 * transaction's metadata lists.
1066 */
1067 if (jh->b_jlist != BJ_SyncData && jh->b_jlist != BJ_Locked) {
1068 JBUFFER_TRACE(jh, "not on correct data list: unfile");
1069 J_ASSERT_JH(jh, jh->b_jlist != BJ_Shadow);
1070 __journal_temp_unlink_buffer(jh);
1071 jh->b_transaction = handle->h_transaction;
1072 JBUFFER_TRACE(jh, "file as data");
1073 __journal_file_buffer(jh, handle->h_transaction,
1074 BJ_SyncData);
1075 }
1076 } else {
1077 JBUFFER_TRACE(jh, "not on a transaction");
1078 __journal_file_buffer(jh, handle->h_transaction, BJ_SyncData);
1079 }
1080no_journal:
1081 spin_unlock(&journal->j_list_lock);
1082 jbd_unlock_bh_state(bh);
1083 if (need_brelse) {
1084 BUFFER_TRACE(bh, "brelse");
1085 __brelse(bh);
1086 }
1087 JBUFFER_TRACE(jh, "exit");
1088 journal_put_journal_head(jh);
1089 return 0;
1090}
1091
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001092/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 * int journal_dirty_metadata() - mark a buffer as containing dirty metadata
1094 * @handle: transaction to add buffer to.
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001095 * @bh: buffer to mark
1096 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 * mark dirty metadata which needs to be journaled as part of the current
1098 * transaction.
1099 *
1100 * The buffer is placed on the transaction's metadata list and is marked
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001101 * as belonging to the transaction.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 *
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001103 * Returns error number or 0 on success.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 *
1105 * Special care needs to be taken if the buffer already belongs to the
1106 * current committing transaction (in which case we should have frozen
1107 * data present for that commit). In that case, we don't relink the
1108 * buffer: that only gets done when the old transaction finally
1109 * completes its commit.
1110 */
1111int journal_dirty_metadata(handle_t *handle, struct buffer_head *bh)
1112{
1113 transaction_t *transaction = handle->h_transaction;
1114 journal_t *journal = transaction->t_journal;
1115 struct journal_head *jh = bh2jh(bh);
1116
1117 jbd_debug(5, "journal_head %p\n", jh);
1118 JBUFFER_TRACE(jh, "entry");
1119 if (is_handle_aborted(handle))
1120 goto out;
1121
1122 jbd_lock_bh_state(bh);
1123
1124 if (jh->b_modified == 0) {
1125 /*
1126 * This buffer's got modified and becoming part
1127 * of the transaction. This needs to be done
1128 * once a transaction -bzzz
1129 */
1130 jh->b_modified = 1;
1131 J_ASSERT_JH(jh, handle->h_buffer_credits > 0);
1132 handle->h_buffer_credits--;
1133 }
1134
1135 /*
1136 * fastpath, to avoid expensive locking. If this buffer is already
1137 * on the running transaction's metadata list there is nothing to do.
1138 * Nobody can take it off again because there is a handle open.
1139 * I _think_ we're OK here with SMP barriers - a mistaken decision will
1140 * result in this test being false, so we go in and take the locks.
1141 */
1142 if (jh->b_transaction == transaction && jh->b_jlist == BJ_Metadata) {
1143 JBUFFER_TRACE(jh, "fastpath");
1144 J_ASSERT_JH(jh, jh->b_transaction ==
1145 journal->j_running_transaction);
1146 goto out_unlock_bh;
1147 }
1148
1149 set_buffer_jbddirty(bh);
1150
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001151 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 * Metadata already on the current transaction list doesn't
1153 * need to be filed. Metadata on another transaction's list must
1154 * be committing, and will be refiled once the commit completes:
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001155 * leave it alone for now.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 */
1157 if (jh->b_transaction != transaction) {
1158 JBUFFER_TRACE(jh, "already on other transaction");
1159 J_ASSERT_JH(jh, jh->b_transaction ==
1160 journal->j_committing_transaction);
1161 J_ASSERT_JH(jh, jh->b_next_transaction == transaction);
1162 /* And this case is illegal: we can't reuse another
1163 * transaction's data buffer, ever. */
1164 goto out_unlock_bh;
1165 }
1166
1167 /* That test should have eliminated the following case: */
1168 J_ASSERT_JH(jh, jh->b_frozen_data == 0);
1169
1170 JBUFFER_TRACE(jh, "file as BJ_Metadata");
1171 spin_lock(&journal->j_list_lock);
1172 __journal_file_buffer(jh, handle->h_transaction, BJ_Metadata);
1173 spin_unlock(&journal->j_list_lock);
1174out_unlock_bh:
1175 jbd_unlock_bh_state(bh);
1176out:
1177 JBUFFER_TRACE(jh, "exit");
1178 return 0;
1179}
1180
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001181/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 * journal_release_buffer: undo a get_write_access without any buffer
1183 * updates, if the update decided in the end that it didn't need access.
1184 *
1185 */
1186void
1187journal_release_buffer(handle_t *handle, struct buffer_head *bh)
1188{
1189 BUFFER_TRACE(bh, "entry");
1190}
1191
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001192/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 * void journal_forget() - bforget() for potentially-journaled buffers.
1194 * @handle: transaction handle
1195 * @bh: bh to 'forget'
1196 *
1197 * We can only do the bforget if there are no commits pending against the
1198 * buffer. If the buffer is dirty in the current running transaction we
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001199 * can safely unlink it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 *
1201 * bh may not be a journalled buffer at all - it may be a non-JBD
1202 * buffer which came off the hashtable. Check for this.
1203 *
1204 * Decrements bh->b_count by one.
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001205 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 * Allow this call even if the handle has aborted --- it may be part of
1207 * the caller's cleanup after an abort.
1208 */
1209int journal_forget (handle_t *handle, struct buffer_head *bh)
1210{
1211 transaction_t *transaction = handle->h_transaction;
1212 journal_t *journal = transaction->t_journal;
1213 struct journal_head *jh;
1214 int drop_reserve = 0;
1215 int err = 0;
1216
1217 BUFFER_TRACE(bh, "entry");
1218
1219 jbd_lock_bh_state(bh);
1220 spin_lock(&journal->j_list_lock);
1221
1222 if (!buffer_jbd(bh))
1223 goto not_jbd;
1224 jh = bh2jh(bh);
1225
1226 /* Critical error: attempting to delete a bitmap buffer, maybe?
1227 * Don't do any jbd operations, and return an error. */
1228 if (!J_EXPECT_JH(jh, !jh->b_committed_data,
1229 "inconsistent data on disk")) {
1230 err = -EIO;
1231 goto not_jbd;
1232 }
1233
1234 /*
1235 * The buffer's going from the transaction, we must drop
1236 * all references -bzzz
1237 */
1238 jh->b_modified = 0;
1239
1240 if (jh->b_transaction == handle->h_transaction) {
1241 J_ASSERT_JH(jh, !jh->b_frozen_data);
1242
1243 /* If we are forgetting a buffer which is already part
1244 * of this transaction, then we can just drop it from
1245 * the transaction immediately. */
1246 clear_buffer_dirty(bh);
1247 clear_buffer_jbddirty(bh);
1248
1249 JBUFFER_TRACE(jh, "belongs to current transaction: unfile");
1250
1251 drop_reserve = 1;
1252
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001253 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 * We are no longer going to journal this buffer.
1255 * However, the commit of this transaction is still
1256 * important to the buffer: the delete that we are now
1257 * processing might obsolete an old log entry, so by
1258 * committing, we can satisfy the buffer's checkpoint.
1259 *
1260 * So, if we have a checkpoint on the buffer, we should
1261 * now refile the buffer on our BJ_Forget list so that
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001262 * we know to remove the checkpoint after we commit.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 */
1264
1265 if (jh->b_cp_transaction) {
1266 __journal_temp_unlink_buffer(jh);
1267 __journal_file_buffer(jh, transaction, BJ_Forget);
1268 } else {
1269 __journal_unfile_buffer(jh);
1270 journal_remove_journal_head(bh);
1271 __brelse(bh);
1272 if (!buffer_jbd(bh)) {
1273 spin_unlock(&journal->j_list_lock);
1274 jbd_unlock_bh_state(bh);
1275 __bforget(bh);
1276 goto drop;
1277 }
1278 }
1279 } else if (jh->b_transaction) {
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001280 J_ASSERT_JH(jh, (jh->b_transaction ==
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 journal->j_committing_transaction));
1282 /* However, if the buffer is still owned by a prior
1283 * (committing) transaction, we can't drop it yet... */
1284 JBUFFER_TRACE(jh, "belongs to older transaction");
1285 /* ... but we CAN drop it from the new transaction if we
1286 * have also modified it since the original commit. */
1287
1288 if (jh->b_next_transaction) {
1289 J_ASSERT(jh->b_next_transaction == transaction);
1290 jh->b_next_transaction = NULL;
1291 drop_reserve = 1;
1292 }
1293 }
1294
1295not_jbd:
1296 spin_unlock(&journal->j_list_lock);
1297 jbd_unlock_bh_state(bh);
1298 __brelse(bh);
1299drop:
1300 if (drop_reserve) {
1301 /* no need to reserve log space for this block -bzzz */
1302 handle->h_buffer_credits++;
1303 }
1304 return err;
1305}
1306
1307/**
1308 * int journal_stop() - complete a transaction
1309 * @handle: tranaction to complete.
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001310 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 * All done for a particular handle.
1312 *
1313 * There is not much action needed here. We just return any remaining
1314 * buffer credits to the transaction and remove the handle. The only
1315 * complication is that we need to start a commit operation if the
1316 * filesystem is marked for synchronous update.
1317 *
1318 * journal_stop itself will not usually return an error, but it may
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001319 * do so in unusual circumstances. In particular, expect it to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 * return -EIO if a journal_abort has been executed since the
1321 * transaction began.
1322 */
1323int journal_stop(handle_t *handle)
1324{
1325 transaction_t *transaction = handle->h_transaction;
1326 journal_t *journal = transaction->t_journal;
1327 int old_handle_count, err;
Andrew Mortonfe1dcbc2006-02-04 23:27:54 -08001328 pid_t pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330 J_ASSERT(journal_current_handle() == handle);
1331
1332 if (is_handle_aborted(handle))
1333 err = -EIO;
OGAWA Hirofumi3e2a5322006-10-19 23:29:11 -07001334 else {
1335 J_ASSERT(transaction->t_updates > 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 err = 0;
OGAWA Hirofumi3e2a5322006-10-19 23:29:11 -07001337 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338
1339 if (--handle->h_ref > 0) {
1340 jbd_debug(4, "h_ref %d -> %d\n", handle->h_ref + 1,
1341 handle->h_ref);
1342 return err;
1343 }
1344
1345 jbd_debug(4, "Handle %p going down\n", handle);
1346
1347 /*
1348 * Implement synchronous transaction batching. If the handle
1349 * was synchronous, don't force a commit immediately. Let's
1350 * yield and let another thread piggyback onto this transaction.
1351 * Keep doing that while new threads continue to arrive.
1352 * It doesn't cost much - we're about to run a commit and sleep
1353 * on IO anyway. Speeds up many-threaded, many-dir operations
1354 * by 30x or more...
Andrew Mortonfe1dcbc2006-02-04 23:27:54 -08001355 *
1356 * But don't do this if this process was the most recent one to
1357 * perform a synchronous write. We do this to detect the case where a
1358 * single process is doing a stream of sync writes. No point in waiting
1359 * for joiners in that case.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 */
Andrew Mortonfe1dcbc2006-02-04 23:27:54 -08001361 pid = current->pid;
1362 if (handle->h_sync && journal->j_last_sync_writer != pid) {
1363 journal->j_last_sync_writer = pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 do {
1365 old_handle_count = transaction->t_handle_count;
Nishanth Aravamudan041e0e32005-09-10 00:27:23 -07001366 schedule_timeout_uninterruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 } while (old_handle_count != transaction->t_handle_count);
1368 }
1369
1370 current->journal_info = NULL;
1371 spin_lock(&journal->j_state_lock);
1372 spin_lock(&transaction->t_handle_lock);
1373 transaction->t_outstanding_credits -= handle->h_buffer_credits;
1374 transaction->t_updates--;
1375 if (!transaction->t_updates) {
1376 wake_up(&journal->j_wait_updates);
1377 if (journal->j_barrier_count)
1378 wake_up(&journal->j_wait_transaction_locked);
1379 }
1380
1381 /*
1382 * If the handle is marked SYNC, we need to set another commit
1383 * going! We also want to force a commit if the current
1384 * transaction is occupying too much of the log, or if the
1385 * transaction is too old now.
1386 */
1387 if (handle->h_sync ||
1388 transaction->t_outstanding_credits >
1389 journal->j_max_transaction_buffers ||
Dave Kleikampe9ad5622006-09-27 01:49:35 -07001390 time_after_eq(jiffies, transaction->t_expires)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 /* Do this even for aborted journals: an abort still
1392 * completes the commit thread, it just doesn't write
1393 * anything to disk. */
1394 tid_t tid = transaction->t_tid;
1395
1396 spin_unlock(&transaction->t_handle_lock);
1397 jbd_debug(2, "transaction too old, requesting commit for "
1398 "handle %p\n", handle);
1399 /* This is non-blocking */
1400 __log_start_commit(journal, transaction->t_tid);
1401 spin_unlock(&journal->j_state_lock);
1402
1403 /*
1404 * Special case: JFS_SYNC synchronous updates require us
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001405 * to wait for the commit to complete.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 */
1407 if (handle->h_sync && !(current->flags & PF_MEMALLOC))
1408 err = log_wait_commit(journal, tid);
1409 } else {
1410 spin_unlock(&transaction->t_handle_lock);
1411 spin_unlock(&journal->j_state_lock);
1412 }
1413
1414 jbd_free_handle(handle);
1415 return err;
1416}
1417
1418/**int journal_force_commit() - force any uncommitted transactions
1419 * @journal: journal to force
1420 *
1421 * For synchronous operations: force any uncommitted transactions
1422 * to disk. May seem kludgy, but it reuses all the handle batching
1423 * code in a very simple manner.
1424 */
1425int journal_force_commit(journal_t *journal)
1426{
1427 handle_t *handle;
1428 int ret;
1429
1430 handle = journal_start(journal, 1);
1431 if (IS_ERR(handle)) {
1432 ret = PTR_ERR(handle);
1433 } else {
1434 handle->h_sync = 1;
1435 ret = journal_stop(handle);
1436 }
1437 return ret;
1438}
1439
1440/*
1441 *
1442 * List management code snippets: various functions for manipulating the
1443 * transaction buffer lists.
1444 *
1445 */
1446
1447/*
1448 * Append a buffer to a transaction list, given the transaction's list head
1449 * pointer.
1450 *
1451 * j_list_lock is held.
1452 *
1453 * jbd_lock_bh_state(jh2bh(jh)) is held.
1454 */
1455
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001456static inline void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457__blist_add_buffer(struct journal_head **list, struct journal_head *jh)
1458{
1459 if (!*list) {
1460 jh->b_tnext = jh->b_tprev = jh;
1461 *list = jh;
1462 } else {
1463 /* Insert at the tail of the list to preserve order */
1464 struct journal_head *first = *list, *last = first->b_tprev;
1465 jh->b_tprev = last;
1466 jh->b_tnext = first;
1467 last->b_tnext = first->b_tprev = jh;
1468 }
1469}
1470
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001471/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 * Remove a buffer from a transaction list, given the transaction's list
1473 * head pointer.
1474 *
1475 * Called with j_list_lock held, and the journal may not be locked.
1476 *
1477 * jbd_lock_bh_state(jh2bh(jh)) is held.
1478 */
1479
1480static inline void
1481__blist_del_buffer(struct journal_head **list, struct journal_head *jh)
1482{
1483 if (*list == jh) {
1484 *list = jh->b_tnext;
1485 if (*list == jh)
1486 *list = NULL;
1487 }
1488 jh->b_tprev->b_tnext = jh->b_tnext;
1489 jh->b_tnext->b_tprev = jh->b_tprev;
1490}
1491
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001492/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 * Remove a buffer from the appropriate transaction list.
1494 *
1495 * Note that this function can *change* the value of
1496 * bh->b_transaction->t_sync_datalist, t_buffers, t_forget,
1497 * t_iobuf_list, t_shadow_list, t_log_list or t_reserved_list. If the caller
1498 * is holding onto a copy of one of thee pointers, it could go bad.
1499 * Generally the caller needs to re-read the pointer from the transaction_t.
1500 *
1501 * Called under j_list_lock. The journal may not be locked.
1502 */
Adrian Bunkd394e122006-12-06 20:38:26 -08001503static void __journal_temp_unlink_buffer(struct journal_head *jh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504{
1505 struct journal_head **list = NULL;
1506 transaction_t *transaction;
1507 struct buffer_head *bh = jh2bh(jh);
1508
1509 J_ASSERT_JH(jh, jbd_is_locked_bh_state(bh));
1510 transaction = jh->b_transaction;
1511 if (transaction)
1512 assert_spin_locked(&transaction->t_journal->j_list_lock);
1513
1514 J_ASSERT_JH(jh, jh->b_jlist < BJ_Types);
1515 if (jh->b_jlist != BJ_None)
1516 J_ASSERT_JH(jh, transaction != 0);
1517
1518 switch (jh->b_jlist) {
1519 case BJ_None:
1520 return;
1521 case BJ_SyncData:
1522 list = &transaction->t_sync_datalist;
1523 break;
1524 case BJ_Metadata:
1525 transaction->t_nr_buffers--;
1526 J_ASSERT_JH(jh, transaction->t_nr_buffers >= 0);
1527 list = &transaction->t_buffers;
1528 break;
1529 case BJ_Forget:
1530 list = &transaction->t_forget;
1531 break;
1532 case BJ_IO:
1533 list = &transaction->t_iobuf_list;
1534 break;
1535 case BJ_Shadow:
1536 list = &transaction->t_shadow_list;
1537 break;
1538 case BJ_LogCtl:
1539 list = &transaction->t_log_list;
1540 break;
1541 case BJ_Reserved:
1542 list = &transaction->t_reserved_list;
1543 break;
1544 case BJ_Locked:
1545 list = &transaction->t_locked_list;
1546 break;
1547 }
1548
1549 __blist_del_buffer(list, jh);
1550 jh->b_jlist = BJ_None;
1551 if (test_clear_buffer_jbddirty(bh))
1552 mark_buffer_dirty(bh); /* Expose it to the VM */
1553}
1554
1555void __journal_unfile_buffer(struct journal_head *jh)
1556{
1557 __journal_temp_unlink_buffer(jh);
1558 jh->b_transaction = NULL;
1559}
1560
1561void journal_unfile_buffer(journal_t *journal, struct journal_head *jh)
1562{
1563 jbd_lock_bh_state(jh2bh(jh));
1564 spin_lock(&journal->j_list_lock);
1565 __journal_unfile_buffer(jh);
1566 spin_unlock(&journal->j_list_lock);
1567 jbd_unlock_bh_state(jh2bh(jh));
1568}
1569
1570/*
1571 * Called from journal_try_to_free_buffers().
1572 *
1573 * Called under jbd_lock_bh_state(bh)
1574 */
1575static void
1576__journal_try_to_free_buffer(journal_t *journal, struct buffer_head *bh)
1577{
1578 struct journal_head *jh;
1579
1580 jh = bh2jh(bh);
1581
1582 if (buffer_locked(bh) || buffer_dirty(bh))
1583 goto out;
1584
1585 if (jh->b_next_transaction != 0)
1586 goto out;
1587
1588 spin_lock(&journal->j_list_lock);
1589 if (jh->b_transaction != 0 && jh->b_cp_transaction == 0) {
1590 if (jh->b_jlist == BJ_SyncData || jh->b_jlist == BJ_Locked) {
1591 /* A written-back ordered data buffer */
1592 JBUFFER_TRACE(jh, "release data");
1593 __journal_unfile_buffer(jh);
1594 journal_remove_journal_head(bh);
1595 __brelse(bh);
1596 }
1597 } else if (jh->b_cp_transaction != 0 && jh->b_transaction == 0) {
1598 /* written-back checkpointed metadata buffer */
1599 if (jh->b_jlist == BJ_None) {
1600 JBUFFER_TRACE(jh, "remove from checkpoint list");
1601 __journal_remove_checkpoint(jh);
1602 journal_remove_journal_head(bh);
1603 __brelse(bh);
1604 }
1605 }
1606 spin_unlock(&journal->j_list_lock);
1607out:
1608 return;
1609}
1610
1611
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001612/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613 * int journal_try_to_free_buffers() - try to free page buffers.
1614 * @journal: journal for operation
1615 * @page: to try and free
1616 * @unused_gfp_mask: unused
1617 *
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001618 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 * For all the buffers on this page,
1620 * if they are fully written out ordered data, move them onto BUF_CLEAN
1621 * so try_to_free_buffers() can reap them.
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001622 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 * This function returns non-zero if we wish try_to_free_buffers()
1624 * to be called. We do this if the page is releasable by try_to_free_buffers().
1625 * We also do it if the page has locked or dirty buffers and the caller wants
1626 * us to perform sync or async writeout.
1627 *
1628 * This complicates JBD locking somewhat. We aren't protected by the
1629 * BKL here. We wish to remove the buffer from its committing or
1630 * running transaction's ->t_datalist via __journal_unfile_buffer.
1631 *
1632 * This may *change* the value of transaction_t->t_datalist, so anyone
1633 * who looks at t_datalist needs to lock against this function.
1634 *
1635 * Even worse, someone may be doing a journal_dirty_data on this
1636 * buffer. So we need to lock against that. journal_dirty_data()
1637 * will come out of the lock with the buffer dirty, which makes it
1638 * ineligible for release here.
1639 *
1640 * Who else is affected by this? hmm... Really the only contender
1641 * is do_get_write_access() - it could be looking at the buffer while
1642 * journal_try_to_free_buffer() is changing its state. But that
1643 * cannot happen because we never reallocate freed data as metadata
1644 * while the data is part of a transaction. Yes?
1645 */
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001646int journal_try_to_free_buffers(journal_t *journal,
Al Viro27496a82005-10-21 03:20:48 -04001647 struct page *page, gfp_t unused_gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648{
1649 struct buffer_head *head;
1650 struct buffer_head *bh;
1651 int ret = 0;
1652
1653 J_ASSERT(PageLocked(page));
1654
1655 head = page_buffers(page);
1656 bh = head;
1657 do {
1658 struct journal_head *jh;
1659
1660 /*
1661 * We take our own ref against the journal_head here to avoid
1662 * having to add tons of locking around each instance of
1663 * journal_remove_journal_head() and journal_put_journal_head().
1664 */
1665 jh = journal_grab_journal_head(bh);
1666 if (!jh)
1667 continue;
1668
1669 jbd_lock_bh_state(bh);
1670 __journal_try_to_free_buffer(journal, bh);
1671 journal_put_journal_head(jh);
1672 jbd_unlock_bh_state(bh);
1673 if (buffer_jbd(bh))
1674 goto busy;
1675 } while ((bh = bh->b_this_page) != head);
1676 ret = try_to_free_buffers(page);
1677busy:
1678 return ret;
1679}
1680
1681/*
1682 * This buffer is no longer needed. If it is on an older transaction's
1683 * checkpoint list we need to record it on this transaction's forget list
1684 * to pin this buffer (and hence its checkpointing transaction) down until
1685 * this transaction commits. If the buffer isn't on a checkpoint list, we
1686 * release it.
1687 * Returns non-zero if JBD no longer has an interest in the buffer.
1688 *
1689 * Called under j_list_lock.
1690 *
1691 * Called under jbd_lock_bh_state(bh).
1692 */
1693static int __dispose_buffer(struct journal_head *jh, transaction_t *transaction)
1694{
1695 int may_free = 1;
1696 struct buffer_head *bh = jh2bh(jh);
1697
1698 __journal_unfile_buffer(jh);
1699
1700 if (jh->b_cp_transaction) {
1701 JBUFFER_TRACE(jh, "on running+cp transaction");
1702 __journal_file_buffer(jh, transaction, BJ_Forget);
1703 clear_buffer_jbddirty(bh);
1704 may_free = 0;
1705 } else {
1706 JBUFFER_TRACE(jh, "on running transaction");
1707 journal_remove_journal_head(bh);
1708 __brelse(bh);
1709 }
1710 return may_free;
1711}
1712
1713/*
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001714 * journal_invalidatepage
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 *
1716 * This code is tricky. It has a number of cases to deal with.
1717 *
1718 * There are two invariants which this code relies on:
1719 *
1720 * i_size must be updated on disk before we start calling invalidatepage on the
1721 * data.
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001722 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 * This is done in ext3 by defining an ext3_setattr method which
1724 * updates i_size before truncate gets going. By maintaining this
1725 * invariant, we can be sure that it is safe to throw away any buffers
1726 * attached to the current transaction: once the transaction commits,
1727 * we know that the data will not be needed.
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001728 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 * Note however that we can *not* throw away data belonging to the
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001730 * previous, committing transaction!
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 *
1732 * Any disk blocks which *are* part of the previous, committing
1733 * transaction (and which therefore cannot be discarded immediately) are
1734 * not going to be reused in the new running transaction
1735 *
1736 * The bitmap committed_data images guarantee this: any block which is
1737 * allocated in one transaction and removed in the next will be marked
1738 * as in-use in the committed_data bitmap, so cannot be reused until
1739 * the next transaction to delete the block commits. This means that
1740 * leaving committing buffers dirty is quite safe: the disk blocks
1741 * cannot be reallocated to a different file and so buffer aliasing is
1742 * not possible.
1743 *
1744 *
1745 * The above applies mainly to ordered data mode. In writeback mode we
1746 * don't make guarantees about the order in which data hits disk --- in
1747 * particular we don't guarantee that new dirty data is flushed before
1748 * transaction commit --- so it is always safe just to discard data
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001749 * immediately in that mode. --sct
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 */
1751
1752/*
1753 * The journal_unmap_buffer helper function returns zero if the buffer
1754 * concerned remains pinned as an anonymous buffer belonging to an older
1755 * transaction.
1756 *
1757 * We're outside-transaction here. Either or both of j_running_transaction
1758 * and j_committing_transaction may be NULL.
1759 */
1760static int journal_unmap_buffer(journal_t *journal, struct buffer_head *bh)
1761{
1762 transaction_t *transaction;
1763 struct journal_head *jh;
1764 int may_free = 1;
1765 int ret;
1766
1767 BUFFER_TRACE(bh, "entry");
1768
1769 /*
1770 * It is safe to proceed here without the j_list_lock because the
1771 * buffers cannot be stolen by try_to_free_buffers as long as we are
1772 * holding the page lock. --sct
1773 */
1774
1775 if (!buffer_jbd(bh))
1776 goto zap_buffer_unlocked;
1777
1778 spin_lock(&journal->j_state_lock);
1779 jbd_lock_bh_state(bh);
1780 spin_lock(&journal->j_list_lock);
1781
1782 jh = journal_grab_journal_head(bh);
1783 if (!jh)
1784 goto zap_buffer_no_jh;
1785
1786 transaction = jh->b_transaction;
1787 if (transaction == NULL) {
1788 /* First case: not on any transaction. If it
1789 * has no checkpoint link, then we can zap it:
1790 * it's a writeback-mode buffer so we don't care
1791 * if it hits disk safely. */
1792 if (!jh->b_cp_transaction) {
1793 JBUFFER_TRACE(jh, "not on any transaction: zap");
1794 goto zap_buffer;
1795 }
1796
1797 if (!buffer_dirty(bh)) {
1798 /* bdflush has written it. We can drop it now */
1799 goto zap_buffer;
1800 }
1801
1802 /* OK, it must be in the journal but still not
1803 * written fully to disk: it's metadata or
1804 * journaled data... */
1805
1806 if (journal->j_running_transaction) {
1807 /* ... and once the current transaction has
1808 * committed, the buffer won't be needed any
1809 * longer. */
1810 JBUFFER_TRACE(jh, "checkpointed: add to BJ_Forget");
1811 ret = __dispose_buffer(jh,
1812 journal->j_running_transaction);
1813 journal_put_journal_head(jh);
1814 spin_unlock(&journal->j_list_lock);
1815 jbd_unlock_bh_state(bh);
1816 spin_unlock(&journal->j_state_lock);
1817 return ret;
1818 } else {
1819 /* There is no currently-running transaction. So the
1820 * orphan record which we wrote for this file must have
1821 * passed into commit. We must attach this buffer to
1822 * the committing transaction, if it exists. */
1823 if (journal->j_committing_transaction) {
1824 JBUFFER_TRACE(jh, "give to committing trans");
1825 ret = __dispose_buffer(jh,
1826 journal->j_committing_transaction);
1827 journal_put_journal_head(jh);
1828 spin_unlock(&journal->j_list_lock);
1829 jbd_unlock_bh_state(bh);
1830 spin_unlock(&journal->j_state_lock);
1831 return ret;
1832 } else {
1833 /* The orphan record's transaction has
1834 * committed. We can cleanse this buffer */
1835 clear_buffer_jbddirty(bh);
1836 goto zap_buffer;
1837 }
1838 }
1839 } else if (transaction == journal->j_committing_transaction) {
Eric Sandeenf58a74d2006-10-28 10:38:27 -07001840 JBUFFER_TRACE(jh, "on committing transaction");
akpm@osdl.orgd13df842005-04-16 15:26:36 -07001841 if (jh->b_jlist == BJ_Locked) {
1842 /*
1843 * The buffer is on the committing transaction's locked
1844 * list. We have the buffer locked, so I/O has
1845 * completed. So we can nail the buffer now.
1846 */
1847 may_free = __dispose_buffer(jh, transaction);
1848 goto zap_buffer;
1849 }
1850 /*
1851 * If it is committing, we simply cannot touch it. We
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852 * can remove it's next_transaction pointer from the
1853 * running transaction if that is set, but nothing
1854 * else. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855 set_buffer_freed(bh);
1856 if (jh->b_next_transaction) {
1857 J_ASSERT(jh->b_next_transaction ==
1858 journal->j_running_transaction);
1859 jh->b_next_transaction = NULL;
1860 }
1861 journal_put_journal_head(jh);
1862 spin_unlock(&journal->j_list_lock);
1863 jbd_unlock_bh_state(bh);
1864 spin_unlock(&journal->j_state_lock);
1865 return 0;
1866 } else {
1867 /* Good, the buffer belongs to the running transaction.
1868 * We are writing our own transaction's data, not any
1869 * previous one's, so it is safe to throw it away
1870 * (remember that we expect the filesystem to have set
1871 * i_size already for this truncate so recovery will not
1872 * expose the disk blocks we are discarding here.) */
1873 J_ASSERT_JH(jh, transaction == journal->j_running_transaction);
Eric Sandeenf58a74d2006-10-28 10:38:27 -07001874 JBUFFER_TRACE(jh, "on running transaction");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 may_free = __dispose_buffer(jh, transaction);
1876 }
1877
1878zap_buffer:
1879 journal_put_journal_head(jh);
1880zap_buffer_no_jh:
1881 spin_unlock(&journal->j_list_lock);
1882 jbd_unlock_bh_state(bh);
1883 spin_unlock(&journal->j_state_lock);
1884zap_buffer_unlocked:
1885 clear_buffer_dirty(bh);
1886 J_ASSERT_BH(bh, !buffer_jbddirty(bh));
1887 clear_buffer_mapped(bh);
1888 clear_buffer_req(bh);
1889 clear_buffer_new(bh);
1890 bh->b_bdev = NULL;
1891 return may_free;
1892}
1893
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001894/**
NeilBrown2ff28e22006-03-26 01:37:18 -08001895 * void journal_invalidatepage()
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001896 * @journal: journal to use for flush...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897 * @page: page to flush
1898 * @offset: length of page to invalidate.
1899 *
1900 * Reap page buffers containing data after offset in page.
1901 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 */
NeilBrown2ff28e22006-03-26 01:37:18 -08001903void journal_invalidatepage(journal_t *journal,
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001904 struct page *page,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905 unsigned long offset)
1906{
1907 struct buffer_head *head, *bh, *next;
1908 unsigned int curr_off = 0;
1909 int may_free = 1;
1910
1911 if (!PageLocked(page))
1912 BUG();
1913 if (!page_has_buffers(page))
NeilBrown2ff28e22006-03-26 01:37:18 -08001914 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915
1916 /* We will potentially be playing with lists other than just the
1917 * data lists (especially for journaled data mode), so be
1918 * cautious in our locking. */
1919
1920 head = bh = page_buffers(page);
1921 do {
1922 unsigned int next_off = curr_off + bh->b_size;
1923 next = bh->b_this_page;
1924
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 if (offset <= curr_off) {
Dave Kleikampe9ad5622006-09-27 01:49:35 -07001926 /* This block is wholly outside the truncation point */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927 lock_buffer(bh);
1928 may_free &= journal_unmap_buffer(journal, bh);
1929 unlock_buffer(bh);
1930 }
1931 curr_off = next_off;
1932 bh = next;
1933
1934 } while (bh != head);
1935
1936 if (!offset) {
NeilBrown2ff28e22006-03-26 01:37:18 -08001937 if (may_free && try_to_free_buffers(page))
1938 J_ASSERT(!page_has_buffers(page));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940}
1941
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001942/*
1943 * File a buffer on the given transaction list.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944 */
1945void __journal_file_buffer(struct journal_head *jh,
1946 transaction_t *transaction, int jlist)
1947{
1948 struct journal_head **list = NULL;
1949 int was_dirty = 0;
1950 struct buffer_head *bh = jh2bh(jh);
1951
1952 J_ASSERT_JH(jh, jbd_is_locked_bh_state(bh));
1953 assert_spin_locked(&transaction->t_journal->j_list_lock);
1954
1955 J_ASSERT_JH(jh, jh->b_jlist < BJ_Types);
1956 J_ASSERT_JH(jh, jh->b_transaction == transaction ||
1957 jh->b_transaction == 0);
1958
1959 if (jh->b_transaction && jh->b_jlist == jlist)
1960 return;
1961
1962 /* The following list of buffer states needs to be consistent
1963 * with __jbd_unexpected_dirty_buffer()'s handling of dirty
1964 * state. */
1965
Mingming Caoae6ddcc2006-09-27 01:49:27 -07001966 if (jlist == BJ_Metadata || jlist == BJ_Reserved ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967 jlist == BJ_Shadow || jlist == BJ_Forget) {
1968 if (test_clear_buffer_dirty(bh) ||
1969 test_clear_buffer_jbddirty(bh))
1970 was_dirty = 1;
1971 }
1972
1973 if (jh->b_transaction)
1974 __journal_temp_unlink_buffer(jh);
1975 jh->b_transaction = transaction;
1976
1977 switch (jlist) {
1978 case BJ_None:
1979 J_ASSERT_JH(jh, !jh->b_committed_data);
1980 J_ASSERT_JH(jh, !jh->b_frozen_data);
1981 return;
1982 case BJ_SyncData:
1983 list = &transaction->t_sync_datalist;
1984 break;
1985 case BJ_Metadata:
1986 transaction->t_nr_buffers++;
1987 list = &transaction->t_buffers;
1988 break;
1989 case BJ_Forget:
1990 list = &transaction->t_forget;
1991 break;
1992 case BJ_IO:
1993 list = &transaction->t_iobuf_list;
1994 break;
1995 case BJ_Shadow:
1996 list = &transaction->t_shadow_list;
1997 break;
1998 case BJ_LogCtl:
1999 list = &transaction->t_log_list;
2000 break;
2001 case BJ_Reserved:
2002 list = &transaction->t_reserved_list;
2003 break;
2004 case BJ_Locked:
2005 list = &transaction->t_locked_list;
2006 break;
2007 }
2008
2009 __blist_add_buffer(list, jh);
2010 jh->b_jlist = jlist;
2011
2012 if (was_dirty)
2013 set_buffer_jbddirty(bh);
2014}
2015
2016void journal_file_buffer(struct journal_head *jh,
2017 transaction_t *transaction, int jlist)
2018{
2019 jbd_lock_bh_state(jh2bh(jh));
2020 spin_lock(&transaction->t_journal->j_list_lock);
2021 __journal_file_buffer(jh, transaction, jlist);
2022 spin_unlock(&transaction->t_journal->j_list_lock);
2023 jbd_unlock_bh_state(jh2bh(jh));
2024}
2025
Mingming Caoae6ddcc2006-09-27 01:49:27 -07002026/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027 * Remove a buffer from its current buffer list in preparation for
2028 * dropping it from its current transaction entirely. If the buffer has
2029 * already started to be used by a subsequent transaction, refile the
2030 * buffer on that transaction's metadata list.
2031 *
2032 * Called under journal->j_list_lock
2033 *
2034 * Called under jbd_lock_bh_state(jh2bh(jh))
2035 */
2036void __journal_refile_buffer(struct journal_head *jh)
2037{
2038 int was_dirty;
2039 struct buffer_head *bh = jh2bh(jh);
2040
2041 J_ASSERT_JH(jh, jbd_is_locked_bh_state(bh));
2042 if (jh->b_transaction)
2043 assert_spin_locked(&jh->b_transaction->t_journal->j_list_lock);
2044
2045 /* If the buffer is now unused, just drop it. */
2046 if (jh->b_next_transaction == NULL) {
2047 __journal_unfile_buffer(jh);
2048 return;
2049 }
2050
2051 /*
2052 * It has been modified by a later transaction: add it to the new
2053 * transaction's metadata list.
2054 */
2055
2056 was_dirty = test_clear_buffer_jbddirty(bh);
2057 __journal_temp_unlink_buffer(jh);
2058 jh->b_transaction = jh->b_next_transaction;
2059 jh->b_next_transaction = NULL;
Jan Kara9ada7342006-06-23 02:05:25 -07002060 __journal_file_buffer(jh, jh->b_transaction,
2061 was_dirty ? BJ_Metadata : BJ_Reserved);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062 J_ASSERT_JH(jh, jh->b_transaction->t_state == T_RUNNING);
2063
2064 if (was_dirty)
2065 set_buffer_jbddirty(bh);
2066}
2067
2068/*
2069 * For the unlocked version of this call, also make sure that any
2070 * hanging journal_head is cleaned up if necessary.
2071 *
2072 * __journal_refile_buffer is usually called as part of a single locked
2073 * operation on a buffer_head, in which the caller is probably going to
2074 * be hooking the journal_head onto other lists. In that case it is up
2075 * to the caller to remove the journal_head if necessary. For the
2076 * unlocked journal_refile_buffer call, the caller isn't going to be
2077 * doing anything else to the buffer so we need to do the cleanup
Mingming Caoae6ddcc2006-09-27 01:49:27 -07002078 * ourselves to avoid a jh leak.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002079 *
2080 * *** The journal_head may be freed by this call! ***
2081 */
2082void journal_refile_buffer(journal_t *journal, struct journal_head *jh)
2083{
2084 struct buffer_head *bh = jh2bh(jh);
2085
2086 jbd_lock_bh_state(bh);
2087 spin_lock(&journal->j_list_lock);
2088
2089 __journal_refile_buffer(jh);
2090 jbd_unlock_bh_state(bh);
2091 journal_remove_journal_head(bh);
2092
2093 spin_unlock(&journal->j_list_lock);
2094 __brelse(bh);
2095}