Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0+
2 : /*
3 : * linux/fs/jbd2/checkpoint.c
4 : *
5 : * Written by Stephen C. Tweedie <sct@redhat.com>, 1999
6 : *
7 : * Copyright 1999 Red Hat Software --- All Rights Reserved
8 : *
9 : * Checkpoint routines for the generic filesystem journaling code.
10 : * Part of the ext2fs journaling system.
11 : *
12 : * Checkpointing is the process of ensuring that a section of the log is
13 : * committed fully to disk, so that that portion of the log can be
14 : * reused.
15 : */
16 :
17 : #include <linux/time.h>
18 : #include <linux/fs.h>
19 : #include <linux/jbd2.h>
20 : #include <linux/errno.h>
21 : #include <linux/slab.h>
22 : #include <linux/blkdev.h>
23 : #include <trace/events/jbd2.h>
24 :
25 : /*
26 : * Unlink a buffer from a transaction checkpoint list.
27 : *
28 : * Called with j_list_lock held.
29 : */
30 3184199 : static inline void __buffer_unlink(struct journal_head *jh)
31 : {
32 3184199 : transaction_t *transaction = jh->b_cp_transaction;
33 :
34 3184199 : jh->b_cpnext->b_cpprev = jh->b_cpprev;
35 3184199 : jh->b_cpprev->b_cpnext = jh->b_cpnext;
36 3184199 : if (transaction->t_checkpoint_list == jh) {
37 1799688 : transaction->t_checkpoint_list = jh->b_cpnext;
38 1799688 : if (transaction->t_checkpoint_list == jh)
39 200928 : transaction->t_checkpoint_list = NULL;
40 : }
41 3184199 : }
42 :
43 : /*
44 : * Check a checkpoint buffer could be release or not.
45 : *
46 : * Requires j_list_lock
47 : */
48 : static inline bool __cp_buffer_busy(struct journal_head *jh)
49 : {
50 : struct buffer_head *bh = jh2bh(jh);
51 :
52 : return (jh->b_transaction || buffer_locked(bh) || buffer_dirty(bh));
53 : }
54 :
55 : /*
56 : * __jbd2_log_wait_for_space: wait until there is space in the journal.
57 : *
58 : * Called under j-state_lock *only*. It will be unlocked if we have to wait
59 : * for a checkpoint to free up some space in the log.
60 : */
61 157204 : void __jbd2_log_wait_for_space(journal_t *journal)
62 : __acquires(&journal->j_state_lock)
63 : __releases(&journal->j_state_lock)
64 : {
65 157204 : int nblocks, space_left;
66 : /* assert_spin_locked(&journal->j_state_lock); */
67 :
68 157204 : nblocks = journal->j_max_transaction_buffers;
69 576078 : while (jbd2_log_space_left(journal) < nblocks) {
70 159638 : write_unlock(&journal->j_state_lock);
71 159627 : mutex_lock_io(&journal->j_checkpoint_mutex);
72 :
73 : /*
74 : * Test again, another process may have checkpointed while we
75 : * were waiting for the checkpoint lock. If there are no
76 : * transactions ready to be checkpointed, try to recover
77 : * journal space by calling cleanup_journal_tail(), and if
78 : * that doesn't work, by waiting for the currently committing
79 : * transaction to complete. If there is absolutely no way
80 : * to make progress, this is either a BUG or corrupted
81 : * filesystem, so abort the journal and leave a stack
82 : * trace for forensic evidence.
83 : */
84 159638 : write_lock(&journal->j_state_lock);
85 159638 : if (journal->j_flags & JBD2_ABORT) {
86 0 : mutex_unlock(&journal->j_checkpoint_mutex);
87 0 : return;
88 : }
89 159638 : spin_lock(&journal->j_list_lock);
90 159638 : space_left = jbd2_log_space_left(journal);
91 159638 : if (space_left < nblocks) {
92 25041 : int chkpt = journal->j_checkpoint_transactions != NULL;
93 25041 : tid_t tid = 0;
94 :
95 25041 : if (journal->j_committing_transaction)
96 24648 : tid = journal->j_committing_transaction->t_tid;
97 25041 : spin_unlock(&journal->j_list_lock);
98 25041 : write_unlock(&journal->j_state_lock);
99 25041 : if (chkpt) {
100 25040 : jbd2_log_do_checkpoint(journal);
101 1 : } else if (jbd2_cleanup_journal_tail(journal) == 0) {
102 : /* We were able to recover space; yay! */
103 : ;
104 0 : } else if (tid) {
105 : /*
106 : * jbd2_journal_commit_transaction() may want
107 : * to take the checkpoint_mutex if JBD2_FLUSHED
108 : * is set. So we need to temporarily drop it.
109 : */
110 0 : mutex_unlock(&journal->j_checkpoint_mutex);
111 0 : jbd2_log_wait_commit(journal, tid);
112 0 : write_lock(&journal->j_state_lock);
113 0 : continue;
114 : } else {
115 0 : printk(KERN_ERR "%s: needed %d blocks and "
116 : "only had %d space available\n",
117 : __func__, nblocks, space_left);
118 0 : printk(KERN_ERR "%s: no way to get more "
119 : "journal space in %s\n", __func__,
120 : journal->j_devname);
121 0 : WARN_ON(1);
122 0 : jbd2_journal_abort(journal, -EIO);
123 : }
124 25041 : write_lock(&journal->j_state_lock);
125 : } else {
126 134597 : spin_unlock(&journal->j_list_lock);
127 : }
128 159638 : mutex_unlock(&journal->j_checkpoint_mutex);
129 : }
130 : }
131 :
132 : static void
133 6212 : __flush_batch(journal_t *journal, int *batch_count)
134 : {
135 6212 : int i;
136 6212 : struct blk_plug plug;
137 :
138 6212 : blk_start_plug(&plug);
139 144421 : for (i = 0; i < *batch_count; i++)
140 131997 : write_dirty_buffer(journal->j_chkpt_bhs[i], REQ_SYNC);
141 6212 : blk_finish_plug(&plug);
142 :
143 144421 : for (i = 0; i < *batch_count; i++) {
144 131997 : struct buffer_head *bh = journal->j_chkpt_bhs[i];
145 131997 : BUFFER_TRACE(bh, "brelse");
146 131997 : __brelse(bh);
147 131997 : journal->j_chkpt_bhs[i] = NULL;
148 : }
149 6212 : *batch_count = 0;
150 6212 : }
151 :
152 : /*
153 : * Perform an actual checkpoint. We take the first transaction on the
154 : * list of transactions to be checkpointed and send all its buffers
155 : * to disk. We submit larger chunks of data at once.
156 : *
157 : * The journal should be locked before calling this function.
158 : * Called with j_checkpoint_mutex held.
159 : */
160 27926 : int jbd2_log_do_checkpoint(journal_t *journal)
161 : {
162 27926 : struct journal_head *jh;
163 27926 : struct buffer_head *bh;
164 27926 : transaction_t *transaction;
165 27926 : tid_t this_tid;
166 27926 : int result, batch_count = 0;
167 :
168 27926 : jbd2_debug(1, "Start checkpoint\n");
169 :
170 : /*
171 : * First thing: if there are any transactions in the log which
172 : * don't need checkpointing, just eliminate them from the
173 : * journal straight away.
174 : */
175 27926 : result = jbd2_cleanup_journal_tail(journal);
176 27926 : trace_jbd2_checkpoint(journal, result);
177 27926 : jbd2_debug(1, "cleanup_journal_tail returned %d\n", result);
178 27926 : if (result <= 0)
179 : return result;
180 :
181 : /*
182 : * OK, we need to start writing disk blocks. Take one transaction
183 : * and write it.
184 : */
185 27378 : spin_lock(&journal->j_list_lock);
186 27378 : if (!journal->j_checkpoint_transactions)
187 0 : goto out;
188 27378 : transaction = journal->j_checkpoint_transactions;
189 27378 : if (transaction->t_chp_stats.cs_chp_time == 0)
190 5684 : transaction->t_chp_stats.cs_chp_time = jiffies;
191 27378 : this_tid = transaction->t_tid;
192 : restart:
193 : /*
194 : * If someone cleaned up this transaction while we slept, we're
195 : * done (maybe it's a new transaction, but it fell at the same
196 : * address).
197 : */
198 64379 : if (journal->j_checkpoint_transactions != transaction ||
199 42667 : transaction->t_tid != this_tid)
200 21712 : goto out;
201 :
202 : /* checkpoint all of the transaction's buffers */
203 426967 : while (transaction->t_checkpoint_list) {
204 426967 : jh = transaction->t_checkpoint_list;
205 426967 : bh = jh2bh(jh);
206 :
207 426967 : if (jh->b_transaction != NULL) {
208 22073 : transaction_t *t = jh->b_transaction;
209 22073 : tid_t tid = t->t_tid;
210 :
211 22073 : transaction->t_chp_stats.cs_forced_to_close++;
212 22073 : spin_unlock(&journal->j_list_lock);
213 22073 : if (unlikely(journal->j_flags & JBD2_UNMOUNT))
214 : /*
215 : * The journal thread is dead; so
216 : * starting and waiting for a commit
217 : * to finish will cause us to wait for
218 : * a _very_ long time.
219 : */
220 0 : printk(KERN_ERR
221 : "JBD2: %s: Waiting for Godot: block %llu\n",
222 : journal->j_devname, (unsigned long long) bh->b_blocknr);
223 :
224 22073 : if (batch_count)
225 359 : __flush_batch(journal, &batch_count);
226 22073 : jbd2_log_start_commit(journal, tid);
227 : /*
228 : * jbd2_journal_commit_transaction() may want
229 : * to take the checkpoint_mutex if JBD2_FLUSHED
230 : * is set, jbd2_update_log_tail() called by
231 : * jbd2_journal_commit_transaction() may also take
232 : * checkpoint_mutex. So we need to temporarily
233 : * drop it.
234 : */
235 22073 : mutex_unlock(&journal->j_checkpoint_mutex);
236 22073 : jbd2_log_wait_commit(journal, tid);
237 22037 : mutex_lock_io(&journal->j_checkpoint_mutex);
238 22073 : spin_lock(&journal->j_list_lock);
239 22073 : goto restart;
240 : }
241 404894 : if (!trylock_buffer(bh)) {
242 : /*
243 : * The buffer is locked, it may be writing back, or
244 : * flushing out in the last couple of cycles, or
245 : * re-adding into a new transaction, need to check
246 : * it again until it's unlocked.
247 : */
248 8924 : get_bh(bh);
249 8924 : spin_unlock(&journal->j_list_lock);
250 8924 : wait_on_buffer(bh);
251 : /* the journal_head may have gone by now */
252 8924 : BUFFER_TRACE(bh, "brelse");
253 8924 : __brelse(bh);
254 8924 : goto retry;
255 791940 : } else if (!buffer_dirty(bh)) {
256 263973 : unlock_buffer(bh);
257 263973 : BUFFER_TRACE(bh, "remove from checkpoint");
258 : /*
259 : * If the transaction was released or the checkpoint
260 : * list was empty, we're done.
261 : */
262 263973 : if (__jbd2_journal_remove_checkpoint(jh) ||
263 258307 : !transaction->t_checkpoint_list)
264 5666 : goto out;
265 : } else {
266 131997 : unlock_buffer(bh);
267 : /*
268 : * We are about to write the buffer, it could be
269 : * raced by some other transaction shrink or buffer
270 : * re-log logic once we release the j_list_lock,
271 : * leave it on the checkpoint list and check status
272 : * again to make sure it's clean.
273 : */
274 131997 : BUFFER_TRACE(bh, "queue");
275 131997 : get_bh(bh);
276 263994 : J_ASSERT_BH(bh, !buffer_jwrite(bh));
277 131997 : journal->j_chkpt_bhs[batch_count++] = bh;
278 131997 : transaction->t_chp_stats.cs_written++;
279 131997 : transaction->t_checkpoint_list = jh->b_cpnext;
280 : }
281 :
282 390304 : if ((batch_count == JBD2_NR_BATCH) ||
283 389374 : need_resched() || spin_needbreak(&journal->j_list_lock) ||
284 387235 : jh2bh(transaction->t_checkpoint_list) == journal->j_chkpt_bhs[0])
285 6004 : goto unlock_and_flush;
286 : }
287 :
288 0 : if (batch_count) {
289 0 : unlock_and_flush:
290 6004 : spin_unlock(&journal->j_list_lock);
291 14928 : retry:
292 14928 : if (batch_count)
293 5853 : __flush_batch(journal, &batch_count);
294 14928 : spin_lock(&journal->j_list_lock);
295 14928 : goto restart;
296 : }
297 :
298 0 : out:
299 27378 : spin_unlock(&journal->j_list_lock);
300 27378 : result = jbd2_cleanup_journal_tail(journal);
301 :
302 27378 : return (result < 0) ? result : 0;
303 : }
304 :
305 : /*
306 : * Check the list of checkpoint transactions for the journal to see if
307 : * we have already got rid of any since the last update of the log tail
308 : * in the journal superblock. If so, we can instantly roll the
309 : * superblock forward to remove those transactions from the log.
310 : *
311 : * Return <0 on error, 0 on success, 1 if there was nothing to clean up.
312 : *
313 : * Called with the journal lock held.
314 : *
315 : * This is the only part of the journaling code which really needs to be
316 : * aware of transaction aborts. Checkpointing involves writing to the
317 : * main filesystem area rather than to the journal, so it can proceed
318 : * even in abort state, but we must not update the super block if
319 : * checkpointing may have failed. Otherwise, we would lose some metadata
320 : * buffers which should be written-back to the filesystem.
321 : */
322 :
323 55763 : int jbd2_cleanup_journal_tail(journal_t *journal)
324 : {
325 55763 : tid_t first_tid;
326 55763 : unsigned long blocknr;
327 :
328 55763 : if (is_journal_aborted(journal))
329 : return -EIO;
330 :
331 55649 : if (!jbd2_journal_get_log_tail(journal, &first_tid, &blocknr))
332 : return 1;
333 6119 : J_ASSERT(blocknr != 0);
334 :
335 : /*
336 : * We need to make sure that any blocks that were recently written out
337 : * --- perhaps by jbd2_log_do_checkpoint() --- are flushed out before
338 : * we drop the transactions from the journal. It's unlikely this will
339 : * be necessary, especially with an appropriately sized journal, but we
340 : * need this to guarantee correctness. Fortunately
341 : * jbd2_cleanup_journal_tail() doesn't get called all that often.
342 : */
343 6119 : if (journal->j_flags & JBD2_BARRIER)
344 6119 : blkdev_issue_flush(journal->j_fs_dev);
345 :
346 6119 : return __jbd2_update_log_tail(journal, first_tid, blocknr);
347 : }
348 :
349 :
350 : /* Checkpoint list management */
351 :
352 : /*
353 : * journal_shrink_one_cp_list
354 : *
355 : * Find all the written-back checkpoint buffers in the given list
356 : * and try to release them. If the whole transaction is released, set
357 : * the 'released' parameter. Return the number of released checkpointed
358 : * buffers.
359 : *
360 : * Called with j_list_lock held.
361 : */
362 239726 : static unsigned long journal_shrink_one_cp_list(struct journal_head *jh,
363 : bool destroy, bool *released)
364 : {
365 239726 : struct journal_head *last_jh;
366 239726 : struct journal_head *next_jh = jh;
367 239726 : unsigned long nr_freed = 0;
368 239726 : int ret;
369 :
370 239726 : *released = false;
371 239726 : if (!jh)
372 : return 0;
373 :
374 239726 : last_jh = jh->b_cpprev;
375 3125399 : do {
376 3125399 : jh = next_jh;
377 3125399 : next_jh = jh->b_cpnext;
378 :
379 3125399 : if (destroy) {
380 21564 : ret = __jbd2_journal_remove_checkpoint(jh);
381 : } else {
382 3103835 : ret = jbd2_journal_try_remove_checkpoint(jh);
383 3103836 : if (ret < 0)
384 1443410 : continue;
385 : }
386 :
387 1681989 : nr_freed++;
388 1681989 : if (ret) {
389 76484 : *released = true;
390 76484 : break;
391 : }
392 :
393 1605505 : if (need_resched())
394 : break;
395 3048895 : } while (jh != last_jh);
396 :
397 : return nr_freed;
398 : }
399 :
400 : /*
401 : * jbd2_journal_shrink_checkpoint_list
402 : *
403 : * Find 'nr_to_scan' written-back checkpoint buffers in the journal
404 : * and try to release them. Return the number of released checkpointed
405 : * buffers.
406 : *
407 : * Called with j_list_lock held.
408 : */
409 54 : unsigned long jbd2_journal_shrink_checkpoint_list(journal_t *journal,
410 : unsigned long *nr_to_scan)
411 : {
412 54 : transaction_t *transaction, *last_transaction, *next_transaction;
413 54 : bool __maybe_unused released;
414 54 : tid_t first_tid = 0, last_tid = 0, next_tid = 0;
415 54 : tid_t tid = 0;
416 54 : unsigned long nr_freed = 0;
417 54 : unsigned long freed;
418 :
419 54 : again:
420 54 : spin_lock(&journal->j_list_lock);
421 54 : if (!journal->j_checkpoint_transactions) {
422 39 : spin_unlock(&journal->j_list_lock);
423 39 : goto out;
424 : }
425 :
426 : /*
427 : * Get next shrink transaction, resume previous scan or start
428 : * over again. If some others do checkpoint and drop transaction
429 : * from the checkpoint list, we ignore saved j_shrink_transaction
430 : * and start over unconditionally.
431 : */
432 15 : if (journal->j_shrink_transaction)
433 : transaction = journal->j_shrink_transaction;
434 : else
435 10 : transaction = journal->j_checkpoint_transactions;
436 :
437 15 : if (!first_tid)
438 15 : first_tid = transaction->t_tid;
439 15 : last_transaction = journal->j_checkpoint_transactions->t_cpprev;
440 15 : next_transaction = transaction;
441 15 : last_tid = last_transaction->t_tid;
442 27 : do {
443 27 : transaction = next_transaction;
444 27 : next_transaction = transaction->t_cpnext;
445 27 : tid = transaction->t_tid;
446 :
447 27 : freed = journal_shrink_one_cp_list(transaction->t_checkpoint_list,
448 : false, &released);
449 27 : nr_freed += freed;
450 27 : (*nr_to_scan) -= min(*nr_to_scan, freed);
451 27 : if (*nr_to_scan == 0)
452 : break;
453 21 : if (need_resched() || spin_needbreak(&journal->j_list_lock))
454 : break;
455 21 : } while (transaction != last_transaction);
456 :
457 15 : if (transaction != last_transaction) {
458 5 : journal->j_shrink_transaction = next_transaction;
459 5 : next_tid = next_transaction->t_tid;
460 : } else {
461 10 : journal->j_shrink_transaction = NULL;
462 10 : next_tid = 0;
463 : }
464 :
465 15 : spin_unlock(&journal->j_list_lock);
466 15 : cond_resched();
467 :
468 15 : if (*nr_to_scan && next_tid)
469 0 : goto again;
470 15 : out:
471 54 : trace_jbd2_shrink_checkpoint_list(journal, first_tid, tid, last_tid,
472 : nr_freed, next_tid);
473 :
474 54 : return nr_freed;
475 : }
476 :
477 : /*
478 : * journal_clean_checkpoint_list
479 : *
480 : * Find all the written-back checkpoint buffers in the journal and release them.
481 : * If 'destroy' is set, release all buffers unconditionally.
482 : *
483 : * Called with j_list_lock held.
484 : */
485 202586 : void __jbd2_journal_clean_checkpoint_list(journal_t *journal, bool destroy)
486 : {
487 202586 : transaction_t *transaction, *last_transaction, *next_transaction;
488 202586 : bool released;
489 :
490 202586 : transaction = journal->j_checkpoint_transactions;
491 202586 : if (!transaction)
492 164955 : return;
493 :
494 200876 : last_transaction = transaction->t_cpprev;
495 200876 : next_transaction = transaction;
496 239698 : do {
497 239698 : transaction = next_transaction;
498 239698 : next_transaction = transaction->t_cpnext;
499 239698 : journal_shrink_one_cp_list(transaction->t_checkpoint_list,
500 : destroy, &released);
501 : /*
502 : * This function only frees up some memory if possible so we
503 : * dont have an obligation to finish processing. Bail out if
504 : * preemption requested:
505 : */
506 239699 : if (need_resched())
507 : return;
508 : /*
509 : * Stop scanning if we couldn't free the transaction. This
510 : * avoids pointless scanning of transactions which still
511 : * weren't checkpointed.
512 : */
513 239671 : if (!released)
514 : return;
515 76454 : } while (transaction != last_transaction);
516 : }
517 :
518 : /*
519 : * Remove buffers from all checkpoint lists as journal is aborted and we just
520 : * need to free memory
521 : */
522 118 : void jbd2_journal_destroy_checkpoint(journal_t *journal)
523 : {
524 : /*
525 : * We loop because __jbd2_journal_clean_checkpoint_list() may abort
526 : * early due to a need of rescheduling.
527 : */
528 117 : while (1) {
529 235 : spin_lock(&journal->j_list_lock);
530 235 : if (!journal->j_checkpoint_transactions) {
531 118 : spin_unlock(&journal->j_list_lock);
532 118 : break;
533 : }
534 117 : __jbd2_journal_clean_checkpoint_list(journal, true);
535 117 : spin_unlock(&journal->j_list_lock);
536 117 : cond_resched();
537 : }
538 118 : }
539 :
540 : /*
541 : * journal_remove_checkpoint: called after a buffer has been committed
542 : * to disk (either by being write-back flushed to disk, or being
543 : * committed to the log).
544 : *
545 : * We cannot safely clean a transaction out of the log until all of the
546 : * buffer updates committed in that transaction have safely been stored
547 : * elsewhere on disk. To achieve this, all of the buffers in a
548 : * transaction need to be maintained on the transaction's checkpoint
549 : * lists until they have been rewritten, at which point this function is
550 : * called to remove the buffer from the existing transaction's
551 : * checkpoint lists.
552 : *
553 : * The function returns 1 if it frees the transaction, 0 otherwise.
554 : * The function can free jh and bh.
555 : *
556 : * This function is called with j_list_lock held.
557 : */
558 3184199 : int __jbd2_journal_remove_checkpoint(struct journal_head *jh)
559 : {
560 3184199 : struct transaction_chp_stats_s *stats;
561 3184199 : transaction_t *transaction;
562 3184199 : journal_t *journal;
563 3184199 : struct buffer_head *bh = jh2bh(jh);
564 :
565 3184199 : JBUFFER_TRACE(jh, "entry");
566 :
567 3184199 : transaction = jh->b_cp_transaction;
568 3184199 : if (!transaction) {
569 : JBUFFER_TRACE(jh, "not on transaction");
570 : return 0;
571 : }
572 3184199 : journal = transaction->t_journal;
573 :
574 3184199 : JBUFFER_TRACE(jh, "removing from transaction");
575 :
576 : /*
577 : * If we have failed to write the buffer out to disk, the filesystem
578 : * may become inconsistent. We cannot abort the journal here since
579 : * we hold j_list_lock and we have to be careful about races with
580 : * jbd2_journal_destroy(). So mark the writeback IO error in the
581 : * journal here and we abort the journal later from a better context.
582 : */
583 6368398 : if (buffer_write_io_error(bh))
584 17 : set_bit(JBD2_CHECKPOINT_IO_ERROR, &journal->j_atomic_flags);
585 :
586 3184199 : __buffer_unlink(jh);
587 3184201 : jh->b_cp_transaction = NULL;
588 3184201 : percpu_counter_dec(&journal->j_checkpoint_jh_count);
589 3184203 : jbd2_journal_put_journal_head(jh);
590 :
591 : /* Is this transaction empty? */
592 3184202 : if (transaction->t_checkpoint_list)
593 : return 0;
594 :
595 : /*
596 : * There is one special case to worry about: if we have just pulled the
597 : * buffer off a running or committing transaction's checkpoing list,
598 : * then even if the checkpoint list is empty, the transaction obviously
599 : * cannot be dropped!
600 : *
601 : * The locking here around t_state is a bit sleazy.
602 : * See the comment at the end of jbd2_journal_commit_transaction().
603 : */
604 200928 : if (transaction->t_state != T_FINISHED)
605 : return 0;
606 :
607 : /*
608 : * OK, that was the last buffer for the transaction, we can now
609 : * safely remove this transaction from the log.
610 : */
611 200928 : stats = &transaction->t_chp_stats;
612 200928 : if (stats->cs_chp_time)
613 11368 : stats->cs_chp_time = jbd2_time_diff(stats->cs_chp_time,
614 : jiffies);
615 200928 : trace_jbd2_checkpoint_stats(journal->j_fs_dev->bd_dev,
616 : transaction->t_tid, stats);
617 :
618 200928 : __jbd2_journal_drop_transaction(journal, transaction);
619 200928 : jbd2_journal_free_transaction(transaction);
620 200928 : return 1;
621 : }
622 :
623 : /*
624 : * Check the checkpoint buffer and try to remove it from the checkpoint
625 : * list if it's clean. Returns -EBUSY if it is not clean, returns 1 if
626 : * it frees the transaction, 0 otherwise.
627 : *
628 : * This function is called with j_list_lock held.
629 : */
630 3191789 : int jbd2_journal_try_remove_checkpoint(struct journal_head *jh)
631 : {
632 3191789 : struct buffer_head *bh = jh2bh(jh);
633 :
634 3191789 : if (!trylock_buffer(bh))
635 : return -EBUSY;
636 6227166 : if (buffer_dirty(bh)) {
637 1452977 : unlock_buffer(bh);
638 1452977 : return -EBUSY;
639 : }
640 1660606 : unlock_buffer(bh);
641 :
642 : /*
643 : * Buffer is clean and the IO has finished (we held the buffer
644 : * lock) so the checkpoint is done. We can safely remove the
645 : * buffer from this transaction.
646 : */
647 1660608 : JBUFFER_TRACE(jh, "remove from checkpoint list");
648 1660608 : return __jbd2_journal_remove_checkpoint(jh);
649 : }
650 :
651 : /*
652 : * journal_insert_checkpoint: put a committed buffer onto a checkpoint
653 : * list so that we know when it is safe to clean the transaction out of
654 : * the log.
655 : *
656 : * Called with the journal locked.
657 : * Called with j_list_lock held.
658 : */
659 3184203 : void __jbd2_journal_insert_checkpoint(struct journal_head *jh,
660 : transaction_t *transaction)
661 : {
662 3184203 : JBUFFER_TRACE(jh, "entry");
663 9552609 : J_ASSERT_JH(jh, buffer_dirty(jh2bh(jh)) || buffer_jbddirty(jh2bh(jh)));
664 3184203 : J_ASSERT_JH(jh, jh->b_cp_transaction == NULL);
665 :
666 : /* Get reference for checkpointing transaction */
667 3184203 : jbd2_journal_grab_journal_head(jh2bh(jh));
668 3184203 : jh->b_cp_transaction = transaction;
669 :
670 3184203 : if (!transaction->t_checkpoint_list) {
671 200928 : jh->b_cpnext = jh->b_cpprev = jh;
672 : } else {
673 2983275 : jh->b_cpnext = transaction->t_checkpoint_list;
674 2983275 : jh->b_cpprev = transaction->t_checkpoint_list->b_cpprev;
675 2983275 : jh->b_cpprev->b_cpnext = jh;
676 2983275 : jh->b_cpnext->b_cpprev = jh;
677 : }
678 3184203 : transaction->t_checkpoint_list = jh;
679 3184203 : percpu_counter_inc(&transaction->t_journal->j_checkpoint_jh_count);
680 3184203 : }
681 :
682 : /*
683 : * We've finished with this transaction structure: adios...
684 : *
685 : * The transaction must have no links except for the checkpoint by this
686 : * point.
687 : *
688 : * Called with the journal locked.
689 : * Called with j_list_lock held.
690 : */
691 :
692 202470 : void __jbd2_journal_drop_transaction(journal_t *journal, transaction_t *transaction)
693 : {
694 202470 : assert_spin_locked(&journal->j_list_lock);
695 :
696 202470 : journal->j_shrink_transaction = NULL;
697 202470 : if (transaction->t_cpnext) {
698 202470 : transaction->t_cpnext->t_cpprev = transaction->t_cpprev;
699 202470 : transaction->t_cpprev->t_cpnext = transaction->t_cpnext;
700 202470 : if (journal->j_checkpoint_transactions == transaction)
701 82206 : journal->j_checkpoint_transactions =
702 : transaction->t_cpnext;
703 202470 : if (journal->j_checkpoint_transactions == transaction)
704 39228 : journal->j_checkpoint_transactions = NULL;
705 : }
706 :
707 202470 : J_ASSERT(transaction->t_state == T_FINISHED);
708 202470 : J_ASSERT(transaction->t_buffers == NULL);
709 202470 : J_ASSERT(transaction->t_forget == NULL);
710 202470 : J_ASSERT(transaction->t_shadow_list == NULL);
711 202470 : J_ASSERT(transaction->t_checkpoint_list == NULL);
712 202470 : J_ASSERT(atomic_read(&transaction->t_updates) == 0);
713 202470 : J_ASSERT(journal->j_committing_transaction != transaction);
714 202470 : J_ASSERT(journal->j_running_transaction != transaction);
715 :
716 202470 : trace_jbd2_drop_transaction(journal, transaction);
717 :
718 202470 : jbd2_debug(1, "Dropping transaction %d, all done\n", transaction->t_tid);
719 202470 : }
|
