1/* 2 * linux/fs/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/errno.h> 23#include <linux/slab.h> 24#include <linux/timer.h> 25#include <linux/smp_lock.h> 26#include <linux/mm.h> 27#include <linux/highmem.h> 28#include "hfsplus_jbd.h" 29 30/* 31 * get_transaction: obtain a new hfsplus_transaction_t object. 32 * 33 * Simply allocate and initialise a new transaction. Create it in 34 * RUNNING state and add it to the current journal (which should not 35 * have an existing running transaction: we only make a new transaction 36 * once we have started to commit the old one). 37 * 38 * Preconditions: 39 * The journal MUST be locked. We don't perform atomic mallocs on the 40 * new transaction and we can't block without protecting against other 41 * processes trying to touch the journal while it is in transition. 42 * 43 * Called under j_state_lock 44 */ 45 46static hfsplus_transaction_t * 47get_transaction(hfsplus_jbd_t *journal, hfsplus_transaction_t *transaction) 48{ 49 transaction->t_journal = journal; 50 transaction->t_state = HFSPLUS_T_RUNNING; 51 transaction->t_tid = journal->j_transaction_sequence++; 52 transaction->t_expires = jiffies + journal->j_commit_interval; 53 spin_lock_init(&transaction->t_handle_lock); 54 55 /* Set up the commit timer for the new transaction. */ 56 journal->j_commit_timer->expires = transaction->t_expires; 57 add_timer(journal->j_commit_timer); 58 59 HFSPLUS_J_ASSERT(journal->j_running_transaction == NULL); 60 journal->j_running_transaction = transaction; 61 62 return transaction; 63} 64 65/* 66 * Handle management. 67 * 68 * A hfsplus_jbd_handle_t is an object which represents a single atomic update to a 69 * filesystem, and which tracks all of the modifications which form part 70 * of that one update. 71 */ 72 73/* 74 * start_this_handle: Given a handle, deal with any locking or stalling 75 * needed to make sure that there is enough journal space for the handle 76 * to begin. Attach the handle to a transaction and set up the 77 * transaction's buffer credits. 78 */ 79 80static int start_this_handle(hfsplus_jbd_t *journal, hfsplus_jbd_handle_t *handle) 81{ 82 hfsplus_transaction_t *transaction; 83 int needed; 84 int nblocks = handle->h_buffer_credits; 85 hfsplus_transaction_t *new_transaction = NULL; 86 int ret = 0; 87 88 if (nblocks > journal->j_max_transaction_buffers) { 89 printk(KERN_ERR "JBD: %s wants too many credits (%d > %d)\n", 90 current->comm, nblocks, 91 journal->j_max_transaction_buffers); 92 ret = -ENOSPC; 93 goto out; 94 } 95 96alloc_transaction: 97 if (!journal->j_running_transaction) { 98 new_transaction = hfsplus_jbd_kmalloc(sizeof(*new_transaction), 99 GFP_NOFS); 100 if (!new_transaction) { 101 ret = -ENOMEM; 102 goto out; 103 } 104 memset(new_transaction, 0, sizeof(*new_transaction)); 105 } 106 107 hfsplus_jbd_debug(3, "New handle %p going live.\n", handle); 108 109repeat: 110 111 /* 112 * We need to hold j_state_lock until t_updates has been incremented, 113 * for proper journal barrier handling 114 */ 115 spin_lock(&journal->j_state_lock); 116repeat_locked: 117 if (is_hfsplus_jbd_aborted(journal) || 118 (journal->j_errno != 0 && !(journal->j_flags & JFS_ACK_ERR))) { 119 spin_unlock(&journal->j_state_lock); 120 ret = -EROFS; 121 goto out; 122 } 123 124 /* Wait on the journal's transaction barrier if necessary */ 125 if (journal->j_barrier_count) { 126 spin_unlock(&journal->j_state_lock); 127 wait_event(journal->j_wait_transaction_locked, 128 journal->j_barrier_count == 0); 129 goto repeat; 130 } 131 132 if (!journal->j_running_transaction) { 133 if (!new_transaction) { 134 spin_unlock(&journal->j_state_lock); 135 goto alloc_transaction; 136 } 137 get_transaction(journal, new_transaction); 138 new_transaction = NULL; 139 } 140 141 transaction = journal->j_running_transaction; 142 143 /* 144 * If the current transaction is locked down for commit, wait for the 145 * lock to be released. 146 */ 147 if (transaction->t_state == HFSPLUS_T_LOCKED) { 148 DEFINE_WAIT(wait); 149 150 prepare_to_wait(&journal->j_wait_transaction_locked, 151 &wait, TASK_UNINTERRUPTIBLE); 152 spin_unlock(&journal->j_state_lock); 153 schedule(); 154 finish_wait(&journal->j_wait_transaction_locked, &wait); 155 goto repeat; 156 } 157 158 /* 159 * If there is not enough space left in the log to write all potential 160 * buffers requested by this operation, we need to stall pending a log 161 * checkpoint to free some more log space. 162 */ 163 spin_lock(&transaction->t_handle_lock); 164 needed = transaction->t_outstanding_credits + nblocks; 165 166 if (needed > journal->j_max_transaction_buffers) { 167 /* 168 * If the current transaction is already too large, then start 169 * to commit it: we can then go back and attach this handle to 170 * a new transaction. 171 */ 172 DEFINE_WAIT(wait); 173 174 hfsplus_jbd_debug(2, "Handle %p starting new commit...\n", handle); 175 spin_unlock(&transaction->t_handle_lock); 176 prepare_to_wait(&journal->j_wait_transaction_locked, &wait, 177 TASK_UNINTERRUPTIBLE); 178 __hfsplus__log_start_commit(journal, transaction->t_tid); 179 spin_unlock(&journal->j_state_lock); 180 schedule(); 181 finish_wait(&journal->j_wait_transaction_locked, &wait); 182 goto repeat; 183 } 184 185 /* 186 * The commit code assumes that it can get enough log space 187 * without forcing a checkpoint. This is *critical* for 188 * correctness: a checkpoint of a buffer which is also 189 * associated with a committing transaction creates a deadlock, 190 * so commit simply cannot force through checkpoints. 191 * 192 * We must therefore ensure the necessary space in the journal 193 * *before* starting to dirty potentially checkpointed buffers 194 * in the new transaction. 195 * 196 * The worst part is, any transaction currently committing can 197 * reduce the free space arbitrarily. Be careful to account for 198 * those buffers when checkpointing. 199 */ 200 201 /* 202 * @@@ AKPM: This seems rather over-defensive. We're giving commit 203 * a _lot_ of headroom: 1/4 of the journal plus the size of 204 * the committing transaction. Really, we only need to give it 205 * committing_transaction->t_outstanding_credits plus "enough" for 206 * the log control blocks. 207 * Also, this test is inconsitent with the matching one in 208 * hfsplus_jbd_extend(). 209 */ 210 if (__hfsplus__log_space_left(journal) < hfsplus_jbd_space_needed(journal)) { 211 hfsplus_jbd_debug(2, "Handle %p waiting for checkpoint...\n", handle); 212 spin_unlock(&transaction->t_handle_lock); 213 __hfsplus__log_wait_for_space(journal); 214 goto repeat_locked; 215 } 216 217 /* OK, account for the buffers that this operation expects to 218 * use and add the handle to the running transaction. */ 219 220 handle->h_transaction = transaction; 221 transaction->t_outstanding_credits += nblocks; 222 transaction->t_updates++; 223 transaction->t_handle_count++; 224 hfsplus_jbd_debug(4, "Handle %p given %d credits (total %d, free %d)\n", 225 handle, nblocks, transaction->t_outstanding_credits, 226 __hfsplus__log_space_left(journal)); 227 spin_unlock(&transaction->t_handle_lock); 228 spin_unlock(&journal->j_state_lock); 229out: 230 kfree(new_transaction); 231 return ret; 232} 233 234/* Allocate a new handle. This should probably be in a slab... */ 235static hfsplus_jbd_handle_t *new_handle(int nblocks) 236{ 237 hfsplus_jbd_handle_t *handle = hfsplus_jbd_alloc_handle(GFP_NOFS); 238 if (!handle) 239 return NULL; 240 memset(handle, 0, sizeof(*handle)); 241 handle->h_buffer_credits = nblocks; 242 handle->h_ref = 1; 243 244 return handle; 245} 246 247/** 248 * hfsplus_jbd_handle_t *hfsplus_jbd_start() - Obtain a new handle. 249 * @journal: Journal to start transaction on. 250 * @nblocks: number of block buffer we might modify 251 * 252 * We make sure that the transaction can guarantee at least nblocks of 253 * modified buffers in the log. We block until the log can guarantee 254 * that much space. 255 * 256 * This function is visible to journal users (like ext3fs), so is not 257 * called with the journal already locked. 258 * 259 * Return a pointer to a newly allocated handle, or NULL on failure 260 */ 261hfsplus_jbd_handle_t *hfsplus_jbd_start(hfsplus_jbd_t *journal, int nblocks, hfsplus_handle_t *hfsplus_handle) 262{ 263 hfsplus_handle_t *tmp_hfsplus_handle = hfsplus_jbd_current_handle(); 264 int err; 265 266 if (!journal) 267 return ERR_PTR(-EROFS); 268 269 if (tmp_hfsplus_handle) { 270 HFSPLUS_J_ASSERT(tmp_hfsplus_handle->handle->h_transaction->t_journal == journal); 271 tmp_hfsplus_handle->handle->h_ref++; 272 return tmp_hfsplus_handle->handle; 273 } 274 275 hfsplus_handle->handle = new_handle(nblocks); 276 if (!hfsplus_handle->handle) 277 return ERR_PTR(-ENOMEM); 278 279 current->journal_info = hfsplus_handle; 280 281 err = start_this_handle(journal, hfsplus_handle->handle); 282 if (err < 0) { 283 hfsplus_jbd_free_handle(hfsplus_handle->handle); 284 current->journal_info = NULL; 285 hfsplus_handle->handle = ERR_PTR(err); 286 } 287 return hfsplus_handle->handle; 288} 289 290/** 291 * int hfsplus_jbd_extend() - extend buffer credits. 292 * @handle: handle to 'extend' 293 * @nblocks: nr blocks to try to extend by. 294 * 295 * Some transactions, such as large extends and truncates, can be done 296 * atomically all at once or in several stages. The operation requests 297 * a credit for a number of buffer modications in advance, but can 298 * extend its credit if it needs more. 299 * 300 * hfsplus_jbd_extend tries to give the running handle more buffer credits. 301 * It does not guarantee that allocation - this is a best-effort only. 302 * The calling process MUST be able to deal cleanly with a failure to 303 * extend here. 304 * 305 * Return 0 on success, non-zero on failure. 306 * 307 * return code < 0 implies an error 308 * return code > 0 implies normal transaction-full status. 309 */ 310int hfsplus_jbd_extend(hfsplus_jbd_handle_t *handle, int nblocks) 311{ 312 hfsplus_transaction_t *transaction = handle->h_transaction; 313 hfsplus_jbd_t *journal = transaction->t_journal; 314 int result; 315 int wanted; 316 317 result = -EIO; 318 if (hfsplus_jbd_is_handle_aborted(handle)) 319 goto out; 320 321 result = 1; 322 323 spin_lock(&journal->j_state_lock); 324 325 /* Don't extend a locked-down transaction! */ 326 if (handle->h_transaction->t_state != HFSPLUS_T_RUNNING) { 327 hfsplus_jbd_debug(3, "denied handle %p %d blocks: " 328 "transaction not running\n", handle, nblocks); 329 goto error_out; 330 } 331 332 spin_lock(&transaction->t_handle_lock); 333 wanted = transaction->t_outstanding_credits + nblocks; 334 335 if (wanted > journal->j_max_transaction_buffers) { 336 hfsplus_jbd_debug(3, "denied handle %p %d blocks: " 337 "transaction too large\n", handle, nblocks); 338 goto unlock; 339 } 340 341 if (wanted > __hfsplus__log_space_left(journal)) { 342 hfsplus_jbd_debug(3, "denied handle %p %d blocks: " 343 "insufficient log space\n", handle, nblocks); 344 goto unlock; 345 } 346 347 handle->h_buffer_credits += nblocks; 348 transaction->t_outstanding_credits += nblocks; 349 result = 0; 350 351 hfsplus_jbd_debug(3, "extended handle %p by %d\n", handle, nblocks); 352unlock: 353 spin_unlock(&transaction->t_handle_lock); 354error_out: 355 spin_unlock(&journal->j_state_lock); 356out: 357 return result; 358} 359 360 361/** 362 * int hfsplus_jbd_restart() - restart a handle . 363 * @handle: handle to restart 364 * @nblocks: nr credits requested 365 * 366 * Restart a handle for a multi-transaction filesystem 367 * operation. 368 * 369 * If the hfsplus_jbd_extend() call above fails to grant new buffer credits 370 * to a running handle, a call to hfsplus_jbd_restart will commit the 371 * handle's transaction so far and reattach the handle to a new 372 * transaction capabable of guaranteeing the requested number of 373 * credits. 374 */ 375 376int hfsplus_jbd_restart(hfsplus_jbd_handle_t *handle, int nblocks) 377{ 378 hfsplus_transaction_t *transaction = handle->h_transaction; 379 hfsplus_jbd_t *journal = transaction->t_journal; 380 hfsplus_handle_t *hfsplus_handle; 381 int ret; 382 383 /* If we've had an abort of any type, don't even think about 384 * actually doing the restart! */ 385 if (hfsplus_jbd_is_handle_aborted(handle)) 386 return 0; 387 388 /* 389 * First unlink the handle from its current transaction, and start the 390 * commit on that. 391 */ 392 HFSPLUS_J_ASSERT(transaction->t_updates > 0); 393 hfsplus_handle = hfsplus_jbd_current_handle(); 394 HFSPLUS_J_ASSERT(hfsplus_handle->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 hfsplus_jbd_debug(2, "restarting handle %p\n", handle); 406 __hfsplus__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 hfsplus_jbd_lock_updates () - establish a transaction barrier. 417 * @journal: Journal to establish a barrier on. 418 * 419 * This locks out any further updates from being started, and blocks 420 * until all existing updates have completed, returning only once the 421 * journal is in a quiescent state with no updates running. 422 * 423 * The journal lock should not be held on entry. 424 */ 425void hfsplus_jbd_lock_updates(hfsplus_jbd_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 hfsplus_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 hfsplus_jbd_lock_updates() calls 457 * to make sure that we serialise special journal-locked operations 458 * too. 459 */ 460 down(&journal->j_barrier); 461} 462 463/** 464 * void hfsplus_jbd_unlock_updates (hfsplus_jbd_t* journal) - release barrier 465 * @journal: Journal to release the barrier on. 466 * 467 * Release a transaction barrier obtained with hfsplus_jbd_lock_updates(). 468 * 469 * Should be called without the journal lock held. 470 */ 471void hfsplus_jbd_unlock_updates (hfsplus_jbd_t *journal) 472{ 473 HFSPLUS_J_ASSERT(journal->j_barrier_count != 0); 474 475 up(&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 */ 492static void hfsplus_jbd_unexpected_dirty_buffer(struct hfsplus_jbd_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 == HFSPLUS_BJ_Metadata || jlist == HFSPLUS_BJ_Reserved || 504 jlist == HFSPLUS_BJ_Shadow || jlist == HFSPLUS_BJ_Forget) { 505 struct buffer_head *bh = hfsplus_jh2bh(jh); 506 507 if (test_clear_buffer_dirty(bh)) 508 set_buffer_hfsplus_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 */ 522static int 523do_get_write_access(hfsplus_jbd_handle_t *handle, struct hfsplus_jbd_head *jh, 524 int force_copy) 525{ 526 struct buffer_head *bh; 527 hfsplus_transaction_t *transaction; 528 hfsplus_jbd_t *journal; 529 int error; 530 char *frozen_buffer = NULL; 531 int need_copy = 0; 532 533 if (hfsplus_jbd_is_handle_aborted(handle)) 534 return -EROFS; 535 536 transaction = handle->h_transaction; 537 journal = transaction->t_journal; 538 539 hfsplus_jbd_debug(5, "buffer_head %p, force_copy %d\n", jh, force_copy); 540 541 HFSPLUS_JBUFFER_TRACE(jh, "entry"); 542repeat: 543 bh = hfsplus_jh2bh(jh); 544 545 /* @@@ Need to check for errors here at some point. */ 546 547 lock_buffer(bh); 548 hfsplus_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 HFSPLUS_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 HFSPLUS_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 HFSPLUS_JBUFFER_TRACE(jh, "Unexpected dirty buffer"); 583 hfsplus_jbd_unexpected_dirty_buffer(jh); 584 } 585 586 unlock_buffer(bh); 587 588 error = -EROFS; 589 if (hfsplus_jbd_is_handle_aborted(handle)) { 590 hfsplus_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 HFSPLUS_JBUFFER_TRACE(jh, "has frozen data"); 609 HFSPLUS_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 HFSPLUS_JBUFFER_TRACE(jh, "owned by older transaction"); 618 HFSPLUS_J_ASSERT_JH(jh, jh->b_next_transaction == NULL); 619 HFSPLUS_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 == HFSPLUS_BJ_Shadow) { 632 DEFINE_WAIT_BIT(wait, &bh->b_state, BH_HFSPLUS_Unshadow); 633 wait_queue_head_t *wqh; 634 635 wqh = bit_waitqueue(&bh->b_state, BH_HFSPLUS_Unshadow); 636 637 HFSPLUS_JBUFFER_TRACE(jh, "on shadow: sleep"); 638 hfsplus_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 != HFSPLUS_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 != HFSPLUS_BJ_Forget || force_copy) { 666 HFSPLUS_JBUFFER_TRACE(jh, "generate frozen data"); 667 if (!frozen_buffer) { 668 HFSPLUS_JBUFFER_TRACE(jh, "allocate memory for buffer"); 669 hfsplus_jbd_unlock_bh_state(bh); 670 frozen_buffer = hfsplus_jbd_kmalloc(hfsplus_jh2bh(jh)->b_size, 671 GFP_NOFS); 672 if (!frozen_buffer) { 673 printk(KERN_EMERG 674 "%s: OOM for frozen_buffer\n", 675 __FUNCTION__); 676 HFSPLUS_JBUFFER_TRACE(jh, "oom!"); 677 error = -ENOMEM; 678 hfsplus_jbd_lock_bh_state(bh); 679 goto done; 680 } 681 goto repeat; 682 } 683 jh->b_frozen_data = frozen_buffer; 684 frozen_buffer = NULL; 685 need_copy = 1; 686 } 687 jh->b_next_transaction = transaction; 688 } 689 690 691 /* 692 * Finally, if the buffer is not journaled right now, we need to make 693 * sure it doesn't get written to disk before the caller actually 694 * commits the new data 695 */ 696 if (!jh->b_transaction) { 697 HFSPLUS_JBUFFER_TRACE(jh, "no transaction"); 698 HFSPLUS_J_ASSERT_JH(jh, !jh->b_next_transaction); 699 jh->b_transaction = transaction; 700 HFSPLUS_JBUFFER_TRACE(jh, "file as HFSPLUS_BJ_Reserved"); 701 spin_lock(&journal->j_list_lock); 702 __hfsplus_jbd_file_buffer(jh, transaction, HFSPLUS_BJ_Reserved); 703 spin_unlock(&journal->j_list_lock); 704 } 705 706done: 707 if (need_copy) { 708 struct page *page; 709 int offset; 710 char *source; 711 712 HFSPLUS_J_EXPECT_JH(jh, buffer_uptodate(hfsplus_jh2bh(jh)), 713 "Possible IO failure.\n"); 714 page = hfsplus_jh2bh(jh)->b_page; 715 offset = ((unsigned long) hfsplus_jh2bh(jh)->b_data) & ~PAGE_MASK; 716 source = kmap_atomic(page, KM_USER0); 717 memcpy(jh->b_frozen_data, source+offset, hfsplus_jh2bh(jh)->b_size); 718 kunmap_atomic(source, KM_USER0); 719 } 720 hfsplus_jbd_unlock_bh_state(bh); 721 722 /* 723 * If we are about to journal a buffer, then any revoke pending on it is 724 * no longer valid 725 */ 726 hfsplus_jbd_cancel_revoke(handle, jh); 727 728out: 729 kfree(frozen_buffer); 730 731 HFSPLUS_JBUFFER_TRACE(jh, "exit"); 732 return error; 733} 734 735/** 736 * int hfsplus_jbd_get_write_access() - notify intent to modify a buffer for metadata (not data) update. 737 * @handle: transaction to add buffer modifications to 738 * @bh: bh to be used for metadata writes 739 * @credits: variable that will receive credits for the buffer 740 * 741 * Returns an error code or 0 on success. 742 * 743 * In full data journalling mode the buffer may be of type HFSPLUS_BJ_AsyncData, 744 * because we're write()ing a buffer which is also part of a shared mapping. 745 */ 746 747int hfsplus_jbd_get_write_access(hfsplus_jbd_handle_t *handle, struct buffer_head *bh) 748{ 749 struct hfsplus_jbd_head *jh = hfsplus_jbd_add_journal_head(bh); 750 int rc; 751 752 /* We do not want to get caught playing with fields which the 753 * log thread also manipulates. Make sure that the buffer 754 * completes any outstanding IO before proceeding. */ 755 rc = do_get_write_access(handle, jh, 0); 756 hfsplus_jbd_put_journal_head(jh); 757 return rc; 758} 759 760 761/* 762 * When the user wants to journal a newly created buffer_head 763 * (ie. getblk() returned a new buffer and we are going to populate it 764 * manually rather than reading off disk), then we need to keep the 765 * buffer_head locked until it has been completely filled with new 766 * data. In this case, we should be able to make the assertion that 767 * the bh is not already part of an existing transaction. 768 * 769 * The buffer should already be locked by the caller by this point. 770 * There is no lock ranking violation: it was a newly created, 771 * unlocked buffer beforehand. */ 772 773/** 774 * int hfsplus_jbd_get_create_access () - notify intent to use newly created bh 775 * @handle: transaction to new buffer to 776 * @bh: new buffer. 777 * 778 * Call this if you create a new bh. 779 */ 780int hfsplus_jbd_get_create_access(hfsplus_jbd_handle_t *handle, struct buffer_head *bh) 781{ 782 hfsplus_transaction_t *transaction = handle->h_transaction; 783 hfsplus_jbd_t *journal = transaction->t_journal; 784 struct hfsplus_jbd_head *jh = hfsplus_jbd_add_journal_head(bh); 785 int err; 786 787 hfsplus_jbd_debug(5, "hfsplus_jbd_head %p\n", jh); 788 err = -EROFS; 789 if (hfsplus_jbd_is_handle_aborted(handle)) 790 goto out; 791 err = 0; 792 793 HFSPLUS_JBUFFER_TRACE(jh, "entry"); 794 /* 795 * The buffer may already belong to this transaction due to pre-zeroing 796 * in the filesystem's new_block code. It may also be on the previous, 797 * committing transaction's lists, but it HAS to be in Forget state in 798 * that case: the transaction must have deleted the buffer for it to be 799 * reused here. 800 */ 801 hfsplus_jbd_lock_bh_state(bh); 802 spin_lock(&journal->j_list_lock); 803 HFSPLUS_J_ASSERT_JH(jh, (jh->b_transaction == transaction || 804 jh->b_transaction == NULL || 805 (jh->b_transaction == journal->j_committing_transaction && 806 jh->b_jlist == HFSPLUS_BJ_Forget))); 807 808 HFSPLUS_J_ASSERT_JH(jh, jh->b_next_transaction == NULL); 809 HFSPLUS_J_ASSERT_JH(jh, buffer_locked(hfsplus_jh2bh(jh))); 810 811 if (jh->b_transaction == NULL) { 812 jh->b_transaction = transaction; 813 HFSPLUS_JBUFFER_TRACE(jh, "file as HFSPLUS_BJ_Reserved"); 814 __hfsplus_jbd_file_buffer(jh, transaction, HFSPLUS_BJ_Reserved); 815 } else if (jh->b_transaction == journal->j_committing_transaction) { 816 HFSPLUS_JBUFFER_TRACE(jh, "set next transaction"); 817 jh->b_next_transaction = transaction; 818 } 819 spin_unlock(&journal->j_list_lock); 820 hfsplus_jbd_unlock_bh_state(bh); 821 822 /* 823 * akpm: I added this. ext3_alloc_branch can pick up new indirect 824 * blocks which contain freed but then revoked metadata. We need 825 * to cancel the revoke in case we end up freeing it yet again 826 * and the reallocating as data - this would cause a second revoke, 827 * which hits an assertion error. 828 */ 829 HFSPLUS_JBUFFER_TRACE(jh, "cancelling revoke"); 830 hfsplus_jbd_cancel_revoke(handle, jh); 831 hfsplus_jbd_put_journal_head(jh); 832out: 833 return err; 834} 835 836/** 837 * int hfsplus_jbd_get_undo_access() - Notify intent to modify metadata with 838 * non-rewindable consequences 839 * @handle: transaction 840 * @bh: buffer to undo 841 * @credits: store the number of taken credits here (if not NULL) 842 * 843 * Sometimes there is a need to distinguish between metadata which has 844 * been committed to disk and that which has not. The ext3fs code uses 845 * this for freeing and allocating space, we have to make sure that we 846 * do not reuse freed space until the deallocation has been committed, 847 * since if we overwrote that space we would make the delete 848 * un-rewindable in case of a crash. 849 * 850 * To deal with that, hfsplus_jbd_get_undo_access requests write access to a 851 * buffer for parts of non-rewindable operations such as delete 852 * operations on the bitmaps. The journaling code must keep a copy of 853 * the buffer's contents prior to the undo_access call until such time 854 * as we know that the buffer has definitely been committed to disk. 855 * 856 * We never need to know which transaction the committed data is part 857 * of, buffers touched here are guaranteed to be dirtied later and so 858 * will be committed to a new transaction in due course, at which point 859 * we can discard the old committed data pointer. 860 * 861 * Returns error number or 0 on success. 862 */ 863int hfsplus_jbd_get_undo_access(hfsplus_jbd_handle_t *handle, struct buffer_head *bh) 864{ 865 int err; 866 struct hfsplus_jbd_head *jh = hfsplus_jbd_add_journal_head(bh); 867 char *committed_data = NULL; 868 869 HFSPLUS_JBUFFER_TRACE(jh, "entry"); 870 871 /* 872 * Do this first --- it can drop the journal lock, so we want to 873 * make sure that obtaining the committed_data is done 874 * atomically wrt. completion of any outstanding commits. 875 */ 876 err = do_get_write_access(handle, jh, 1); 877 if (err) 878 goto out; 879 880repeat: 881 if (!jh->b_committed_data) { 882 committed_data = hfsplus_jbd_kmalloc(hfsplus_jh2bh(jh)->b_size, GFP_NOFS); 883 if (!committed_data) { 884 printk(KERN_EMERG "%s: No memory for committed data\n", 885 __FUNCTION__); 886 err = -ENOMEM; 887 goto out; 888 } 889 } 890 891 hfsplus_jbd_lock_bh_state(bh); 892 if (!jh->b_committed_data) { 893 /* Copy out the current buffer contents into the 894 * preserved, committed copy. */ 895 HFSPLUS_JBUFFER_TRACE(jh, "generate b_committed data"); 896 if (!committed_data) { 897 hfsplus_jbd_unlock_bh_state(bh); 898 goto repeat; 899 } 900 901 jh->b_committed_data = committed_data; 902 committed_data = NULL; 903 memcpy(jh->b_committed_data, bh->b_data, bh->b_size); 904 } 905 hfsplus_jbd_unlock_bh_state(bh); 906out: 907 hfsplus_jbd_put_journal_head(jh); 908 kfree(committed_data); 909 return err; 910} 911 912/** 913 * int hfsplus_jbd_dirty_data() - mark a buffer as containing dirty data which 914 * needs to be flushed before we can commit the 915 * current transaction. 916 * @handle: transaction 917 * @bh: bufferhead to mark 918 * 919 * The buffer is placed on the transaction's data list and is marked as 920 * belonging to the transaction. 921 * 922 * Returns error number or 0 on success. 923 * 924 * hfsplus_jbd_dirty_data() can be called via page_launder->ext3_writepage 925 * by kswapd. 926 */ 927int hfsplus_jbd_dirty_data(hfsplus_jbd_handle_t *handle, struct buffer_head *bh) 928{ 929 hfsplus_jbd_t *journal = handle->h_transaction->t_journal; 930 int need_brelse = 0; 931 struct hfsplus_jbd_head *jh; 932 933 if (hfsplus_jbd_is_handle_aborted(handle)) 934 return 0; 935 936 jh = hfsplus_jbd_add_journal_head(bh); 937 HFSPLUS_JBUFFER_TRACE(jh, "entry"); 938 939 /* 940 * The buffer could *already* be dirty. Writeout can start 941 * at any time. 942 */ 943 hfsplus_jbd_debug(4, "jh: %p, tid:%d\n", jh, handle->h_transaction->t_tid); 944 945 /* 946 * What if the buffer is already part of a running transaction? 947 * 948 * There are two cases: 949 * 1) It is part of the current running transaction. Refile it, 950 * just in case we have allocated it as metadata, deallocated 951 * it, then reallocated it as data. 952 * 2) It is part of the previous, still-committing transaction. 953 * If all we want to do is to guarantee that the buffer will be 954 * written to disk before this new transaction commits, then 955 * being sure that the *previous* transaction has this same 956 * property is sufficient for us! Just leave it on its old 957 * transaction. 958 * 959 * In case (2), the buffer must not already exist as metadata 960 * --- that would violate write ordering (a transaction is free 961 * to write its data at any point, even before the previous 962 * committing transaction has committed). The caller must 963 * never, ever allow this to happen: there's nothing we can do 964 * about it in this layer. 965 */ 966 hfsplus_jbd_lock_bh_state(bh); 967 spin_lock(&journal->j_list_lock); 968 if (jh->b_transaction) { 969 HFSPLUS_JBUFFER_TRACE(jh, "has transaction"); 970 if (jh->b_transaction != handle->h_transaction) { 971 HFSPLUS_JBUFFER_TRACE(jh, "belongs to older transaction"); 972 HFSPLUS_J_ASSERT_JH(jh, jh->b_transaction == 973 journal->j_committing_transaction); 974 975 /* @@@ IS THIS TRUE ? */ 976 /* 977 * Not any more. Scenario: someone does a write() 978 * in data=journal mode. The buffer's transaction has 979 * moved into commit. Then someone does another 980 * write() to the file. We do the frozen data copyout 981 * and set b_next_transaction to point to j_running_t. 982 * And while we're in that state, someone does a 983 * writepage() in an attempt to pageout the same area 984 * of the file via a shared mapping. At present that 985 * calls hfsplus_jbd_dirty_data(), and we get right here. 986 * It may be too late to journal the data. Simply 987 * falling through to the next test will suffice: the 988 * data will be dirty and wil be checkpointed. The 989 * ordering comments in the next comment block still 990 * apply. 991 */ 992 //HFSPLUS_J_ASSERT_JH(jh, jh->b_next_transaction == NULL); 993 994 /* 995 * If we're journalling data, and this buffer was 996 * subject to a write(), it could be metadata, forget 997 * or shadow against the committing transaction. Now, 998 * someone has dirtied the same darn page via a mapping 999 * and it is being writepage()'d. 1000 * We *could* just steal the page from commit, with some 1001 * fancy locking there. Instead, we just skip it - 1002 * don't tie the page's buffers to the new transaction 1003 * at all. 1004 * Implication: if we crash before the writepage() data 1005 * is written into the filesystem, recovery will replay 1006 * the write() data. 1007 */ 1008 if (jh->b_jlist != HFSPLUS_BJ_None && 1009 jh->b_jlist != HFSPLUS_BJ_SyncData && 1010 jh->b_jlist != HFSPLUS_BJ_Locked) { 1011 HFSPLUS_JBUFFER_TRACE(jh, "Not stealing"); 1012 goto no_journal; 1013 } 1014 1015 /* 1016 * This buffer may be undergoing writeout in commit. We 1017 * can't return from here and let the caller dirty it 1018 * again because that can cause the write-out loop in 1019 * commit to never terminate. 1020 */ 1021 if (buffer_dirty(bh)) { 1022 get_bh(bh); 1023 spin_unlock(&journal->j_list_lock); 1024 hfsplus_jbd_unlock_bh_state(bh); 1025 need_brelse = 1; 1026 sync_dirty_buffer(bh); 1027 hfsplus_jbd_lock_bh_state(bh); 1028 spin_lock(&journal->j_list_lock); 1029 /* The buffer may become locked again at any 1030 time if it is redirtied */ 1031 } 1032 1033 /* hfsplus_jbd_clean_data_list() may have got there first */ 1034 if (jh->b_transaction != NULL) { 1035 HFSPLUS_JBUFFER_TRACE(jh, "unfile from commit"); 1036 __hfsplus_jbd_temp_unlink_buffer(jh); 1037 /* It still points to the committing 1038 * transaction; move it to this one so 1039 * that the refile assert checks are 1040 * happy. */ 1041 jh->b_transaction = handle->h_transaction; 1042 } 1043 /* The buffer will be refiled below */ 1044 1045 } 1046 /* 1047 * Special case --- the buffer might actually have been 1048 * allocated and then immediately deallocated in the previous, 1049 * committing transaction, so might still be left on that 1050 * transaction's metadata lists. 1051 */ 1052 if (jh->b_jlist != HFSPLUS_BJ_SyncData && jh->b_jlist != HFSPLUS_BJ_Locked) { 1053 HFSPLUS_JBUFFER_TRACE(jh, "not on correct data list: unfile"); 1054 HFSPLUS_J_ASSERT_JH(jh, jh->b_jlist != HFSPLUS_BJ_Shadow); 1055 __hfsplus_jbd_temp_unlink_buffer(jh); 1056 jh->b_transaction = handle->h_transaction; 1057 HFSPLUS_JBUFFER_TRACE(jh, "file as data"); 1058 __hfsplus_jbd_file_buffer(jh, handle->h_transaction, 1059 HFSPLUS_BJ_SyncData); 1060 } 1061 } else { 1062 HFSPLUS_JBUFFER_TRACE(jh, "not on a transaction"); 1063 __hfsplus_jbd_file_buffer(jh, handle->h_transaction, HFSPLUS_BJ_SyncData); 1064 } 1065no_journal: 1066 spin_unlock(&journal->j_list_lock); 1067 hfsplus_jbd_unlock_bh_state(bh); 1068 if (need_brelse) { 1069 HFSPLUS_BUFFER_TRACE(bh, "brelse"); 1070 __brelse(bh); 1071 } 1072 HFSPLUS_JBUFFER_TRACE(jh, "exit"); 1073 hfsplus_jbd_put_journal_head(jh); 1074 return 0; 1075} 1076 1077/** 1078 * int hfsplus_jbd_dirty_metadata() - mark a buffer as containing dirty metadata 1079 * @handle: transaction to add buffer to. 1080 * @bh: buffer to mark 1081 * 1082 * mark dirty metadata which needs to be journaled as part of the current 1083 * transaction. 1084 * 1085 * The buffer is placed on the transaction's metadata list and is marked 1086 * as belonging to the transaction. 1087 * 1088 * Returns error number or 0 on success. 1089 * 1090 * Special care needs to be taken if the buffer already belongs to the 1091 * current committing transaction (in which case we should have frozen 1092 * data present for that commit). In that case, we don't relink the 1093 * buffer: that only gets done when the old transaction finally 1094 * completes its commit. 1095 */ 1096int hfsplus_jbd_dirty_metadata(hfsplus_jbd_handle_t *handle, struct buffer_head *bh) 1097{ 1098 hfsplus_transaction_t *transaction = handle->h_transaction; 1099 hfsplus_jbd_t *journal = transaction->t_journal; 1100 struct hfsplus_jbd_head *jh = hfsplus_bh2jh(bh); 1101 1102 hfsplus_jbd_debug(5, "hfsplus_jbd_head %p\n", jh); 1103 HFSPLUS_JBUFFER_TRACE(jh, "entry"); 1104 if (hfsplus_jbd_is_handle_aborted(handle)) 1105 goto out; 1106 1107 hfsplus_jbd_lock_bh_state(bh); 1108 1109 if (jh->b_modified == 0) { 1110 /* 1111 * This buffer's got modified and becoming part 1112 * of the transaction. This needs to be done 1113 * once a transaction -bzzz 1114 */ 1115 jh->b_modified = 1; 1116 HFSPLUS_J_ASSERT_JH(jh, handle->h_buffer_credits > 0); 1117 handle->h_buffer_credits--; 1118 } 1119 1120 /* 1121 * fastpath, to avoid expensive locking. If this buffer is already 1122 * on the running transaction's metadata list there is nothing to do. 1123 * Nobody can take it off again because there is a handle open. 1124 * I _think_ we're OK here with SMP barriers - a mistaken decision will 1125 * result in this test being false, so we go in and take the locks. 1126 */ 1127 if (jh->b_transaction == transaction && jh->b_jlist == HFSPLUS_BJ_Metadata) { 1128 hfsplus_jbd_debug(5, "fastpath\n"); 1129 HFSPLUS_JBUFFER_TRACE(jh, "fastpath"); 1130 HFSPLUS_J_ASSERT_JH(jh, jh->b_transaction == 1131 journal->j_running_transaction); 1132 goto out_unlock_bh; 1133 } 1134 1135 set_buffer_hfsplus_jbddirty(bh); 1136 1137 /* 1138 * Metadata already on the current transaction list doesn't 1139 * need to be filed. Metadata on another transaction's list must 1140 * be committing, and will be refiled once the commit completes: 1141 * leave it alone for now. 1142 */ 1143 if (jh->b_transaction != transaction) { 1144 HFSPLUS_JBUFFER_TRACE(jh, "already on other transaction"); 1145 hfsplus_jbd_debug(5, "already on other transaction\n"); 1146 HFSPLUS_J_ASSERT_JH(jh, jh->b_transaction == 1147 journal->j_committing_transaction); 1148 HFSPLUS_J_ASSERT_JH(jh, jh->b_next_transaction == transaction); 1149 /* And this case is illegal: we can't reuse another 1150 * transaction's data buffer, ever. */ 1151 goto out_unlock_bh; 1152 } 1153 1154 /* That test should have eliminated the following case: */ 1155 HFSPLUS_J_ASSERT_JH(jh, jh->b_frozen_data == 0); 1156 1157 HFSPLUS_JBUFFER_TRACE(jh, "file as HFSPLUS_BJ_Metadata"); 1158 hfsplus_jbd_debug(5, "file as HFSPLUS_BJ_Metadata\n"); 1159 spin_lock(&journal->j_list_lock); 1160 __hfsplus_jbd_file_buffer(jh, handle->h_transaction, HFSPLUS_BJ_Metadata); 1161 spin_unlock(&journal->j_list_lock); 1162out_unlock_bh: 1163 hfsplus_jbd_unlock_bh_state(bh); 1164out: 1165 HFSPLUS_JBUFFER_TRACE(jh, "exit"); 1166 hfsplus_jbd_debug(5, "exit\n"); 1167 return 0; 1168} 1169 1170/* 1171 * hfsplus_jbd_release_buffer: undo a get_write_access without any buffer 1172 * updates, if the update decided in the end that it didn't need access. 1173 * 1174 */ 1175void 1176hfsplus_jbd_release_buffer(hfsplus_jbd_handle_t *handle, struct buffer_head *bh) 1177{ 1178 HFSPLUS_BUFFER_TRACE(bh, "entry"); 1179} 1180 1181/** 1182 * void hfsplus_jbd_forget() - bforget() for potentially-journaled buffers. 1183 * @handle: transaction handle 1184 * @bh: bh to 'forget' 1185 * 1186 * We can only do the bforget if there are no commits pending against the 1187 * buffer. If the buffer is dirty in the current running transaction we 1188 * can safely unlink it. 1189 * 1190 * bh may not be a journalled buffer at all - it may be a non-JBD 1191 * buffer which came off the hashtable. Check for this. 1192 * 1193 * Decrements bh->b_count by one. 1194 * 1195 * Allow this call even if the handle has aborted --- it may be part of 1196 * the caller's cleanup after an abort. 1197 */ 1198int hfsplus_jbd_forget (hfsplus_jbd_handle_t *handle, struct buffer_head *bh) 1199{ 1200 hfsplus_transaction_t *transaction = handle->h_transaction; 1201 hfsplus_jbd_t *journal = transaction->t_journal; 1202 struct hfsplus_jbd_head *jh; 1203 int drop_reserve = 0; 1204 int err = 0; 1205 1206 HFSPLUS_BUFFER_TRACE(bh, "entry"); 1207 1208 hfsplus_jbd_lock_bh_state(bh); 1209 spin_lock(&journal->j_list_lock); 1210 1211 if (!buffer_hfsplus_jbd(bh)) 1212 goto not_jbd; 1213 jh = hfsplus_bh2jh(bh); 1214 1215 /* Critical error: attempting to delete a bitmap buffer, maybe? 1216 * Don't do any jbd operations, and return an error. */ 1217 if (!HFSPLUS_J_EXPECT_JH(jh, !jh->b_committed_data, 1218 "inconsistent data on disk")) { 1219 err = -EIO; 1220 goto not_jbd; 1221 } 1222 1223 /* 1224 * The buffer's going from the transaction, we must drop 1225 * all references -bzzz 1226 */ 1227 jh->b_modified = 0; 1228 1229 if (jh->b_transaction == handle->h_transaction) { 1230 HFSPLUS_J_ASSERT_JH(jh, !jh->b_frozen_data); 1231 1232 /* If we are forgetting a buffer which is already part 1233 * of this transaction, then we can just drop it from 1234 * the transaction immediately. */ 1235 clear_buffer_dirty(bh); 1236 clear_buffer_hfsplus_jbddirty(bh); 1237 1238 HFSPLUS_JBUFFER_TRACE(jh, "belongs to current transaction: unfile"); 1239 1240 drop_reserve = 1; 1241 1242 /* 1243 * We are no longer going to journal this buffer. 1244 * However, the commit of this transaction is still 1245 * important to the buffer: the delete that we are now 1246 * processing might obsolete an old log entry, so by 1247 * committing, we can satisfy the buffer's checkpoint. 1248 * 1249 * So, if we have a checkpoint on the buffer, we should 1250 * now refile the buffer on our HFSPLUS_BJ_Forget list so that 1251 * we know to remove the checkpoint after we commit. 1252 */ 1253 1254 if (jh->b_cp_transaction) { 1255 __hfsplus_jbd_temp_unlink_buffer(jh); 1256 __hfsplus_jbd_file_buffer(jh, transaction, HFSPLUS_BJ_Forget); 1257 } else { 1258 __hfsplus_jbd_unfile_buffer(jh); 1259 hfsplus_jbd_remove_journal_head(bh); 1260 __brelse(bh); 1261 if (!buffer_hfsplus_jbd(bh)) { 1262 spin_unlock(&journal->j_list_lock); 1263 hfsplus_jbd_unlock_bh_state(bh); 1264 __bforget(bh); 1265 goto drop; 1266 } 1267 } 1268 } else if (jh->b_transaction) { 1269 HFSPLUS_J_ASSERT_JH(jh, (jh->b_transaction == 1270 journal->j_committing_transaction)); 1271 /* However, if the buffer is still owned by a prior 1272 * (committing) transaction, we can't drop it yet... */ 1273 HFSPLUS_JBUFFER_TRACE(jh, "belongs to older transaction"); 1274 /* ... but we CAN drop it from the new transaction if we 1275 * have also modified it since the original commit. */ 1276 1277 if (jh->b_next_transaction) { 1278 HFSPLUS_J_ASSERT(jh->b_next_transaction == transaction); 1279 jh->b_next_transaction = NULL; 1280 drop_reserve = 1; 1281 } 1282 } 1283 1284not_jbd: 1285 spin_unlock(&journal->j_list_lock); 1286 hfsplus_jbd_unlock_bh_state(bh); 1287 __brelse(bh); 1288drop: 1289 if (drop_reserve) { 1290 /* no need to reserve log space for this block -bzzz */ 1291 handle->h_buffer_credits++; 1292 } 1293 return err; 1294} 1295 1296/** 1297 * int hfsplus_jbd_stop() - complete a transaction 1298 * @handle: tranaction to complete. 1299 * 1300 * All done for a particular handle. 1301 * 1302 * There is not much action needed here. We just return any remaining 1303 * buffer credits to the transaction and remove the handle. The only 1304 * complication is that we need to start a commit operation if the 1305 * filesystem is marked for synchronous update. 1306 * 1307 * hfsplus_jbd_stop itself will not usually return an error, but it may 1308 * do so in unusual circumstances. In particular, expect it to 1309 * return -EIO if a hfsplus_jbd_abort has been executed since the 1310 * transaction began. 1311 */ 1312int hfsplus_jbd_stop(hfsplus_jbd_handle_t *handle) 1313{ 1314 hfsplus_transaction_t *transaction = handle->h_transaction; 1315 hfsplus_jbd_t *journal = transaction->t_journal; 1316 hfsplus_handle_t *hfsplus_handle; 1317 int old_handle_count, err; 1318 1319 HFSPLUS_J_ASSERT(transaction->t_updates > 0); 1320 hfsplus_handle = hfsplus_jbd_current_handle(); 1321 HFSPLUS_J_ASSERT(hfsplus_handle->handle == handle); 1322 1323 if (hfsplus_jbd_is_handle_aborted(handle)) 1324 err = -EIO; 1325 else 1326 err = 0; 1327 1328 if (--handle->h_ref > 0) { 1329 hfsplus_jbd_debug(4, "h_ref %d -> %d\n", handle->h_ref + 1, 1330 handle->h_ref); 1331 return err; 1332 } 1333 1334 hfsplus_jbd_debug(4, "Handle %p going down\n", handle); 1335 1336 /* 1337 * Implement synchronous transaction batching. If the handle 1338 * was synchronous, don't force a commit immediately. Let's 1339 * yield and let another thread piggyback onto this transaction. 1340 * Keep doing that while new threads continue to arrive. 1341 * It doesn't cost much - we're about to run a commit and sleep 1342 * on IO anyway. Speeds up many-threaded, many-dir operations 1343 * by 30x or more... 1344 */ 1345 if (handle->h_sync) { 1346 do { 1347 old_handle_count = transaction->t_handle_count; 1348 schedule_timeout_uninterruptible(1); 1349 } while (old_handle_count != transaction->t_handle_count); 1350 } 1351 1352 current->journal_info = NULL; 1353 spin_lock(&journal->j_state_lock); 1354 spin_lock(&transaction->t_handle_lock); 1355 transaction->t_outstanding_credits -= handle->h_buffer_credits; 1356 transaction->t_updates--; 1357 if (!transaction->t_updates) { 1358 wake_up(&journal->j_wait_updates); 1359 if (journal->j_barrier_count) 1360 wake_up(&journal->j_wait_transaction_locked); 1361 } 1362 1363 /* 1364 * If the handle is marked SYNC, we need to set another commit 1365 * going! We also want to force a commit if the current 1366 * transaction is occupying too much of the log, or if the 1367 * transaction is too old now. 1368 */ 1369 if (handle->h_sync || 1370 transaction->t_outstanding_credits > 1371 journal->j_max_transaction_buffers || 1372 time_after_eq(jiffies, transaction->t_expires)) { 1373 /* Do this even for aborted journals: an abort still 1374 * completes the commit thread, it just doesn't write 1375 * anything to disk. */ 1376 hfsplus_jbd_tid_t tid = transaction->t_tid; 1377 1378 spin_unlock(&transaction->t_handle_lock); 1379 hfsplus_jbd_debug(2, "transaction too old, requesting commit for " 1380 "handle %p\n", handle); 1381 /* This is non-blocking */ 1382 __hfsplus__log_start_commit(journal, transaction->t_tid); 1383 spin_unlock(&journal->j_state_lock); 1384 1385 /* 1386 * Special case: JFS_SYNC synchronous updates require us 1387 * to wait for the commit to complete. 1388 */ 1389 if (handle->h_sync && !(current->flags & PF_MEMALLOC)) 1390 err = hfsplus_jbd_log_wait_commit(journal, tid); 1391 } else { 1392 spin_unlock(&transaction->t_handle_lock); 1393 spin_unlock(&journal->j_state_lock); 1394 } 1395 1396 hfsplus_jbd_free_handle(handle); 1397 return err; 1398} 1399 1400/**int hfsplus_jbd_force_commit() - force any uncommitted transactions 1401 * @journal: journal to force 1402 * 1403 * For synchronous operations: force any uncommitted transactions 1404 * to disk. May seem kludgy, but it reuses all the handle batching 1405 * code in a very simple manner. 1406 */ 1407int hfsplus_jbd_force_commit(hfsplus_jbd_t *journal) 1408{ 1409 hfsplus_handle_t hfsplus_handle; 1410 int ret; 1411 1412 hfsplus_handle.handle = hfsplus_jbd_start(journal, 1, &hfsplus_handle); 1413 if (IS_ERR(hfsplus_handle.handle)) { 1414 ret = PTR_ERR(hfsplus_handle.handle); 1415 } else { 1416 hfsplus_handle.handle->h_sync = 1; 1417 ret = hfsplus_jbd_stop(hfsplus_handle.handle); 1418 } 1419 return ret; 1420} 1421 1422/* 1423 * 1424 * List management code snippets: various functions for manipulating the 1425 * transaction buffer lists. 1426 * 1427 */ 1428 1429/* 1430 * Append a buffer to a transaction list, given the transaction's list head 1431 * pointer. 1432 * 1433 * j_list_lock is held. 1434 * 1435 * hfsplus_jbd_lock_bh_state(hfsplus_jh2bh(jh)) is held. 1436 */ 1437 1438static inline void 1439__blist_add_buffer(struct hfsplus_jbd_head **list, struct hfsplus_jbd_head *jh) 1440{ 1441 if (!*list) { 1442 jh->b_tnext = jh->b_tprev = jh; 1443 *list = jh; 1444 } else { 1445 /* Insert at the tail of the list to preserve order */ 1446 struct hfsplus_jbd_head *first = *list, *last = first->b_tprev; 1447 jh->b_tprev = last; 1448 jh->b_tnext = first; 1449 last->b_tnext = first->b_tprev = jh; 1450 } 1451} 1452 1453/* 1454 * Remove a buffer from a transaction list, given the transaction's list 1455 * head pointer. 1456 * 1457 * Called with j_list_lock held, and the journal may not be locked. 1458 * 1459 * hfsplus_jbd_lock_bh_state(hfsplus_jh2bh(jh)) is held. 1460 */ 1461 1462static inline void 1463__blist_del_buffer(struct hfsplus_jbd_head **list, struct hfsplus_jbd_head *jh) 1464{ 1465 if (*list == jh) { 1466 *list = jh->b_tnext; 1467 if (*list == jh) 1468 *list = NULL; 1469 } 1470 jh->b_tprev->b_tnext = jh->b_tnext; 1471 jh->b_tnext->b_tprev = jh->b_tprev; 1472} 1473 1474/* 1475 * Remove a buffer from the appropriate transaction list. 1476 * 1477 * Note that this function can *change* the value of 1478 * bh->b_transaction->t_sync_datalist, t_buffers, t_forget, 1479 * t_iobuf_list, t_shadow_list, t_log_list or t_reserved_list. If the caller 1480 * is holding onto a copy of one of thee pointers, it could go bad. 1481 * Generally the caller needs to re-read the pointer from the hfsplus_transaction_t. 1482 * 1483 * Called under j_list_lock. The journal may not be locked. 1484 */ 1485void __hfsplus_jbd_temp_unlink_buffer(struct hfsplus_jbd_head *jh) 1486{ 1487 struct hfsplus_jbd_head **list = NULL; 1488 hfsplus_transaction_t *transaction; 1489 struct buffer_head *bh = hfsplus_jh2bh(jh); 1490 1491 HFSPLUS_J_ASSERT_JH(jh, hfsplus_jbd_is_locked_bh_state(bh)); 1492 transaction = jh->b_transaction; 1493 if (transaction) 1494 assert_spin_locked(&transaction->t_journal->j_list_lock); 1495 1496 HFSPLUS_J_ASSERT_JH(jh, jh->b_jlist < HFSPLUS_BJ_Types); 1497 if (jh->b_jlist != HFSPLUS_BJ_None) 1498 HFSPLUS_J_ASSERT_JH(jh, transaction != 0); 1499 1500 switch (jh->b_jlist) { 1501 case HFSPLUS_BJ_None: 1502 return; 1503 case HFSPLUS_BJ_SyncData: 1504 list = &transaction->t_sync_datalist; 1505 break; 1506 case HFSPLUS_BJ_Metadata: 1507 transaction->t_nr_buffers--; 1508 HFSPLUS_J_ASSERT_JH(jh, transaction->t_nr_buffers >= 0); 1509 list = &transaction->t_buffers; 1510 break; 1511 case HFSPLUS_BJ_Forget: 1512 list = &transaction->t_forget; 1513 break; 1514 case HFSPLUS_BJ_IO: 1515 list = &transaction->t_iobuf_list; 1516 break; 1517 case HFSPLUS_BJ_Shadow: 1518 list = &transaction->t_shadow_list; 1519 break; 1520 case HFSPLUS_BJ_LogCtl: 1521 list = &transaction->t_log_list; 1522 break; 1523 case HFSPLUS_BJ_Reserved: 1524 list = &transaction->t_reserved_list; 1525 break; 1526 case HFSPLUS_BJ_Locked: 1527 list = &transaction->t_locked_list; 1528 break; 1529 } 1530 1531 __blist_del_buffer(list, jh); 1532 jh->b_jlist = HFSPLUS_BJ_None; 1533 if (test_clear_buffer_hfsplus_jbddirty(bh)) 1534 mark_buffer_dirty(bh); /* Expose it to the VM */ 1535} 1536 1537void __hfsplus_jbd_unfile_buffer(struct hfsplus_jbd_head *jh) 1538{ 1539 __hfsplus_jbd_temp_unlink_buffer(jh); 1540 jh->b_transaction = NULL; 1541} 1542 1543void hfsplus_jbd_unfile_buffer(hfsplus_jbd_t *journal, struct hfsplus_jbd_head *jh) 1544{ 1545 hfsplus_jbd_lock_bh_state(hfsplus_jh2bh(jh)); 1546 spin_lock(&journal->j_list_lock); 1547 __hfsplus_jbd_unfile_buffer(jh); 1548 spin_unlock(&journal->j_list_lock); 1549 hfsplus_jbd_unlock_bh_state(hfsplus_jh2bh(jh)); 1550} 1551 1552/* 1553 * Called from hfsplus_jbd_try_to_free_buffers(). 1554 * 1555 * Called under hfsplus_jbd_lock_bh_state(bh) 1556 */ 1557static void 1558__hfsplus_jbd_try_to_free_buffer(hfsplus_jbd_t *journal, struct buffer_head *bh) 1559{ 1560 struct hfsplus_jbd_head *jh; 1561 1562 jh = hfsplus_bh2jh(bh); 1563 1564 if (buffer_locked(bh) || buffer_dirty(bh)) 1565 goto out; 1566 1567 if (jh->b_next_transaction != 0) 1568 goto out; 1569 1570 spin_lock(&journal->j_list_lock); 1571 if (jh->b_transaction != 0 && jh->b_cp_transaction == 0) { 1572 if (jh->b_jlist == HFSPLUS_BJ_SyncData || jh->b_jlist == HFSPLUS_BJ_Locked) { 1573 /* A written-back ordered data buffer */ 1574 HFSPLUS_JBUFFER_TRACE(jh, "release data"); 1575 __hfsplus_jbd_unfile_buffer(jh); 1576 hfsplus_jbd_remove_journal_head(bh); 1577 __brelse(bh); 1578 } 1579 } else if (jh->b_cp_transaction != 0 && jh->b_transaction == 0) { 1580 /* written-back checkpointed metadata buffer */ 1581 if (jh->b_jlist == HFSPLUS_BJ_None) { 1582 HFSPLUS_JBUFFER_TRACE(jh, "remove from checkpoint list"); 1583 __hfsplus_jbd_remove_checkpoint(jh); 1584 hfsplus_jbd_remove_journal_head(bh); 1585 __brelse(bh); 1586 } 1587 } 1588 spin_unlock(&journal->j_list_lock); 1589out: 1590 return; 1591} 1592 1593 1594/** 1595 * int hfsplus_jbd_try_to_free_buffers() - try to free page buffers. 1596 * @journal: journal for operation 1597 * @page: to try and free 1598 * @unused_gfp_mask: unused 1599 * 1600 * 1601 * For all the buffers on this page, 1602 * if they are fully written out ordered data, move them onto BUF_CLEAN 1603 * so try_to_free_buffers() can reap them. 1604 * 1605 * This function returns non-zero if we wish try_to_free_buffers() 1606 * to be called. We do this if the page is releasable by try_to_free_buffers(). 1607 * We also do it if the page has locked or dirty buffers and the caller wants 1608 * us to perform sync or async writeout. 1609 * 1610 * This complicates JBD locking somewhat. We aren't protected by the 1611 * BKL here. We wish to remove the buffer from its committing or 1612 * running transaction's ->t_datalist via __hfsplus_jbd_unfile_buffer. 1613 * 1614 * This may *change* the value of hfsplus_transaction_t->t_datalist, so anyone 1615 * who looks at t_datalist needs to lock against this function. 1616 * 1617 * Even worse, someone may be doing a hfsplus_jbd_dirty_data on this 1618 * buffer. So we need to lock against that. hfsplus_jbd_dirty_data() 1619 * will come out of the lock with the buffer dirty, which makes it 1620 * ineligible for release here. 1621 * 1622 * Who else is affected by this? hmm... Really the only contender 1623 * is do_get_write_access() - it could be looking at the buffer while 1624 * hfsplus_jbd_try_to_free_buffer() is changing its state. But that 1625 * cannot happen because we never reallocate freed data as metadata 1626 * while the data is part of a transaction. Yes? 1627 */ 1628int hfsplus_jbd_try_to_free_buffers(hfsplus_jbd_t *journal, 1629 struct page *page, gfp_t unused_gfp_mask) 1630{ 1631 struct buffer_head *head; 1632 struct buffer_head *bh; 1633 int ret = 0; 1634 1635 HFSPLUS_J_ASSERT(PageLocked(page)); 1636 1637 head = page_buffers(page); 1638 bh = head; 1639 do { 1640 struct hfsplus_jbd_head *jh; 1641 1642 /* 1643 * We take our own ref against the hfsplus_jbd_head here to avoid 1644 * having to add tons of locking around each instance of 1645 * hfsplus_jbd_remove_journal_head() and hfsplus_jbd_put_journal_head(). 1646 */ 1647 jh = hfsplus_jbd_grab_journal_head(bh); 1648 if (!jh) 1649 continue; 1650 1651 hfsplus_jbd_lock_bh_state(bh); 1652 __hfsplus_jbd_try_to_free_buffer(journal, bh); 1653 hfsplus_jbd_put_journal_head(jh); 1654 hfsplus_jbd_unlock_bh_state(bh); 1655 if (buffer_hfsplus_jbd(bh)) 1656 goto busy; 1657 } while ((bh = bh->b_this_page) != head); 1658 ret = try_to_free_buffers(page); 1659busy: 1660 return ret; 1661} 1662 1663/* 1664 * This buffer is no longer needed. If it is on an older transaction's 1665 * checkpoint list we need to record it on this transaction's forget list 1666 * to pin this buffer (and hence its checkpointing transaction) down until 1667 * this transaction commits. If the buffer isn't on a checkpoint list, we 1668 * release it. 1669 * Returns non-zero if JBD no longer has an interest in the buffer. 1670 * 1671 * Called under j_list_lock. 1672 * 1673 * Called under jbd_lock_bh_state(bh). 1674 */ 1675static int __dispose_buffer(struct hfsplus_jbd_head *jh, hfsplus_transaction_t *transaction) 1676{ 1677 int may_free = 1; 1678 struct buffer_head *bh = hfsplus_jh2bh(jh); 1679 1680 __hfsplus_jbd_unfile_buffer(jh); 1681 1682 if (jh->b_cp_transaction) { 1683 HFSPLUS_JBUFFER_TRACE(jh, "on running+cp transaction"); 1684 __hfsplus_jbd_file_buffer(jh, transaction, HFSPLUS_BJ_Forget); 1685 clear_buffer_hfsplus_jbddirty(bh); 1686 may_free = 0; 1687 } else { 1688 HFSPLUS_JBUFFER_TRACE(jh, "on running transaction"); 1689 hfsplus_jbd_remove_journal_head(bh); 1690 __brelse(bh); 1691 } 1692 return may_free; 1693} 1694 1695/* 1696 * hfsplus_jbd_invalidatepage 1697 * 1698 * This code is tricky. It has a number of cases to deal with. 1699 * 1700 * There are two invariants which this code relies on: 1701 * 1702 * i_size must be updated on disk before we start calling invalidatepage on the 1703 * data. 1704 * 1705 * This is done in ext3 by defining an ext3_setattr method which 1706 * updates i_size before truncate gets going. By maintaining this 1707 * invariant, we can be sure that it is safe to throw away any buffers 1708 * attached to the current transaction: once the transaction commits, 1709 * we know that the data will not be needed. 1710 * 1711 * Note however that we can *not* throw away data belonging to the 1712 * previous, committing transaction! 1713 * 1714 * Any disk blocks which *are* part of the previous, committing 1715 * transaction (and which therefore cannot be discarded immediately) are 1716 * not going to be reused in the new running transaction 1717 * 1718 * The bitmap committed_data images guarantee this: any block which is 1719 * allocated in one transaction and removed in the next will be marked 1720 * as in-use in the committed_data bitmap, so cannot be reused until 1721 * the next transaction to delete the block commits. This means that 1722 * leaving committing buffers dirty is quite safe: the disk blocks 1723 * cannot be reallocated to a different file and so buffer aliasing is 1724 * not possible. 1725 * 1726 * 1727 * The above applies mainly to ordered data mode. In writeback mode we 1728 * don't make guarantees about the order in which data hits disk --- in 1729 * particular we don't guarantee that new dirty data is flushed before 1730 * transaction commit --- so it is always safe just to discard data 1731 * immediately in that mode. --sct 1732 */ 1733 1734/* 1735 * The hfsplus_jbd_unmap_buffer helper function returns zero if the buffer 1736 * concerned remains pinned as an anonymous buffer belonging to an older 1737 * transaction. 1738 * 1739 * We're outside-transaction here. Either or both of j_running_transaction 1740 * and j_committing_transaction may be NULL. 1741 */ 1742static int hfsplus_jbd_unmap_buffer(hfsplus_jbd_t *journal, struct buffer_head *bh) 1743{ 1744 hfsplus_transaction_t *transaction; 1745 struct hfsplus_jbd_head *jh; 1746 int may_free = 1; 1747 int ret; 1748 1749 HFSPLUS_BUFFER_TRACE(bh, "entry"); 1750 1751 /* 1752 * It is safe to proceed here without the j_list_lock because the 1753 * buffers cannot be stolen by try_to_free_buffers as long as we are 1754 * holding the page lock. --sct 1755 */ 1756 1757 if (!buffer_hfsplus_jbd(bh)) 1758 goto zap_buffer_unlocked; 1759 1760 spin_lock(&journal->j_state_lock); 1761 hfsplus_jbd_lock_bh_state(bh); 1762 spin_lock(&journal->j_list_lock); 1763 1764 jh = hfsplus_jbd_grab_journal_head(bh); 1765 if (!jh) 1766 goto zap_buffer_no_jh; 1767 1768 transaction = jh->b_transaction; 1769 if (transaction == NULL) { 1770 /* First case: not on any transaction. If it 1771 * has no checkpoint link, then we can zap it: 1772 * it's a writeback-mode buffer so we don't care 1773 * if it hits disk safely. */ 1774 if (!jh->b_cp_transaction) { 1775 HFSPLUS_JBUFFER_TRACE(jh, "not on any transaction: zap"); 1776 goto zap_buffer; 1777 } 1778 1779 if (!buffer_dirty(bh)) { 1780 /* bdflush has written it. We can drop it now */ 1781 goto zap_buffer; 1782 } 1783 1784 /* OK, it must be in the journal but still not 1785 * written fully to disk: it's metadata or 1786 * journaled data... */ 1787 1788 if (journal->j_running_transaction) { 1789 /* ... and once the current transaction has 1790 * committed, the buffer won't be needed any 1791 * longer. */ 1792 HFSPLUS_JBUFFER_TRACE(jh, "checkpointed: add to HFSPLUS_BJ_Forget"); 1793 ret = __dispose_buffer(jh, 1794 journal->j_running_transaction); 1795 hfsplus_jbd_put_journal_head(jh); 1796 spin_unlock(&journal->j_list_lock); 1797 hfsplus_jbd_unlock_bh_state(bh); 1798 spin_unlock(&journal->j_state_lock); 1799 return ret; 1800 } else { 1801 /* There is no currently-running transaction. So the 1802 * orphan record which we wrote for this file must have 1803 * passed into commit. We must attach this buffer to 1804 * the committing transaction, if it exists. */ 1805 if (journal->j_committing_transaction) { 1806 HFSPLUS_JBUFFER_TRACE(jh, "give to committing trans"); 1807 ret = __dispose_buffer(jh, 1808 journal->j_committing_transaction); 1809 hfsplus_jbd_put_journal_head(jh); 1810 spin_unlock(&journal->j_list_lock); 1811 hfsplus_jbd_unlock_bh_state(bh); 1812 spin_unlock(&journal->j_state_lock); 1813 return ret; 1814 } else { 1815 /* The orphan record's transaction has 1816 * committed. We can cleanse this buffer */ 1817 clear_buffer_hfsplus_jbddirty(bh); 1818 goto zap_buffer; 1819 } 1820 } 1821 } else if (transaction == journal->j_committing_transaction) { 1822 if (jh->b_jlist == HFSPLUS_BJ_Locked) { 1823 /* 1824 * The buffer is on the committing transaction's locked 1825 * list. We have the buffer locked, so I/O has 1826 * completed. So we can nail the buffer now. 1827 */ 1828 may_free = __dispose_buffer(jh, transaction); 1829 goto zap_buffer; 1830 } 1831 /* 1832 * If it is committing, we simply cannot touch it. We 1833 * can remove it's next_transaction pointer from the 1834 * running transaction if that is set, but nothing 1835 * else. */ 1836 HFSPLUS_JBUFFER_TRACE(jh, "on committing transaction"); 1837 set_buffer_hfsplus_jbd_freed(bh); 1838 if (jh->b_next_transaction) { 1839 HFSPLUS_J_ASSERT(jh->b_next_transaction == 1840 journal->j_running_transaction); 1841 jh->b_next_transaction = NULL; 1842 } 1843 hfsplus_jbd_put_journal_head(jh); 1844 spin_unlock(&journal->j_list_lock); 1845 hfsplus_jbd_unlock_bh_state(bh); 1846 spin_unlock(&journal->j_state_lock); 1847 return 0; 1848 } else { 1849 /* Good, the buffer belongs to the running transaction. 1850 * We are writing our own transaction's data, not any 1851 * previous one's, so it is safe to throw it away 1852 * (remember that we expect the filesystem to have set 1853 * i_size already for this truncate so recovery will not 1854 * expose the disk blocks we are discarding here.) */ 1855 HFSPLUS_J_ASSERT_JH(jh, transaction == journal->j_running_transaction); 1856 may_free = __dispose_buffer(jh, transaction); 1857 } 1858 1859zap_buffer: 1860 hfsplus_jbd_put_journal_head(jh); 1861zap_buffer_no_jh: 1862 spin_unlock(&journal->j_list_lock); 1863 hfsplus_jbd_unlock_bh_state(bh); 1864 spin_unlock(&journal->j_state_lock); 1865zap_buffer_unlocked: 1866 clear_buffer_dirty(bh); 1867 HFSPLUS_J_ASSERT_BH(bh, !buffer_hfsplus_jbddirty(bh)); 1868 clear_buffer_mapped(bh); 1869 clear_buffer_req(bh); 1870 clear_buffer_new(bh); 1871 bh->b_bdev = NULL; 1872 return may_free; 1873} 1874 1875/** 1876 * int hfsplus_jbd_invalidatepage() 1877 * @journal: journal to use for flush... 1878 * @page: page to flush 1879 * @offset: length of page to invalidate. 1880 * 1881 * Reap page buffers containing data after offset in page. 1882 * 1883 * Return non-zero if the page's buffers were successfully reaped. 1884 */ 1885int hfsplus_jbd_invalidatepage(hfsplus_jbd_t *journal, 1886 struct page *page, 1887 unsigned long offset) 1888{ 1889 struct buffer_head *head, *bh, *next; 1890 unsigned int curr_off = 0; 1891 int may_free = 1; 1892 1893 if (!PageLocked(page)) 1894 BUG(); 1895 if (!page_has_buffers(page)) 1896 return 1; 1897 1898 /* We will potentially be playing with lists other than just the 1899 * data lists (especially for journaled data mode), so be 1900 * cautious in our locking. */ 1901 1902 head = bh = page_buffers(page); 1903 do { 1904 unsigned int next_off = curr_off + bh->b_size; 1905 next = bh->b_this_page; 1906 1907 if (offset <= curr_off) { 1908 /* This block is wholly outside the truncation point */ 1909 lock_buffer(bh); 1910 may_free &= hfsplus_jbd_unmap_buffer(journal, bh); 1911 unlock_buffer(bh); 1912 } 1913 curr_off = next_off; 1914 bh = next; 1915 1916 } while (bh != head); 1917 1918 if (!offset) { 1919 if (!may_free || !try_to_free_buffers(page)) 1920 return 0; 1921 HFSPLUS_J_ASSERT(!page_has_buffers(page)); 1922 } 1923 return 1; 1924} 1925 1926/* 1927 * File a buffer on the given transaction list. 1928 */ 1929void __hfsplus_jbd_file_buffer(struct hfsplus_jbd_head *jh, 1930 hfsplus_transaction_t *transaction, int jlist) 1931{ 1932 struct hfsplus_jbd_head **list = NULL; 1933 int was_dirty = 0; 1934 struct buffer_head *bh = hfsplus_jh2bh(jh); 1935 1936 HFSPLUS_J_ASSERT_JH(jh, hfsplus_jbd_is_locked_bh_state(bh)); 1937 assert_spin_locked(&transaction->t_journal->j_list_lock); 1938 1939 HFSPLUS_J_ASSERT_JH(jh, jh->b_jlist < HFSPLUS_BJ_Types); 1940 HFSPLUS_J_ASSERT_JH(jh, jh->b_transaction == transaction || 1941 jh->b_transaction == 0); 1942 1943 if (jh->b_transaction && jh->b_jlist == jlist) 1944 return; 1945 1946 /* The following list of buffer states needs to be consistent 1947 * with __hfsplus_jbd_unexpected_dirty_buffer()'s handling of dirty 1948 * state. */ 1949 1950 if (jlist == HFSPLUS_BJ_Metadata || jlist == HFSPLUS_BJ_Reserved || 1951 jlist == HFSPLUS_BJ_Shadow || jlist == HFSPLUS_BJ_Forget) { 1952 if (test_clear_buffer_dirty(bh) || 1953 test_clear_buffer_hfsplus_jbddirty(bh)) 1954 was_dirty = 1; 1955 } 1956 1957 if (jh->b_transaction) 1958 __hfsplus_jbd_temp_unlink_buffer(jh); 1959 jh->b_transaction = transaction; 1960 1961 switch (jlist) { 1962 case HFSPLUS_BJ_None: 1963 HFSPLUS_J_ASSERT_JH(jh, !jh->b_committed_data); 1964 HFSPLUS_J_ASSERT_JH(jh, !jh->b_frozen_data); 1965 return; 1966 case HFSPLUS_BJ_SyncData: 1967 list = &transaction->t_sync_datalist; 1968 break; 1969 case HFSPLUS_BJ_Metadata: 1970 transaction->t_nr_buffers++; 1971 list = &transaction->t_buffers; 1972 break; 1973 case HFSPLUS_BJ_Forget: 1974 list = &transaction->t_forget; 1975 break; 1976 case HFSPLUS_BJ_IO: 1977 list = &transaction->t_iobuf_list; 1978 break; 1979 case HFSPLUS_BJ_Shadow: 1980 list = &transaction->t_shadow_list; 1981 break; 1982 case HFSPLUS_BJ_LogCtl: 1983 list = &transaction->t_log_list; 1984 break; 1985 case HFSPLUS_BJ_Reserved: 1986 list = &transaction->t_reserved_list; 1987 break; 1988 case HFSPLUS_BJ_Locked: 1989 list = &transaction->t_locked_list; 1990 break; 1991 } 1992 1993 __blist_add_buffer(list, jh); 1994 jh->b_jlist = jlist; 1995 1996 if (was_dirty) 1997 set_buffer_hfsplus_jbddirty(bh); 1998} 1999 2000void hfsplus_jbd_file_buffer(struct hfsplus_jbd_head *jh, 2001 hfsplus_transaction_t *transaction, int jlist) 2002{ 2003 hfsplus_jbd_lock_bh_state(hfsplus_jh2bh(jh)); 2004 spin_lock(&transaction->t_journal->j_list_lock); 2005 __hfsplus_jbd_file_buffer(jh, transaction, jlist); 2006 spin_unlock(&transaction->t_journal->j_list_lock); 2007 hfsplus_jbd_unlock_bh_state(hfsplus_jh2bh(jh)); 2008} 2009 2010/* 2011 * Remove a buffer from its current buffer list in preparation for 2012 * dropping it from its current transaction entirely. If the buffer has 2013 * already started to be used by a subsequent transaction, refile the 2014 * buffer on that transaction's metadata list. 2015 * 2016 * Called under journal->j_list_lock 2017 * 2018 * Called under hfsplus_jbd_lock_bh_state(hfsplus_jh2bh(jh)) 2019 */ 2020void __hfsplus_jbd_refile_buffer(struct hfsplus_jbd_head *jh) 2021{ 2022 int was_dirty; 2023 struct buffer_head *bh = hfsplus_jh2bh(jh); 2024 2025 HFSPLUS_J_ASSERT_JH(jh, hfsplus_jbd_is_locked_bh_state(bh)); 2026 if (jh->b_transaction) 2027 assert_spin_locked(&jh->b_transaction->t_journal->j_list_lock); 2028 2029 /* If the buffer is now unused, just drop it. */ 2030 if (jh->b_next_transaction == NULL) { 2031 __hfsplus_jbd_unfile_buffer(jh); 2032 return; 2033 } 2034 2035 /* 2036 * It has been modified by a later transaction: add it to the new 2037 * transaction's metadata list. 2038 */ 2039 2040 was_dirty = test_clear_buffer_hfsplus_jbddirty(bh); 2041 __hfsplus_jbd_temp_unlink_buffer(jh); 2042 jh->b_transaction = jh->b_next_transaction; 2043 jh->b_next_transaction = NULL; 2044 __hfsplus_jbd_file_buffer(jh, jh->b_transaction, HFSPLUS_BJ_Metadata); 2045 HFSPLUS_J_ASSERT_JH(jh, jh->b_transaction->t_state == HFSPLUS_T_RUNNING); 2046 2047 if (was_dirty) 2048 set_buffer_hfsplus_jbddirty(bh); 2049} 2050 2051/* 2052 * For the unlocked version of this call, also make sure that any 2053 * hanging hfsplus_jbd_head is cleaned up if necessary. 2054 * 2055 * __hfsplus_jbd_refile_buffer is usually called as part of a single locked 2056 * operation on a buffer_head, in which the caller is probably going to 2057 * be hooking the hfsplus_jbd_head onto other lists. In that case it is up 2058 * to the caller to remove the hfsplus_jbd_head if necessary. For the 2059 * unlocked hfsplus_jbd_refile_buffer call, the caller isn't going to be 2060 * doing anything else to the buffer so we need to do the cleanup 2061 * ourselves to avoid a jh leak. 2062 * 2063 * *** The hfsplus_jbd_head may be freed by this call! *** 2064 */ 2065void hfsplus_jbd_refile_buffer(hfsplus_jbd_t *journal, struct hfsplus_jbd_head *jh) 2066{ 2067 struct buffer_head *bh = hfsplus_jh2bh(jh); 2068 2069 hfsplus_jbd_lock_bh_state(bh); 2070 spin_lock(&journal->j_list_lock); 2071 2072 __hfsplus_jbd_refile_buffer(jh); 2073 hfsplus_jbd_unlock_bh_state(bh); 2074 hfsplus_jbd_remove_journal_head(bh); 2075 2076 spin_unlock(&journal->j_list_lock); 2077 __brelse(bh); 2078} 2079