User: | Jiri Slaby |
Error type: | Double Lock |
Error type description: | Some lock is locked twice unintentionally in a sequence |
File location: | fs/jbd2/checkpoint.c |
Line in file: | 426 |
Project: | Linux Kernel |
Project version: | 2.6.28 |
Tools: |
Stanse
(1.2)
Clang Static Analyzer (3.0) Smatch (1.59) |
Entered: | 2011-11-07 22:19:59 UTC |
1/* 2 * linux/fs/jbd2/checkpoint.c 3 * 4 * Written by Stephen C. Tweedie <sct@redhat.com>, 1999 5 * 6 * Copyright 1999 Red Hat Software --- 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 * Checkpoint routines for the generic filesystem journaling code. 13 * Part of the ext2fs journaling system. 14 * 15 * Checkpointing is the process of ensuring that a section of the log is 16 * committed fully to disk, so that that portion of the log can be 17 * reused. 18 */ 19 20#include <linux/time.h> 21#include <linux/fs.h> 22#include <linux/jbd2.h> 23#include <linux/marker.h> 24#include <linux/errno.h> 25#include <linux/slab.h> 26 27/* 28 * Unlink a buffer from a transaction checkpoint list. 29 * 30 * Called with j_list_lock held. 31 */ 32static inline void __buffer_unlink_first(struct journal_head *jh) 33{ 34 transaction_t *transaction = jh->b_cp_transaction; 35 36 jh->b_cpnext->b_cpprev = jh->b_cpprev; 37 jh->b_cpprev->b_cpnext = jh->b_cpnext; 38 if (transaction->t_checkpoint_list == jh) { 39 transaction->t_checkpoint_list = jh->b_cpnext; 40 if (transaction->t_checkpoint_list == jh) 41 transaction->t_checkpoint_list = NULL; 42 } 43} 44 45/* 46 * Unlink a buffer from a transaction checkpoint(io) list. 47 * 48 * Called with j_list_lock held. 49 */ 50static inline void __buffer_unlink(struct journal_head *jh) 51{ 52 transaction_t *transaction = jh->b_cp_transaction; 53 54 __buffer_unlink_first(jh); 55 if (transaction->t_checkpoint_io_list == jh) { 56 transaction->t_checkpoint_io_list = jh->b_cpnext; 57 if (transaction->t_checkpoint_io_list == jh) 58 transaction->t_checkpoint_io_list = NULL; 59 } 60} 61 62/* 63 * Move a buffer from the checkpoint list to the checkpoint io list 64 * 65 * Called with j_list_lock held 66 */ 67static inline void __buffer_relink_io(struct journal_head *jh) 68{ 69 transaction_t *transaction = jh->b_cp_transaction; 70 71 __buffer_unlink_first(jh); 72 73 if (!transaction->t_checkpoint_io_list) { 74 jh->b_cpnext = jh->b_cpprev = jh; 75 } else { 76 jh->b_cpnext = transaction->t_checkpoint_io_list; 77 jh->b_cpprev = transaction->t_checkpoint_io_list->b_cpprev; 78 jh->b_cpprev->b_cpnext = jh; 79 jh->b_cpnext->b_cpprev = jh; 80 } 81 transaction->t_checkpoint_io_list = jh; 82} 83 84/* 85 * Try to release a checkpointed buffer from its transaction. 86 * Returns 1 if we released it and 2 if we also released the 87 * whole transaction. 88 * 89 * Requires j_list_lock 90 * Called under jbd_lock_bh_state(jh2bh(jh)), and drops it 91 */ 92static int __try_to_free_cp_buf(struct journal_head *jh) 93{ 94 int ret = 0; 95 struct buffer_head *bh = jh2bh(jh); 96 97 if (jh->b_jlist == BJ_None && !buffer_locked(bh) && 98 !buffer_dirty(bh) && !buffer_write_io_error(bh)) { 99 JBUFFER_TRACE(jh, "remove from checkpoint list"); 100 ret = __jbd2_journal_remove_checkpoint(jh) + 1; 101 jbd_unlock_bh_state(bh); 102 jbd2_journal_remove_journal_head(bh); 103 BUFFER_TRACE(bh, "release"); 104 __brelse(bh); 105 } else { 106 jbd_unlock_bh_state(bh); 107 } 108 return ret; 109} 110 111/* 112 * __jbd2_log_wait_for_space: wait until there is space in the journal. 113 * 114 * Called under j-state_lock *only*. It will be unlocked if we have to wait 115 * for a checkpoint to free up some space in the log. 116 */ 117void __jbd2_log_wait_for_space(journal_t *journal) 118{ 119 int nblocks, space_left; 120 assert_spin_locked(&journal->j_state_lock); 121 122 nblocks = jbd_space_needed(journal); 123 while (__jbd2_log_space_left(journal) < nblocks) { 124 if (journal->j_flags & JBD2_ABORT) 125 return; 126 spin_unlock(&journal->j_state_lock); 127 mutex_lock(&journal->j_checkpoint_mutex); 128 129 /* 130 * Test again, another process may have checkpointed while we 131 * were waiting for the checkpoint lock. If there are no 132 * transactions ready to be checkpointed, try to recover 133 * journal space by calling cleanup_journal_tail(), and if 134 * that doesn't work, by waiting for the currently committing 135 * transaction to complete. If there is absolutely no way 136 * to make progress, this is either a BUG or corrupted 137 * filesystem, so abort the journal and leave a stack 138 * trace for forensic evidence. 139 */ 140 spin_lock(&journal->j_state_lock); 141 spin_lock(&journal->j_list_lock); 142 nblocks = jbd_space_needed(journal); 143 space_left = __jbd2_log_space_left(journal); 144 if (space_left < nblocks) { 145 int chkpt = journal->j_checkpoint_transactions != NULL; 146 tid_t tid = 0; 147 148 if (journal->j_committing_transaction) 149 tid = journal->j_committing_transaction->t_tid; 150 spin_unlock(&journal->j_list_lock); 151 spin_unlock(&journal->j_state_lock); 152 if (chkpt) { 153 jbd2_log_do_checkpoint(journal); 154 } else if (jbd2_cleanup_journal_tail(journal) == 0) { 155 /* We were able to recover space; yay! */ 156 ; 157 } else if (tid) { 158 jbd2_log_wait_commit(journal, tid); 159 } else { 160 printk(KERN_ERR "%s: needed %d blocks and " 161 "only had %d space available\n", 162 __func__, nblocks, space_left); 163 printk(KERN_ERR "%s: no way to get more " 164 "journal space in %s\n", __func__, 165 journal->j_devname); 166 WARN_ON(1); 167 jbd2_journal_abort(journal, 0); 168 } 169 spin_lock(&journal->j_state_lock); 170 } else { 171 spin_unlock(&journal->j_list_lock); 172 } 173 mutex_unlock(&journal->j_checkpoint_mutex); 174 } 175} 176 177/* 178 * We were unable to perform jbd_trylock_bh_state() inside j_list_lock. 179 * The caller must restart a list walk. Wait for someone else to run 180 * jbd_unlock_bh_state(). 181 */ 182static void jbd_sync_bh(journal_t *journal, struct buffer_head *bh) 183 __releases(journal->j_list_lock) 184{ 185 get_bh(bh); 186 spin_unlock(&journal->j_list_lock); 187 jbd_lock_bh_state(bh); 188 jbd_unlock_bh_state(bh); 189 put_bh(bh); 190} 191 192/* 193 * Clean up transaction's list of buffers submitted for io. 194 * We wait for any pending IO to complete and remove any clean 195 * buffers. Note that we take the buffers in the opposite ordering 196 * from the one in which they were submitted for IO. 197 * 198 * Return 0 on success, and return <0 if some buffers have failed 199 * to be written out. 200 * 201 * Called with j_list_lock held. 202 */ 203static int __wait_cp_io(journal_t *journal, transaction_t *transaction) 204{ 205 struct journal_head *jh; 206 struct buffer_head *bh; 207 tid_t this_tid; 208 int released = 0; 209 int ret = 0; 210 211 this_tid = transaction->t_tid; 212restart: 213 /* Did somebody clean up the transaction in the meanwhile? */ 214 if (journal->j_checkpoint_transactions != transaction || 215 transaction->t_tid != this_tid) 216 return ret; 217 while (!released && transaction->t_checkpoint_io_list) { 218 jh = transaction->t_checkpoint_io_list; 219 bh = jh2bh(jh); 220 if (!jbd_trylock_bh_state(bh)) { 221 jbd_sync_bh(journal, bh); 222 spin_lock(&journal->j_list_lock); 223 goto restart; 224 } 225 if (buffer_locked(bh)) { 226 atomic_inc(&bh->b_count); 227 spin_unlock(&journal->j_list_lock); 228 jbd_unlock_bh_state(bh); 229 wait_on_buffer(bh); 230 /* the journal_head may have gone by now */ 231 BUFFER_TRACE(bh, "brelse"); 232 __brelse(bh); 233 spin_lock(&journal->j_list_lock); 234 goto restart; 235 } 236 if (unlikely(buffer_write_io_error(bh))) 237 ret = -EIO; 238 239 /* 240 * Now in whatever state the buffer currently is, we know that 241 * it has been written out and so we can drop it from the list 242 */ 243 released = __jbd2_journal_remove_checkpoint(jh); 244 jbd_unlock_bh_state(bh); 245 jbd2_journal_remove_journal_head(bh); 246 __brelse(bh); 247 } 248 249 return ret; 250} 251 252#define NR_BATCH 64 253 254static void 255__flush_batch(journal_t *journal, struct buffer_head **bhs, int *batch_count) 256{ 257 int i; 258 259 ll_rw_block(SWRITE, *batch_count, bhs); 260 for (i = 0; i < *batch_count; i++) { 261 struct buffer_head *bh = bhs[i]; 262 clear_buffer_jwrite(bh); 263 BUFFER_TRACE(bh, "brelse"); 264 __brelse(bh); 265 } 266 *batch_count = 0; 267} 268 269/* 270 * Try to flush one buffer from the checkpoint list to disk. 271 * 272 * Return 1 if something happened which requires us to abort the current 273 * scan of the checkpoint list. Return <0 if the buffer has failed to 274 * be written out. 275 * 276 * Called with j_list_lock held and drops it if 1 is returned 277 * Called under jbd_lock_bh_state(jh2bh(jh)), and drops it 278 */ 279static int __process_buffer(journal_t *journal, struct journal_head *jh, 280 struct buffer_head **bhs, int *batch_count, 281 transaction_t *transaction) 282{ 283 struct buffer_head *bh = jh2bh(jh); 284 int ret = 0; 285 286 if (buffer_locked(bh)) { 287 atomic_inc(&bh->b_count); 288 spin_unlock(&journal->j_list_lock); 289 jbd_unlock_bh_state(bh); 290 wait_on_buffer(bh); 291 /* the journal_head may have gone by now */ 292 BUFFER_TRACE(bh, "brelse"); 293 __brelse(bh); 294 ret = 1; 295 } else if (jh->b_transaction != NULL) { 296 transaction_t *t = jh->b_transaction; 297 tid_t tid = t->t_tid; 298 299 transaction->t_chp_stats.cs_forced_to_close++; 300 spin_unlock(&journal->j_list_lock); 301 jbd_unlock_bh_state(bh); 302 jbd2_log_start_commit(journal, tid); 303 jbd2_log_wait_commit(journal, tid); 304 ret = 1; 305 } else if (!buffer_dirty(bh)) { 306 ret = 1; 307 if (unlikely(buffer_write_io_error(bh))) 308 ret = -EIO; 309 J_ASSERT_JH(jh, !buffer_jbddirty(bh)); 310 BUFFER_TRACE(bh, "remove from checkpoint"); 311 __jbd2_journal_remove_checkpoint(jh); 312 spin_unlock(&journal->j_list_lock); 313 jbd_unlock_bh_state(bh); 314 jbd2_journal_remove_journal_head(bh); 315 __brelse(bh); 316 } else { 317 /* 318 * Important: we are about to write the buffer, and 319 * possibly block, while still holding the journal lock. 320 * We cannot afford to let the transaction logic start 321 * messing around with this buffer before we write it to 322 * disk, as that would break recoverability. 323 */ 324 BUFFER_TRACE(bh, "queue"); 325 get_bh(bh); 326 J_ASSERT_BH(bh, !buffer_jwrite(bh)); 327 set_buffer_jwrite(bh); 328 bhs[*batch_count] = bh; 329 __buffer_relink_io(jh); 330 jbd_unlock_bh_state(bh); 331 transaction->t_chp_stats.cs_written++; 332 (*batch_count)++; 333 if (*batch_count == NR_BATCH) { 334 spin_unlock(&journal->j_list_lock); 335 __flush_batch(journal, bhs, batch_count); 336 ret = 1; 337 } 338 } 339 return ret; 340} 341 342/* 343 * Perform an actual checkpoint. We take the first transaction on the 344 * list of transactions to be checkpointed and send all its buffers 345 * to disk. We submit larger chunks of data at once. 346 * 347 * The journal should be locked before calling this function. 348 * Called with j_checkpoint_mutex held. 349 */ 350int jbd2_log_do_checkpoint(journal_t *journal) 351{ 352 transaction_t *transaction; 353 tid_t this_tid; 354 int result; 355 356 jbd_debug(1, "Start checkpoint\n"); 357 358 /* 359 * First thing: if there are any transactions in the log which 360 * don't need checkpointing, just eliminate them from the 361 * journal straight away. 362 */ 363 result = jbd2_cleanup_journal_tail(journal); 364 trace_mark(jbd2_checkpoint, "dev %s need_checkpoint %d", 365 journal->j_devname, result); 366 jbd_debug(1, "cleanup_journal_tail returned %d\n", result); 367 if (result <= 0) 368 return result; 369 370 /* 371 * OK, we need to start writing disk blocks. Take one transaction 372 * and write it. 373 */ 374 result = 0; 375 spin_lock(&journal->j_list_lock); 376 if (!journal->j_checkpoint_transactions) 377 goto out; 378 transaction = journal->j_checkpoint_transactions; 379 if (transaction->t_chp_stats.cs_chp_time == 0) 380 transaction->t_chp_stats.cs_chp_time = jiffies; 381 this_tid = transaction->t_tid; 382restart: 383 /* 384 * If someone cleaned up this transaction while we slept, we're 385 * done (maybe it's a new transaction, but it fell at the same 386 * address). 387 */ 388 if (journal->j_checkpoint_transactions == transaction && 389 transaction->t_tid == this_tid) { 390 int batch_count = 0; 391 struct buffer_head *bhs[NR_BATCH]; 392 struct journal_head *jh; 393 int retry = 0, err; 394 395 while (!retry && transaction->t_checkpoint_list) { 396 struct buffer_head *bh; 397 398 jh = transaction->t_checkpoint_list; 399 bh = jh2bh(jh); 400 if (!jbd_trylock_bh_state(bh)) { 401 jbd_sync_bh(journal, bh); 402 retry = 1; 403 break; 404 } 405 retry = __process_buffer(journal, jh, bhs, &batch_count, 406 transaction); 407 if (retry < 0 && !result) 408 result = retry; 409 if (!retry && (need_resched() || 410 spin_needbreak(&journal->j_list_lock))) { 411 spin_unlock(&journal->j_list_lock); 412 retry = 1; 413 break; 414 } 415 } 416 417 if (batch_count) { 418 if (!retry) { 419 spin_unlock(&journal->j_list_lock); 420 retry = 1; 421 } 422 __flush_batch(journal, bhs, &batch_count); 423 } 424 425 if (retry) { 426 spin_lock(&journal->j_list_lock); 427 goto restart; 428 } 429 /* 430 * Now we have cleaned up the first transaction's checkpoint 431 * list. Let's clean up the second one 432 */ 433 err = __wait_cp_io(journal, transaction); 434 if (!result) 435 result = err; 436 } 437out: 438 spin_unlock(&journal->j_list_lock); 439 if (result < 0) 440 jbd2_journal_abort(journal, result); 441 else 442 result = jbd2_cleanup_journal_tail(journal); 443 444 return (result < 0) ? result : 0; 445} 446 447/* 448 * Check the list of checkpoint transactions for the journal to see if 449 * we have already got rid of any since the last update of the log tail 450 * in the journal superblock. If so, we can instantly roll the 451 * superblock forward to remove those transactions from the log. 452 * 453 * Return <0 on error, 0 on success, 1 if there was nothing to clean up. 454 * 455 * Called with the journal lock held. 456 * 457 * This is the only part of the journaling code which really needs to be 458 * aware of transaction aborts. Checkpointing involves writing to the 459 * main filesystem area rather than to the journal, so it can proceed 460 * even in abort state, but we must not update the super block if 461 * checkpointing may have failed. Otherwise, we would lose some metadata 462 * buffers which should be written-back to the filesystem. 463 */ 464 465int jbd2_cleanup_journal_tail(journal_t *journal) 466{ 467 transaction_t * transaction; 468 tid_t first_tid; 469 unsigned long blocknr, freed; 470 471 if (is_journal_aborted(journal)) 472 return 1; 473 474 /* OK, work out the oldest transaction remaining in the log, and 475 * the log block it starts at. 476 * 477 * If the log is now empty, we need to work out which is the 478 * next transaction ID we will write, and where it will 479 * start. */ 480 481 spin_lock(&journal->j_state_lock); 482 spin_lock(&journal->j_list_lock); 483 transaction = journal->j_checkpoint_transactions; 484 if (transaction) { 485 first_tid = transaction->t_tid; 486 blocknr = transaction->t_log_start; 487 } else if ((transaction = journal->j_committing_transaction) != NULL) { 488 first_tid = transaction->t_tid; 489 blocknr = transaction->t_log_start; 490 } else if ((transaction = journal->j_running_transaction) != NULL) { 491 first_tid = transaction->t_tid; 492 blocknr = journal->j_head; 493 } else { 494 first_tid = journal->j_transaction_sequence; 495 blocknr = journal->j_head; 496 } 497 spin_unlock(&journal->j_list_lock); 498 J_ASSERT(blocknr != 0); 499 500 /* If the oldest pinned transaction is at the tail of the log 501 already then there's not much we can do right now. */ 502 if (journal->j_tail_sequence == first_tid) { 503 spin_unlock(&journal->j_state_lock); 504 return 1; 505 } 506 507 /* OK, update the superblock to recover the freed space. 508 * Physical blocks come first: have we wrapped beyond the end of 509 * the log? */ 510 freed = blocknr - journal->j_tail; 511 if (blocknr < journal->j_tail) 512 freed = freed + journal->j_last - journal->j_first; 513 514 jbd_debug(1, 515 "Cleaning journal tail from %d to %d (offset %lu), " 516 "freeing %lu\n", 517 journal->j_tail_sequence, first_tid, blocknr, freed); 518 519 journal->j_free += freed; 520 journal->j_tail_sequence = first_tid; 521 journal->j_tail = blocknr; 522 spin_unlock(&journal->j_state_lock); 523 if (!(journal->j_flags & JBD2_ABORT)) 524 jbd2_journal_update_superblock(journal, 1); 525 return 0; 526} 527 528 529/* Checkpoint list management */ 530 531/* 532 * journal_clean_one_cp_list 533 * 534 * Find all the written-back checkpoint buffers in the given list and release them. 535 * 536 * Called with the journal locked. 537 * Called with j_list_lock held. 538 * Returns number of bufers reaped (for debug) 539 */ 540 541static int journal_clean_one_cp_list(struct journal_head *jh, int *released) 542{ 543 struct journal_head *last_jh; 544 struct journal_head *next_jh = jh; 545 int ret, freed = 0; 546 547 *released = 0; 548 if (!jh) 549 return 0; 550 551 last_jh = jh->b_cpprev; 552 do { 553 jh = next_jh; 554 next_jh = jh->b_cpnext; 555 /* Use trylock because of the ranking */ 556 if (jbd_trylock_bh_state(jh2bh(jh))) { 557 ret = __try_to_free_cp_buf(jh); 558 if (ret) { 559 freed++; 560 if (ret == 2) { 561 *released = 1; 562 return freed; 563 } 564 } 565 } 566 /* 567 * This function only frees up some memory 568 * if possible so we dont have an obligation 569 * to finish processing. Bail out if preemption 570 * requested: 571 */ 572 if (need_resched()) 573 return freed; 574 } while (jh != last_jh); 575 576 return freed; 577} 578 579/* 580 * journal_clean_checkpoint_list 581 * 582 * Find all the written-back checkpoint buffers in the journal and release them. 583 * 584 * Called with the journal locked. 585 * Called with j_list_lock held. 586 * Returns number of buffers reaped (for debug) 587 */ 588 589int __jbd2_journal_clean_checkpoint_list(journal_t *journal) 590{ 591 transaction_t *transaction, *last_transaction, *next_transaction; 592 int ret = 0; 593 int released; 594 595 transaction = journal->j_checkpoint_transactions; 596 if (!transaction) 597 goto out; 598 599 last_transaction = transaction->t_cpprev; 600 next_transaction = transaction; 601 do { 602 transaction = next_transaction; 603 next_transaction = transaction->t_cpnext; 604 ret += journal_clean_one_cp_list(transaction-> 605 t_checkpoint_list, &released); 606 /* 607 * This function only frees up some memory if possible so we 608 * dont have an obligation to finish processing. Bail out if 609 * preemption requested: 610 */ 611 if (need_resched()) 612 goto out; 613 if (released) 614 continue; 615 /* 616 * It is essential that we are as careful as in the case of 617 * t_checkpoint_list with removing the buffer from the list as 618 * we can possibly see not yet submitted buffers on io_list 619 */ 620 ret += journal_clean_one_cp_list(transaction-> 621 t_checkpoint_io_list, &released); 622 if (need_resched()) 623 goto out; 624 } while (transaction != last_transaction); 625out: 626 return ret; 627} 628 629/* 630 * journal_remove_checkpoint: called after a buffer has been committed 631 * to disk (either by being write-back flushed to disk, or being 632 * committed to the log). 633 * 634 * We cannot safely clean a transaction out of the log until all of the 635 * buffer updates committed in that transaction have safely been stored 636 * elsewhere on disk. To achieve this, all of the buffers in a 637 * transaction need to be maintained on the transaction's checkpoint 638 * lists until they have been rewritten, at which point this function is 639 * called to remove the buffer from the existing transaction's 640 * checkpoint lists. 641 * 642 * The function returns 1 if it frees the transaction, 0 otherwise. 643 * 644 * This function is called with the journal locked. 645 * This function is called with j_list_lock held. 646 * This function is called with jbd_lock_bh_state(jh2bh(jh)) 647 */ 648 649int __jbd2_journal_remove_checkpoint(struct journal_head *jh) 650{ 651 transaction_t *transaction; 652 journal_t *journal; 653 int ret = 0; 654 655 JBUFFER_TRACE(jh, "entry"); 656 657 if ((transaction = jh->b_cp_transaction) == NULL) { 658 JBUFFER_TRACE(jh, "not on transaction"); 659 goto out; 660 } 661 journal = transaction->t_journal; 662 663 __buffer_unlink(jh); 664 jh->b_cp_transaction = NULL; 665 666 if (transaction->t_checkpoint_list != NULL || 667 transaction->t_checkpoint_io_list != NULL) 668 goto out; 669 JBUFFER_TRACE(jh, "transaction has no more buffers"); 670 671 /* 672 * There is one special case to worry about: if we have just pulled the 673 * buffer off a running or committing transaction's checkpoing list, 674 * then even if the checkpoint list is empty, the transaction obviously 675 * cannot be dropped! 676 * 677 * The locking here around t_state is a bit sleazy. 678 * See the comment at the end of jbd2_journal_commit_transaction(). 679 */ 680 if (transaction->t_state != T_FINISHED) { 681 JBUFFER_TRACE(jh, "belongs to running/committing transaction"); 682 goto out; 683 } 684 685 /* OK, that was the last buffer for the transaction: we can now 686 safely remove this transaction from the log */ 687 688 __jbd2_journal_drop_transaction(journal, transaction); 689 690 /* Just in case anybody was waiting for more transactions to be 691 checkpointed... */ 692 wake_up(&journal->j_wait_logspace); 693 ret = 1; 694out: 695 JBUFFER_TRACE(jh, "exit"); 696 return ret; 697} 698 699/* 700 * journal_insert_checkpoint: put a committed buffer onto a checkpoint 701 * list so that we know when it is safe to clean the transaction out of 702 * the log. 703 * 704 * Called with the journal locked. 705 * Called with j_list_lock held. 706 */ 707void __jbd2_journal_insert_checkpoint(struct journal_head *jh, 708 transaction_t *transaction) 709{ 710 JBUFFER_TRACE(jh, "entry"); 711 J_ASSERT_JH(jh, buffer_dirty(jh2bh(jh)) || buffer_jbddirty(jh2bh(jh))); 712 J_ASSERT_JH(jh, jh->b_cp_transaction == NULL); 713 714 jh->b_cp_transaction = transaction; 715 716 if (!transaction->t_checkpoint_list) { 717 jh->b_cpnext = jh->b_cpprev = jh; 718 } else { 719 jh->b_cpnext = transaction->t_checkpoint_list; 720 jh->b_cpprev = transaction->t_checkpoint_list->b_cpprev; 721 jh->b_cpprev->b_cpnext = jh; 722 jh->b_cpnext->b_cpprev = jh; 723 } 724 transaction->t_checkpoint_list = jh; 725} 726 727/* 728 * We've finished with this transaction structure: adios... 729 * 730 * The transaction must have no links except for the checkpoint by this 731 * point. 732 * 733 * Called with the journal locked. 734 * Called with j_list_lock held. 735 */ 736 737void __jbd2_journal_drop_transaction(journal_t *journal, transaction_t *transaction) 738{ 739 assert_spin_locked(&journal->j_list_lock); 740 if (transaction->t_cpnext) { 741 transaction->t_cpnext->t_cpprev = transaction->t_cpprev; 742 transaction->t_cpprev->t_cpnext = transaction->t_cpnext; 743 if (journal->j_checkpoint_transactions == transaction) 744 journal->j_checkpoint_transactions = 745 transaction->t_cpnext; 746 if (journal->j_checkpoint_transactions == transaction) 747 journal->j_checkpoint_transactions = NULL; 748 } 749 750 J_ASSERT(transaction->t_state == T_FINISHED); 751 J_ASSERT(transaction->t_buffers == NULL); 752 J_ASSERT(transaction->t_forget == NULL); 753 J_ASSERT(transaction->t_iobuf_list == NULL); 754 J_ASSERT(transaction->t_shadow_list == NULL); 755 J_ASSERT(transaction->t_log_list == NULL); 756 J_ASSERT(transaction->t_checkpoint_list == NULL); 757 J_ASSERT(transaction->t_checkpoint_io_list == NULL); 758 J_ASSERT(transaction->t_updates == 0); 759 J_ASSERT(journal->j_committing_transaction != transaction); 760 J_ASSERT(journal->j_running_transaction != transaction); 761 762 jbd_debug(1, "Dropping transaction %d, all done\n", transaction->t_tid); 763 kfree(transaction); 764}