1 /* 2 * linux/fs/jbd2/transaction.c 3 * 4 * Written by Stephen C. Tweedie <sct@redhat.com>, 1998 5 * 6 * Copyright 1998 Red Hat corp --- All Rights Reserved 7 * 8 * This file is part of the Linux kernel and is made available under 9 * the terms of the GNU General Public License, version 2, or at your 10 * option, any later version, incorporated herein by reference. 11 * 12 * Generic filesystem transaction handling code; part of the ext2fs 13 * journaling system. 14 * 15 * This file manages transactions (compound commits managed by the 16 * journaling code) and handles (individual atomic operations by the 17 * filesystem). 18 */ 19 20 #include <linux/time.h> 21 #include <linux/fs.h> 22 #include <linux/jbd2.h> 23 #include <linux/errno.h> 24 #include <linux/slab.h> 25 #include <linux/timer.h> 26 #include <linux/mm.h> 27 #include <linux/highmem.h> 28 29 static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh); 30 31 /* 32 * jbd2_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 47 static transaction_t * 48 jbd2_get_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. */ 57 journal->j_commit_timer.expires = transaction->t_expires; 58 add_timer(&journal->j_commit_timer); 59 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 78 * transaction's buffer credits. 79 */ 80 81 static 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 97 alloc_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 110 repeat: 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); 117 repeat_locked: 118 if (is_journal_aborted(journal) || 119 (journal->j_errno != 0 && !(journal->j_flags & JBD2_ACK_ERR))) { 120 spin_unlock(&journal->j_state_lock); 121 ret = -EROFS; 122 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 jbd2_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 __jbd2_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 186 /* 187 * 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 195 * in the new transaction. 196 * 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 * jbd2_journal_extend(). 210 */ 211 if (__jbd2_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 __jbd2_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 __jbd2_log_space_left(journal)); 228 spin_unlock(&transaction->t_handle_lock); 229 spin_unlock(&journal->j_state_lock); 230 out: 231 if (unlikely(new_transaction)) /* It's usually NULL */ 232 kfree(new_transaction); 233 return ret; 234 } 235 236 /* Allocate a new handle. This should probably be in a slab... */ 237 static 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 /** 250 * handle_t *jbd2_journal_start() - Obtain a new handle. 251 * @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 256 * that much space. 257 * 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 */ 263 handle_t *jbd2_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 jbd2_journal_extend() - extend buffer credits. 294 * @handle: handle to 'extend' 295 * @nblocks: nr blocks to try to extend by. 296 * 297 * 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 300 * extend its credit if it needs more. 301 * 302 * jbd2_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 */ 312 int jbd2_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 > __jbd2_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); 354 unlock: 355 spin_unlock(&transaction->t_handle_lock); 356 error_out: 357 spin_unlock(&journal->j_state_lock); 358 out: 359 return result; 360 } 361 362 363 /** 364 * int jbd2_journal_restart() - restart a handle . 365 * @handle: handle to restart 366 * @nblocks: nr credits requested 367 * 368 * Restart a handle for a multi-transaction filesystem 369 * operation. 370 * 371 * If the jbd2_journal_extend() call above fails to grant new buffer credits 372 * to a running handle, a call to jbd2_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 378 int jbd2_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 __jbd2_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 jbd2_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 */ 425 void jbd2_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 jbd2_journal_lock_updates() calls 457 * to make sure that we serialise special journal-locked operations 458 * too. 459 */ 460 mutex_lock(&journal->j_barrier); 461 } 462 463 /** 464 * void jbd2_journal_unlock_updates (journal_t* journal) - release barrier 465 * @journal: Journal to release the barrier on. 466 * 467 * Release a transaction barrier obtained with jbd2_journal_lock_updates(). 468 * 469 * Should be called without the journal lock held. 470 */ 471 void jbd2_journal_unlock_updates (journal_t *journal) 472 { 473 J_ASSERT(journal->j_barrier_count != 0); 474 475 mutex_unlock(&journal->j_barrier); 476 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 */ 492 static void jbd_unexpected_dirty_buffer(struct journal_head *jh) 493 { 494 int jlist; 495 496 /* 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; 502 503 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); 509 } 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 */ 522 static int 523 do_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"); 542 repeat: 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 551 * state. Is the buffer dirty? 552 * 553 * 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, 570 jh->b_transaction == transaction || 571 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); 576 } 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); 584 } 585 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 657 * list so won't be flushed. 658 * 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); 670 frozen_buffer = 671 jbd2_slab_alloc(jh2bh(jh)->b_size, 672 GFP_NOFS); 673 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 __jbd2_journal_file_buffer(jh, transaction, BJ_Reserved); 704 spin_unlock(&journal->j_list_lock); 705 } 706 707 done: 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 jbd2_journal_cancel_revoke(handle, jh); 728 729 out: 730 if (unlikely(frozen_buffer)) /* It's usually NULL */ 731 jbd2_slab_free(frozen_buffer, bh->b_size); 732 733 JBUFFER_TRACE(jh, "exit"); 734 return error; 735 } 736 737 /** 738 * int jbd2_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 749 int jbd2_journal_get_write_access(handle_t *handle, struct buffer_head *bh) 750 { 751 struct journal_head *jh = jbd2_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 jbd2_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 769 * the bh is not already part of an existing transaction. 770 * 771 * 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 jbd2_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 */ 782 int jbd2_journal_get_create_access(handle_t *handle, struct buffer_head *bh) 783 { 784 transaction_t *transaction = handle->h_transaction; 785 journal_t *journal = transaction->t_journal; 786 struct journal_head *jh = jbd2_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 __jbd2_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 jbd2_journal_cancel_revoke(handle, jh); 833 jbd2_journal_put_journal_head(jh); 834 out: 835 return err; 836 } 837 838 /** 839 * int jbd2_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. 851 * 852 * To deal with that, jbd2_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. 857 * 858 * 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 */ 865 int jbd2_journal_get_undo_access(handle_t *handle, struct buffer_head *bh) 866 { 867 int err; 868 struct journal_head *jh = jbd2_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 882 repeat: 883 if (!jh->b_committed_data) { 884 committed_data = jbd2_slab_alloc(jh2bh(jh)->b_size, GFP_NOFS); 885 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); 908 out: 909 jbd2_journal_put_journal_head(jh); 910 if (unlikely(committed_data)) 911 jbd2_slab_free(committed_data, bh->b_size); 912 return err; 913 } 914 915 /** 916 * int jbd2_journal_dirty_data() - mark a buffer as containing dirty data which 917 * needs to be flushed before we can commit the 918 * current transaction. 919 * @handle: transaction 920 * @bh: bufferhead to mark 921 * 922 * 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 * jbd2_journal_dirty_data() can be called via page_launder->ext3_writepage 928 * by kswapd. 929 */ 930 int jbd2_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 = jbd2_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? 950 * 951 * 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 954 * it, then reallocated it as data. 955 * 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 958 * being sure that the *previous* transaction has this same 959 * 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); 971 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 978 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 jbd2_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); 1039 /* Since we dropped the lock... */ 1040 if (!buffer_mapped(bh)) { 1041 JBUFFER_TRACE(jh, "buffer got unmapped"); 1042 goto no_journal; 1043 } 1044 /* 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 __jbd2_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 __jbd2_journal_temp_unlink_buffer(jh); 1071 jh->b_transaction = handle->h_transaction; 1072 JBUFFER_TRACE(jh, "file as data"); 1073 __jbd2_journal_file_buffer(jh, handle->h_transaction, 1074 BJ_SyncData); 1075 } 1076 } else { 1077 JBUFFER_TRACE(jh, "not on a transaction"); 1078 __jbd2_journal_file_buffer(jh, handle->h_transaction, BJ_SyncData); 1079 } 1080 no_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 jbd2_journal_put_journal_head(jh); 1089 return 0; 1090 } 1091 1092 /** 1093 * int jbd2_journal_dirty_metadata() - mark a buffer as containing dirty metadata 1094 * @handle: transaction to add buffer to. 1095 * @bh: buffer to mark 1096 * 1097 * 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 1101 * as belonging to the transaction. 1102 * 1103 * Returns error number or 0 on success. 1104 * 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 */ 1111 int jbd2_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 1151 /* 1152 * 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: 1155 * leave it alone for now. 1156 */ 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 __jbd2_journal_file_buffer(jh, handle->h_transaction, BJ_Metadata); 1173 spin_unlock(&journal->j_list_lock); 1174 out_unlock_bh: 1175 jbd_unlock_bh_state(bh); 1176 out: 1177 JBUFFER_TRACE(jh, "exit"); 1178 return 0; 1179 } 1180 1181 /* 1182 * jbd2_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 */ 1186 void 1187 jbd2_journal_release_buffer(handle_t *handle, struct buffer_head *bh) 1188 { 1189 BUFFER_TRACE(bh, "entry"); 1190 } 1191 1192 /** 1193 * void jbd2_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 1199 * can safely unlink it. 1200 * 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. 1205 * 1206 * Allow this call even if the handle has aborted --- it may be part of 1207 * the caller's cleanup after an abort. 1208 */ 1209 int jbd2_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 1253 /* 1254 * 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 1262 * we know to remove the checkpoint after we commit. 1263 */ 1264 1265 if (jh->b_cp_transaction) { 1266 __jbd2_journal_temp_unlink_buffer(jh); 1267 __jbd2_journal_file_buffer(jh, transaction, BJ_Forget); 1268 } else { 1269 __jbd2_journal_unfile_buffer(jh); 1270 jbd2_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) { 1280 J_ASSERT_JH(jh, (jh->b_transaction == 1281 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 1295 not_jbd: 1296 spin_unlock(&journal->j_list_lock); 1297 jbd_unlock_bh_state(bh); 1298 __brelse(bh); 1299 drop: 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 jbd2_journal_stop() - complete a transaction 1309 * @handle: tranaction to complete. 1310 * 1311 * 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 * jbd2_journal_stop itself will not usually return an error, but it may 1319 * do so in unusual circumstances. In particular, expect it to 1320 * return -EIO if a jbd2_journal_abort has been executed since the 1321 * transaction began. 1322 */ 1323 int jbd2_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; 1328 pid_t pid; 1329 1330 J_ASSERT(journal_current_handle() == handle); 1331 1332 if (is_handle_aborted(handle)) 1333 err = -EIO; 1334 else { 1335 J_ASSERT(transaction->t_updates > 0); 1336 err = 0; 1337 } 1338 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... 1355 * 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. 1360 */ 1361 pid = current->pid; 1362 if (handle->h_sync && journal->j_last_sync_writer != pid) { 1363 journal->j_last_sync_writer = pid; 1364 do { 1365 old_handle_count = transaction->t_handle_count; 1366 schedule_timeout_uninterruptible(1); 1367 } 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 || 1390 time_after_eq(jiffies, transaction->t_expires)) { 1391 /* 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 __jbd2_log_start_commit(journal, transaction->t_tid); 1401 spin_unlock(&journal->j_state_lock); 1402 1403 /* 1404 * Special case: JBD2_SYNC synchronous updates require us 1405 * to wait for the commit to complete. 1406 */ 1407 if (handle->h_sync && !(current->flags & PF_MEMALLOC)) 1408 err = jbd2_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 jbd2_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 */ 1425 int jbd2_journal_force_commit(journal_t *journal) 1426 { 1427 handle_t *handle; 1428 int ret; 1429 1430 handle = jbd2_journal_start(journal, 1); 1431 if (IS_ERR(handle)) { 1432 ret = PTR_ERR(handle); 1433 } else { 1434 handle->h_sync = 1; 1435 ret = jbd2_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 1456 static inline void 1457 __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 1471 /* 1472 * 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 1480 static 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 1492 /* 1493 * 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 */ 1503 void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh) 1504 { 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 1555 void __jbd2_journal_unfile_buffer(struct journal_head *jh) 1556 { 1557 __jbd2_journal_temp_unlink_buffer(jh); 1558 jh->b_transaction = NULL; 1559 } 1560 1561 void jbd2_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 __jbd2_journal_unfile_buffer(jh); 1566 spin_unlock(&journal->j_list_lock); 1567 jbd_unlock_bh_state(jh2bh(jh)); 1568 } 1569 1570 /* 1571 * Called from jbd2_journal_try_to_free_buffers(). 1572 * 1573 * Called under jbd_lock_bh_state(bh) 1574 */ 1575 static 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 __jbd2_journal_unfile_buffer(jh); 1594 jbd2_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 __jbd2_journal_remove_checkpoint(jh); 1602 jbd2_journal_remove_journal_head(bh); 1603 __brelse(bh); 1604 } 1605 } 1606 spin_unlock(&journal->j_list_lock); 1607 out: 1608 return; 1609 } 1610 1611 1612 /** 1613 * int jbd2_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 * 1618 * 1619 * 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. 1622 * 1623 * 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 __jbd2_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 jbd2_journal_dirty_data on this 1636 * buffer. So we need to lock against that. jbd2_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 */ 1646 int jbd2_journal_try_to_free_buffers(journal_t *journal, 1647 struct page *page, gfp_t unused_gfp_mask) 1648 { 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 * jbd2_journal_remove_journal_head() and jbd2_journal_put_journal_head(). 1664 */ 1665 jh = jbd2_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 jbd2_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); 1677 busy: 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 */ 1693 static 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 __jbd2_journal_unfile_buffer(jh); 1699 1700 if (jh->b_cp_transaction) { 1701 JBUFFER_TRACE(jh, "on running+cp transaction"); 1702 __jbd2_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 jbd2_journal_remove_journal_head(bh); 1708 __brelse(bh); 1709 } 1710 return may_free; 1711 } 1712 1713 /* 1714 * jbd2_journal_invalidatepage 1715 * 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. 1722 * 1723 * 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. 1728 * 1729 * Note however that we can *not* throw away data belonging to the 1730 * previous, committing transaction! 1731 * 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 1749 * immediately in that mode. --sct 1750 */ 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 */ 1760 static 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 = jbd2_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 jbd2_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 jbd2_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) { 1840 JBUFFER_TRACE(jh, "on committing transaction"); 1841 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 1852 * can remove it's next_transaction pointer from the 1853 * running transaction if that is set, but nothing 1854 * else. */ 1855 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 jbd2_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); 1874 JBUFFER_TRACE(jh, "on running transaction"); 1875 may_free = __dispose_buffer(jh, transaction); 1876 } 1877 1878 zap_buffer: 1879 jbd2_journal_put_journal_head(jh); 1880 zap_buffer_no_jh: 1881 spin_unlock(&journal->j_list_lock); 1882 jbd_unlock_bh_state(bh); 1883 spin_unlock(&journal->j_state_lock); 1884 zap_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 1894 /** 1895 * void jbd2_journal_invalidatepage() 1896 * @journal: journal to use for flush... 1897 * @page: page to flush 1898 * @offset: length of page to invalidate. 1899 * 1900 * Reap page buffers containing data after offset in page. 1901 * 1902 */ 1903 void jbd2_journal_invalidatepage(journal_t *journal, 1904 struct page *page, 1905 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)) 1914 return; 1915 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 1925 if (offset <= curr_off) { 1926 /* This block is wholly outside the truncation point */ 1927 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) { 1937 if (may_free && try_to_free_buffers(page)) 1938 J_ASSERT(!page_has_buffers(page)); 1939 } 1940 } 1941 1942 /* 1943 * File a buffer on the given transaction list. 1944 */ 1945 void __jbd2_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 1966 if (jlist == BJ_Metadata || jlist == BJ_Reserved || 1967 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 __jbd2_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 2016 void jbd2_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 __jbd2_journal_file_buffer(jh, transaction, jlist); 2022 spin_unlock(&transaction->t_journal->j_list_lock); 2023 jbd_unlock_bh_state(jh2bh(jh)); 2024 } 2025 2026 /* 2027 * 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 */ 2036 void __jbd2_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 __jbd2_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 __jbd2_journal_temp_unlink_buffer(jh); 2058 jh->b_transaction = jh->b_next_transaction; 2059 jh->b_next_transaction = NULL; 2060 __jbd2_journal_file_buffer(jh, jh->b_transaction, 2061 was_dirty ? BJ_Metadata : BJ_Reserved); 2062 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 * __jbd2_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 jbd2_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 2078 * ourselves to avoid a jh leak. 2079 * 2080 * *** The journal_head may be freed by this call! *** 2081 */ 2082 void jbd2_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 __jbd2_journal_refile_buffer(jh); 2090 jbd_unlock_bh_state(bh); 2091 jbd2_journal_remove_journal_head(bh); 2092 2093 spin_unlock(&journal->j_list_lock); 2094 __brelse(bh); 2095 } 2096