1 /* -*- mode: c; c-basic-offset: 8; -*- 2 * vim: noexpandtab sw=8 ts=8 sts=0: 3 * 4 * journal.c 5 * 6 * Defines functions of journalling api 7 * 8 * Copyright (C) 2003, 2004 Oracle. All rights reserved. 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public 12 * License as published by the Free Software Foundation; either 13 * version 2 of the License, or (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public 21 * License along with this program; if not, write to the 22 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 23 * Boston, MA 021110-1307, USA. 24 */ 25 26 #include <linux/fs.h> 27 #include <linux/types.h> 28 #include <linux/slab.h> 29 #include <linux/highmem.h> 30 #include <linux/kthread.h> 31 32 #define MLOG_MASK_PREFIX ML_JOURNAL 33 #include <cluster/masklog.h> 34 35 #include "ocfs2.h" 36 37 #include "alloc.h" 38 #include "dlmglue.h" 39 #include "extent_map.h" 40 #include "heartbeat.h" 41 #include "inode.h" 42 #include "journal.h" 43 #include "localalloc.h" 44 #include "namei.h" 45 #include "slot_map.h" 46 #include "super.h" 47 #include "vote.h" 48 #include "sysfile.h" 49 50 #include "buffer_head_io.h" 51 52 spinlock_t trans_inc_lock = SPIN_LOCK_UNLOCKED; 53 54 static int ocfs2_force_read_journal(struct inode *inode); 55 static int ocfs2_recover_node(struct ocfs2_super *osb, 56 int node_num); 57 static int __ocfs2_recovery_thread(void *arg); 58 static int ocfs2_commit_cache(struct ocfs2_super *osb); 59 static int ocfs2_wait_on_mount(struct ocfs2_super *osb); 60 static void ocfs2_handle_cleanup_locks(struct ocfs2_journal *journal, 61 struct ocfs2_journal_handle *handle); 62 static void ocfs2_commit_unstarted_handle(struct ocfs2_journal_handle *handle); 63 static int ocfs2_journal_toggle_dirty(struct ocfs2_super *osb, 64 int dirty); 65 static int ocfs2_trylock_journal(struct ocfs2_super *osb, 66 int slot_num); 67 static int ocfs2_recover_orphans(struct ocfs2_super *osb, 68 int slot); 69 static int ocfs2_commit_thread(void *arg); 70 71 static int ocfs2_commit_cache(struct ocfs2_super *osb) 72 { 73 int status = 0; 74 unsigned int flushed; 75 unsigned long old_id; 76 struct ocfs2_journal *journal = NULL; 77 78 mlog_entry_void(); 79 80 journal = osb->journal; 81 82 /* Flush all pending commits and checkpoint the journal. */ 83 down_write(&journal->j_trans_barrier); 84 85 if (atomic_read(&journal->j_num_trans) == 0) { 86 up_write(&journal->j_trans_barrier); 87 mlog(0, "No transactions for me to flush!\n"); 88 goto finally; 89 } 90 91 journal_lock_updates(journal->j_journal); 92 status = journal_flush(journal->j_journal); 93 journal_unlock_updates(journal->j_journal); 94 if (status < 0) { 95 up_write(&journal->j_trans_barrier); 96 mlog_errno(status); 97 goto finally; 98 } 99 100 old_id = ocfs2_inc_trans_id(journal); 101 102 flushed = atomic_read(&journal->j_num_trans); 103 atomic_set(&journal->j_num_trans, 0); 104 up_write(&journal->j_trans_barrier); 105 106 mlog(0, "commit_thread: flushed transaction %lu (%u handles)\n", 107 journal->j_trans_id, flushed); 108 109 ocfs2_kick_vote_thread(osb); 110 wake_up(&journal->j_checkpointed); 111 finally: 112 mlog_exit(status); 113 return status; 114 } 115 116 struct ocfs2_journal_handle *ocfs2_alloc_handle(struct ocfs2_super *osb) 117 { 118 struct ocfs2_journal_handle *retval = NULL; 119 120 retval = kcalloc(1, sizeof(*retval), GFP_KERNEL); 121 if (!retval) { 122 mlog(ML_ERROR, "Failed to allocate memory for journal " 123 "handle!\n"); 124 return NULL; 125 } 126 127 retval->max_buffs = 0; 128 retval->num_locks = 0; 129 retval->k_handle = NULL; 130 131 INIT_LIST_HEAD(&retval->locks); 132 INIT_LIST_HEAD(&retval->inode_list); 133 retval->journal = osb->journal; 134 135 return retval; 136 } 137 138 /* pass it NULL and it will allocate a new handle object for you. If 139 * you pass it a handle however, it may still return error, in which 140 * case it has free'd the passed handle for you. */ 141 struct ocfs2_journal_handle *ocfs2_start_trans(struct ocfs2_super *osb, 142 struct ocfs2_journal_handle *handle, 143 int max_buffs) 144 { 145 int ret; 146 journal_t *journal = osb->journal->j_journal; 147 148 mlog_entry("(max_buffs = %d)\n", max_buffs); 149 150 BUG_ON(!osb || !osb->journal->j_journal); 151 152 if (ocfs2_is_hard_readonly(osb)) { 153 ret = -EROFS; 154 goto done_free; 155 } 156 157 BUG_ON(osb->journal->j_state == OCFS2_JOURNAL_FREE); 158 BUG_ON(max_buffs <= 0); 159 160 /* JBD might support this, but our journalling code doesn't yet. */ 161 if (journal_current_handle()) { 162 mlog(ML_ERROR, "Recursive transaction attempted!\n"); 163 BUG(); 164 } 165 166 if (!handle) 167 handle = ocfs2_alloc_handle(osb); 168 if (!handle) { 169 ret = -ENOMEM; 170 mlog(ML_ERROR, "Failed to allocate memory for journal " 171 "handle!\n"); 172 goto done_free; 173 } 174 175 handle->max_buffs = max_buffs; 176 177 down_read(&osb->journal->j_trans_barrier); 178 179 /* actually start the transaction now */ 180 handle->k_handle = journal_start(journal, max_buffs); 181 if (IS_ERR(handle->k_handle)) { 182 up_read(&osb->journal->j_trans_barrier); 183 184 ret = PTR_ERR(handle->k_handle); 185 handle->k_handle = NULL; 186 mlog_errno(ret); 187 188 if (is_journal_aborted(journal)) { 189 ocfs2_abort(osb->sb, "Detected aborted journal"); 190 ret = -EROFS; 191 } 192 goto done_free; 193 } 194 195 atomic_inc(&(osb->journal->j_num_trans)); 196 handle->flags |= OCFS2_HANDLE_STARTED; 197 198 mlog_exit_ptr(handle); 199 return handle; 200 201 done_free: 202 if (handle) 203 ocfs2_commit_unstarted_handle(handle); /* will kfree handle */ 204 205 mlog_exit(ret); 206 return ERR_PTR(ret); 207 } 208 209 void ocfs2_handle_add_inode(struct ocfs2_journal_handle *handle, 210 struct inode *inode) 211 { 212 BUG_ON(!handle); 213 BUG_ON(!inode); 214 215 atomic_inc(&inode->i_count); 216 217 /* we're obviously changing it... */ 218 mutex_lock(&inode->i_mutex); 219 220 /* sanity check */ 221 BUG_ON(OCFS2_I(inode)->ip_handle); 222 BUG_ON(!list_empty(&OCFS2_I(inode)->ip_handle_list)); 223 224 OCFS2_I(inode)->ip_handle = handle; 225 list_del(&(OCFS2_I(inode)->ip_handle_list)); 226 list_add_tail(&(OCFS2_I(inode)->ip_handle_list), &(handle->inode_list)); 227 } 228 229 static void ocfs2_handle_unlock_inodes(struct ocfs2_journal_handle *handle) 230 { 231 struct list_head *p, *n; 232 struct inode *inode; 233 struct ocfs2_inode_info *oi; 234 235 list_for_each_safe(p, n, &handle->inode_list) { 236 oi = list_entry(p, struct ocfs2_inode_info, 237 ip_handle_list); 238 inode = &oi->vfs_inode; 239 240 OCFS2_I(inode)->ip_handle = NULL; 241 list_del_init(&OCFS2_I(inode)->ip_handle_list); 242 243 mutex_unlock(&inode->i_mutex); 244 iput(inode); 245 } 246 } 247 248 /* This is trivial so we do it out of the main commit 249 * paths. Beware, it can be called from start_trans too! */ 250 static void ocfs2_commit_unstarted_handle(struct ocfs2_journal_handle *handle) 251 { 252 mlog_entry_void(); 253 254 BUG_ON(handle->flags & OCFS2_HANDLE_STARTED); 255 256 ocfs2_handle_unlock_inodes(handle); 257 /* You are allowed to add journal locks before the transaction 258 * has started. */ 259 ocfs2_handle_cleanup_locks(handle->journal, handle); 260 261 kfree(handle); 262 263 mlog_exit_void(); 264 } 265 266 void ocfs2_commit_trans(struct ocfs2_journal_handle *handle) 267 { 268 handle_t *jbd_handle; 269 int retval; 270 struct ocfs2_journal *journal = handle->journal; 271 272 mlog_entry_void(); 273 274 BUG_ON(!handle); 275 276 if (!(handle->flags & OCFS2_HANDLE_STARTED)) { 277 ocfs2_commit_unstarted_handle(handle); 278 mlog_exit_void(); 279 return; 280 } 281 282 /* release inode semaphores we took during this transaction */ 283 ocfs2_handle_unlock_inodes(handle); 284 285 /* ocfs2_extend_trans may have had to call journal_restart 286 * which will always commit the transaction, but may return 287 * error for any number of reasons. If this is the case, we 288 * clear k_handle as it's not valid any more. */ 289 if (handle->k_handle) { 290 jbd_handle = handle->k_handle; 291 292 if (handle->flags & OCFS2_HANDLE_SYNC) 293 jbd_handle->h_sync = 1; 294 else 295 jbd_handle->h_sync = 0; 296 297 /* actually stop the transaction. if we've set h_sync, 298 * it'll have been committed when we return */ 299 retval = journal_stop(jbd_handle); 300 if (retval < 0) { 301 mlog_errno(retval); 302 mlog(ML_ERROR, "Could not commit transaction\n"); 303 BUG(); 304 } 305 306 handle->k_handle = NULL; /* it's been free'd in journal_stop */ 307 } 308 309 ocfs2_handle_cleanup_locks(journal, handle); 310 311 up_read(&journal->j_trans_barrier); 312 313 kfree(handle); 314 mlog_exit_void(); 315 } 316 317 /* 318 * 'nblocks' is what you want to add to the current 319 * transaction. extend_trans will either extend the current handle by 320 * nblocks, or commit it and start a new one with nblocks credits. 321 * 322 * WARNING: This will not release any semaphores or disk locks taken 323 * during the transaction, so make sure they were taken *before* 324 * start_trans or we'll have ordering deadlocks. 325 * 326 * WARNING2: Note that we do *not* drop j_trans_barrier here. This is 327 * good because transaction ids haven't yet been recorded on the 328 * cluster locks associated with this handle. 329 */ 330 int ocfs2_extend_trans(struct ocfs2_journal_handle *handle, 331 int nblocks) 332 { 333 int status; 334 335 BUG_ON(!handle); 336 BUG_ON(!(handle->flags & OCFS2_HANDLE_STARTED)); 337 BUG_ON(!nblocks); 338 339 mlog_entry_void(); 340 341 mlog(0, "Trying to extend transaction by %d blocks\n", nblocks); 342 343 status = journal_extend(handle->k_handle, nblocks); 344 if (status < 0) { 345 mlog_errno(status); 346 goto bail; 347 } 348 349 if (status > 0) { 350 mlog(0, "journal_extend failed, trying journal_restart\n"); 351 status = journal_restart(handle->k_handle, nblocks); 352 if (status < 0) { 353 handle->k_handle = NULL; 354 mlog_errno(status); 355 goto bail; 356 } 357 handle->max_buffs = nblocks; 358 } else 359 handle->max_buffs += nblocks; 360 361 status = 0; 362 bail: 363 364 mlog_exit(status); 365 return status; 366 } 367 368 int ocfs2_journal_access(struct ocfs2_journal_handle *handle, 369 struct inode *inode, 370 struct buffer_head *bh, 371 int type) 372 { 373 int status; 374 375 BUG_ON(!inode); 376 BUG_ON(!handle); 377 BUG_ON(!bh); 378 BUG_ON(!(handle->flags & OCFS2_HANDLE_STARTED)); 379 380 mlog_entry("bh->b_blocknr=%llu, type=%d (\"%s\"), bh->b_size = %hu\n", 381 (unsigned long long)bh->b_blocknr, type, 382 (type == OCFS2_JOURNAL_ACCESS_CREATE) ? 383 "OCFS2_JOURNAL_ACCESS_CREATE" : 384 "OCFS2_JOURNAL_ACCESS_WRITE", 385 bh->b_size); 386 387 /* we can safely remove this assertion after testing. */ 388 if (!buffer_uptodate(bh)) { 389 mlog(ML_ERROR, "giving me a buffer that's not uptodate!\n"); 390 mlog(ML_ERROR, "b_blocknr=%llu\n", 391 (unsigned long long)bh->b_blocknr); 392 BUG(); 393 } 394 395 /* Set the current transaction information on the inode so 396 * that the locking code knows whether it can drop it's locks 397 * on this inode or not. We're protected from the commit 398 * thread updating the current transaction id until 399 * ocfs2_commit_trans() because ocfs2_start_trans() took 400 * j_trans_barrier for us. */ 401 ocfs2_set_inode_lock_trans(OCFS2_SB(inode->i_sb)->journal, inode); 402 403 mutex_lock(&OCFS2_I(inode)->ip_io_mutex); 404 switch (type) { 405 case OCFS2_JOURNAL_ACCESS_CREATE: 406 case OCFS2_JOURNAL_ACCESS_WRITE: 407 status = journal_get_write_access(handle->k_handle, bh); 408 break; 409 410 case OCFS2_JOURNAL_ACCESS_UNDO: 411 status = journal_get_undo_access(handle->k_handle, bh); 412 break; 413 414 default: 415 status = -EINVAL; 416 mlog(ML_ERROR, "Uknown access type!\n"); 417 } 418 mutex_unlock(&OCFS2_I(inode)->ip_io_mutex); 419 420 if (status < 0) 421 mlog(ML_ERROR, "Error %d getting %d access to buffer!\n", 422 status, type); 423 424 mlog_exit(status); 425 return status; 426 } 427 428 int ocfs2_journal_dirty(struct ocfs2_journal_handle *handle, 429 struct buffer_head *bh) 430 { 431 int status; 432 433 BUG_ON(!(handle->flags & OCFS2_HANDLE_STARTED)); 434 435 mlog_entry("(bh->b_blocknr=%llu)\n", 436 (unsigned long long)bh->b_blocknr); 437 438 status = journal_dirty_metadata(handle->k_handle, bh); 439 if (status < 0) 440 mlog(ML_ERROR, "Could not dirty metadata buffer. " 441 "(bh->b_blocknr=%llu)\n", 442 (unsigned long long)bh->b_blocknr); 443 444 mlog_exit(status); 445 return status; 446 } 447 448 int ocfs2_journal_dirty_data(handle_t *handle, 449 struct buffer_head *bh) 450 { 451 int err = journal_dirty_data(handle, bh); 452 if (err) 453 mlog_errno(err); 454 /* TODO: When we can handle it, abort the handle and go RO on 455 * error here. */ 456 457 return err; 458 } 459 460 /* We always assume you're adding a metadata lock at level 'ex' */ 461 int ocfs2_handle_add_lock(struct ocfs2_journal_handle *handle, 462 struct inode *inode) 463 { 464 int status; 465 struct ocfs2_journal_lock *lock; 466 467 BUG_ON(!inode); 468 469 lock = kmem_cache_alloc(ocfs2_lock_cache, GFP_NOFS); 470 if (!lock) { 471 status = -ENOMEM; 472 mlog_errno(-ENOMEM); 473 goto bail; 474 } 475 476 if (!igrab(inode)) 477 BUG(); 478 lock->jl_inode = inode; 479 480 list_add_tail(&(lock->jl_lock_list), &(handle->locks)); 481 handle->num_locks++; 482 483 status = 0; 484 bail: 485 mlog_exit(status); 486 return status; 487 } 488 489 static void ocfs2_handle_cleanup_locks(struct ocfs2_journal *journal, 490 struct ocfs2_journal_handle *handle) 491 { 492 struct list_head *p, *n; 493 struct ocfs2_journal_lock *lock; 494 struct inode *inode; 495 496 list_for_each_safe(p, n, &(handle->locks)) { 497 lock = list_entry(p, struct ocfs2_journal_lock, 498 jl_lock_list); 499 list_del(&lock->jl_lock_list); 500 handle->num_locks--; 501 502 inode = lock->jl_inode; 503 ocfs2_meta_unlock(inode, 1); 504 if (atomic_read(&inode->i_count) == 1) 505 mlog(ML_ERROR, 506 "Inode %"MLFu64", I'm doing a last iput for!", 507 OCFS2_I(inode)->ip_blkno); 508 iput(inode); 509 kmem_cache_free(ocfs2_lock_cache, lock); 510 } 511 } 512 513 #define OCFS2_DEFAULT_COMMIT_INTERVAL (HZ * 5) 514 515 void ocfs2_set_journal_params(struct ocfs2_super *osb) 516 { 517 journal_t *journal = osb->journal->j_journal; 518 519 spin_lock(&journal->j_state_lock); 520 journal->j_commit_interval = OCFS2_DEFAULT_COMMIT_INTERVAL; 521 if (osb->s_mount_opt & OCFS2_MOUNT_BARRIER) 522 journal->j_flags |= JFS_BARRIER; 523 else 524 journal->j_flags &= ~JFS_BARRIER; 525 spin_unlock(&journal->j_state_lock); 526 } 527 528 int ocfs2_journal_init(struct ocfs2_journal *journal, int *dirty) 529 { 530 int status = -1; 531 struct inode *inode = NULL; /* the journal inode */ 532 journal_t *j_journal = NULL; 533 struct ocfs2_dinode *di = NULL; 534 struct buffer_head *bh = NULL; 535 struct ocfs2_super *osb; 536 int meta_lock = 0; 537 538 mlog_entry_void(); 539 540 BUG_ON(!journal); 541 542 osb = journal->j_osb; 543 544 /* already have the inode for our journal */ 545 inode = ocfs2_get_system_file_inode(osb, JOURNAL_SYSTEM_INODE, 546 osb->slot_num); 547 if (inode == NULL) { 548 status = -EACCES; 549 mlog_errno(status); 550 goto done; 551 } 552 if (is_bad_inode(inode)) { 553 mlog(ML_ERROR, "access error (bad inode)\n"); 554 iput(inode); 555 inode = NULL; 556 status = -EACCES; 557 goto done; 558 } 559 560 SET_INODE_JOURNAL(inode); 561 OCFS2_I(inode)->ip_open_count++; 562 563 /* Skip recovery waits here - journal inode metadata never 564 * changes in a live cluster so it can be considered an 565 * exception to the rule. */ 566 status = ocfs2_meta_lock_full(inode, NULL, &bh, 1, 567 OCFS2_META_LOCK_RECOVERY); 568 if (status < 0) { 569 if (status != -ERESTARTSYS) 570 mlog(ML_ERROR, "Could not get lock on journal!\n"); 571 goto done; 572 } 573 574 meta_lock = 1; 575 di = (struct ocfs2_dinode *)bh->b_data; 576 577 if (inode->i_size < OCFS2_MIN_JOURNAL_SIZE) { 578 mlog(ML_ERROR, "Journal file size (%lld) is too small!\n", 579 inode->i_size); 580 status = -EINVAL; 581 goto done; 582 } 583 584 mlog(0, "inode->i_size = %lld\n", inode->i_size); 585 mlog(0, "inode->i_blocks = %lu\n", inode->i_blocks); 586 mlog(0, "inode->ip_clusters = %u\n", OCFS2_I(inode)->ip_clusters); 587 588 /* call the kernels journal init function now */ 589 j_journal = journal_init_inode(inode); 590 if (j_journal == NULL) { 591 mlog(ML_ERROR, "Linux journal layer error\n"); 592 status = -EINVAL; 593 goto done; 594 } 595 596 mlog(0, "Returned from journal_init_inode\n"); 597 mlog(0, "j_journal->j_maxlen = %u\n", j_journal->j_maxlen); 598 599 *dirty = (le32_to_cpu(di->id1.journal1.ij_flags) & 600 OCFS2_JOURNAL_DIRTY_FL); 601 602 journal->j_journal = j_journal; 603 journal->j_inode = inode; 604 journal->j_bh = bh; 605 606 ocfs2_set_journal_params(osb); 607 608 journal->j_state = OCFS2_JOURNAL_LOADED; 609 610 status = 0; 611 done: 612 if (status < 0) { 613 if (meta_lock) 614 ocfs2_meta_unlock(inode, 1); 615 if (bh != NULL) 616 brelse(bh); 617 if (inode) { 618 OCFS2_I(inode)->ip_open_count--; 619 iput(inode); 620 } 621 } 622 623 mlog_exit(status); 624 return status; 625 } 626 627 static int ocfs2_journal_toggle_dirty(struct ocfs2_super *osb, 628 int dirty) 629 { 630 int status; 631 unsigned int flags; 632 struct ocfs2_journal *journal = osb->journal; 633 struct buffer_head *bh = journal->j_bh; 634 struct ocfs2_dinode *fe; 635 636 mlog_entry_void(); 637 638 fe = (struct ocfs2_dinode *)bh->b_data; 639 if (!OCFS2_IS_VALID_DINODE(fe)) { 640 /* This is called from startup/shutdown which will 641 * handle the errors in a specific manner, so no need 642 * to call ocfs2_error() here. */ 643 mlog(ML_ERROR, "Journal dinode %"MLFu64" has invalid " 644 "signature: %.*s", fe->i_blkno, 7, fe->i_signature); 645 status = -EIO; 646 goto out; 647 } 648 649 flags = le32_to_cpu(fe->id1.journal1.ij_flags); 650 if (dirty) 651 flags |= OCFS2_JOURNAL_DIRTY_FL; 652 else 653 flags &= ~OCFS2_JOURNAL_DIRTY_FL; 654 fe->id1.journal1.ij_flags = cpu_to_le32(flags); 655 656 status = ocfs2_write_block(osb, bh, journal->j_inode); 657 if (status < 0) 658 mlog_errno(status); 659 660 out: 661 mlog_exit(status); 662 return status; 663 } 664 665 /* 666 * If the journal has been kmalloc'd it needs to be freed after this 667 * call. 668 */ 669 void ocfs2_journal_shutdown(struct ocfs2_super *osb) 670 { 671 struct ocfs2_journal *journal = NULL; 672 int status = 0; 673 struct inode *inode = NULL; 674 int num_running_trans = 0; 675 676 mlog_entry_void(); 677 678 BUG_ON(!osb); 679 680 journal = osb->journal; 681 if (!journal) 682 goto done; 683 684 inode = journal->j_inode; 685 686 if (journal->j_state != OCFS2_JOURNAL_LOADED) 687 goto done; 688 689 /* need to inc inode use count as journal_destroy will iput. */ 690 if (!igrab(inode)) 691 BUG(); 692 693 num_running_trans = atomic_read(&(osb->journal->j_num_trans)); 694 if (num_running_trans > 0) 695 mlog(0, "Shutting down journal: must wait on %d " 696 "running transactions!\n", 697 num_running_trans); 698 699 /* Do a commit_cache here. It will flush our journal, *and* 700 * release any locks that are still held. 701 * set the SHUTDOWN flag and release the trans lock. 702 * the commit thread will take the trans lock for us below. */ 703 journal->j_state = OCFS2_JOURNAL_IN_SHUTDOWN; 704 705 /* The OCFS2_JOURNAL_IN_SHUTDOWN will signal to commit_cache to not 706 * drop the trans_lock (which we want to hold until we 707 * completely destroy the journal. */ 708 if (osb->commit_task) { 709 /* Wait for the commit thread */ 710 mlog(0, "Waiting for ocfs2commit to exit....\n"); 711 kthread_stop(osb->commit_task); 712 osb->commit_task = NULL; 713 } 714 715 BUG_ON(atomic_read(&(osb->journal->j_num_trans)) != 0); 716 717 status = ocfs2_journal_toggle_dirty(osb, 0); 718 if (status < 0) 719 mlog_errno(status); 720 721 /* Shutdown the kernel journal system */ 722 journal_destroy(journal->j_journal); 723 724 OCFS2_I(inode)->ip_open_count--; 725 726 /* unlock our journal */ 727 ocfs2_meta_unlock(inode, 1); 728 729 brelse(journal->j_bh); 730 journal->j_bh = NULL; 731 732 journal->j_state = OCFS2_JOURNAL_FREE; 733 734 // up_write(&journal->j_trans_barrier); 735 done: 736 if (inode) 737 iput(inode); 738 mlog_exit_void(); 739 } 740 741 static void ocfs2_clear_journal_error(struct super_block *sb, 742 journal_t *journal, 743 int slot) 744 { 745 int olderr; 746 747 olderr = journal_errno(journal); 748 if (olderr) { 749 mlog(ML_ERROR, "File system error %d recorded in " 750 "journal %u.\n", olderr, slot); 751 mlog(ML_ERROR, "File system on device %s needs checking.\n", 752 sb->s_id); 753 754 journal_ack_err(journal); 755 journal_clear_err(journal); 756 } 757 } 758 759 int ocfs2_journal_load(struct ocfs2_journal *journal) 760 { 761 int status = 0; 762 struct ocfs2_super *osb; 763 764 mlog_entry_void(); 765 766 if (!journal) 767 BUG(); 768 769 osb = journal->j_osb; 770 771 status = journal_load(journal->j_journal); 772 if (status < 0) { 773 mlog(ML_ERROR, "Failed to load journal!\n"); 774 goto done; 775 } 776 777 ocfs2_clear_journal_error(osb->sb, journal->j_journal, osb->slot_num); 778 779 status = ocfs2_journal_toggle_dirty(osb, 1); 780 if (status < 0) { 781 mlog_errno(status); 782 goto done; 783 } 784 785 /* Launch the commit thread */ 786 osb->commit_task = kthread_run(ocfs2_commit_thread, osb, "ocfs2cmt-%d", 787 osb->osb_id); 788 if (IS_ERR(osb->commit_task)) { 789 status = PTR_ERR(osb->commit_task); 790 osb->commit_task = NULL; 791 mlog(ML_ERROR, "unable to launch ocfs2commit thread, error=%d", 792 status); 793 goto done; 794 } 795 796 done: 797 mlog_exit(status); 798 return status; 799 } 800 801 802 /* 'full' flag tells us whether we clear out all blocks or if we just 803 * mark the journal clean */ 804 int ocfs2_journal_wipe(struct ocfs2_journal *journal, int full) 805 { 806 int status; 807 808 mlog_entry_void(); 809 810 BUG_ON(!journal); 811 812 status = journal_wipe(journal->j_journal, full); 813 if (status < 0) { 814 mlog_errno(status); 815 goto bail; 816 } 817 818 status = ocfs2_journal_toggle_dirty(journal->j_osb, 0); 819 if (status < 0) 820 mlog_errno(status); 821 822 bail: 823 mlog_exit(status); 824 return status; 825 } 826 827 /* 828 * JBD Might read a cached version of another nodes journal file. We 829 * don't want this as this file changes often and we get no 830 * notification on those changes. The only way to be sure that we've 831 * got the most up to date version of those blocks then is to force 832 * read them off disk. Just searching through the buffer cache won't 833 * work as there may be pages backing this file which are still marked 834 * up to date. We know things can't change on this file underneath us 835 * as we have the lock by now :) 836 */ 837 static int ocfs2_force_read_journal(struct inode *inode) 838 { 839 int status = 0; 840 int i, p_blocks; 841 u64 v_blkno, p_blkno; 842 #define CONCURRENT_JOURNAL_FILL 32 843 struct buffer_head *bhs[CONCURRENT_JOURNAL_FILL]; 844 845 mlog_entry_void(); 846 847 BUG_ON(inode->i_blocks != 848 ocfs2_align_bytes_to_sectors(i_size_read(inode))); 849 850 memset(bhs, 0, sizeof(struct buffer_head *) * CONCURRENT_JOURNAL_FILL); 851 852 mlog(0, "Force reading %lu blocks\n", 853 (inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9))); 854 855 v_blkno = 0; 856 while (v_blkno < 857 (inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9))) { 858 859 status = ocfs2_extent_map_get_blocks(inode, v_blkno, 860 1, &p_blkno, 861 &p_blocks); 862 if (status < 0) { 863 mlog_errno(status); 864 goto bail; 865 } 866 867 if (p_blocks > CONCURRENT_JOURNAL_FILL) 868 p_blocks = CONCURRENT_JOURNAL_FILL; 869 870 status = ocfs2_read_blocks(OCFS2_SB(inode->i_sb), 871 p_blkno, p_blocks, bhs, 0, 872 inode); 873 if (status < 0) { 874 mlog_errno(status); 875 goto bail; 876 } 877 878 for(i = 0; i < p_blocks; i++) { 879 brelse(bhs[i]); 880 bhs[i] = NULL; 881 } 882 883 v_blkno += p_blocks; 884 } 885 886 bail: 887 for(i = 0; i < CONCURRENT_JOURNAL_FILL; i++) 888 if (bhs[i]) 889 brelse(bhs[i]); 890 mlog_exit(status); 891 return status; 892 } 893 894 struct ocfs2_la_recovery_item { 895 struct list_head lri_list; 896 int lri_slot; 897 struct ocfs2_dinode *lri_la_dinode; 898 struct ocfs2_dinode *lri_tl_dinode; 899 }; 900 901 /* Does the second half of the recovery process. By this point, the 902 * node is marked clean and can actually be considered recovered, 903 * hence it's no longer in the recovery map, but there's still some 904 * cleanup we can do which shouldn't happen within the recovery thread 905 * as locking in that context becomes very difficult if we are to take 906 * recovering nodes into account. 907 * 908 * NOTE: This function can and will sleep on recovery of other nodes 909 * during cluster locking, just like any other ocfs2 process. 910 */ 911 void ocfs2_complete_recovery(void *data) 912 { 913 int ret; 914 struct ocfs2_super *osb = data; 915 struct ocfs2_journal *journal = osb->journal; 916 struct ocfs2_dinode *la_dinode, *tl_dinode; 917 struct ocfs2_la_recovery_item *item; 918 struct list_head *p, *n; 919 LIST_HEAD(tmp_la_list); 920 921 mlog_entry_void(); 922 923 mlog(0, "completing recovery from keventd\n"); 924 925 spin_lock(&journal->j_lock); 926 list_splice_init(&journal->j_la_cleanups, &tmp_la_list); 927 spin_unlock(&journal->j_lock); 928 929 list_for_each_safe(p, n, &tmp_la_list) { 930 item = list_entry(p, struct ocfs2_la_recovery_item, lri_list); 931 list_del_init(&item->lri_list); 932 933 mlog(0, "Complete recovery for slot %d\n", item->lri_slot); 934 935 la_dinode = item->lri_la_dinode; 936 if (la_dinode) { 937 mlog(0, "Clean up local alloc %"MLFu64"\n", 938 la_dinode->i_blkno); 939 940 ret = ocfs2_complete_local_alloc_recovery(osb, 941 la_dinode); 942 if (ret < 0) 943 mlog_errno(ret); 944 945 kfree(la_dinode); 946 } 947 948 tl_dinode = item->lri_tl_dinode; 949 if (tl_dinode) { 950 mlog(0, "Clean up truncate log %"MLFu64"\n", 951 tl_dinode->i_blkno); 952 953 ret = ocfs2_complete_truncate_log_recovery(osb, 954 tl_dinode); 955 if (ret < 0) 956 mlog_errno(ret); 957 958 kfree(tl_dinode); 959 } 960 961 ret = ocfs2_recover_orphans(osb, item->lri_slot); 962 if (ret < 0) 963 mlog_errno(ret); 964 965 kfree(item); 966 } 967 968 mlog(0, "Recovery completion\n"); 969 mlog_exit_void(); 970 } 971 972 /* NOTE: This function always eats your references to la_dinode and 973 * tl_dinode, either manually on error, or by passing them to 974 * ocfs2_complete_recovery */ 975 static void ocfs2_queue_recovery_completion(struct ocfs2_journal *journal, 976 int slot_num, 977 struct ocfs2_dinode *la_dinode, 978 struct ocfs2_dinode *tl_dinode) 979 { 980 struct ocfs2_la_recovery_item *item; 981 982 item = kmalloc(sizeof(struct ocfs2_la_recovery_item), GFP_KERNEL); 983 if (!item) { 984 /* Though we wish to avoid it, we are in fact safe in 985 * skipping local alloc cleanup as fsck.ocfs2 is more 986 * than capable of reclaiming unused space. */ 987 if (la_dinode) 988 kfree(la_dinode); 989 990 if (tl_dinode) 991 kfree(tl_dinode); 992 993 mlog_errno(-ENOMEM); 994 return; 995 } 996 997 INIT_LIST_HEAD(&item->lri_list); 998 item->lri_la_dinode = la_dinode; 999 item->lri_slot = slot_num; 1000 item->lri_tl_dinode = tl_dinode; 1001 1002 spin_lock(&journal->j_lock); 1003 list_add_tail(&item->lri_list, &journal->j_la_cleanups); 1004 queue_work(ocfs2_wq, &journal->j_recovery_work); 1005 spin_unlock(&journal->j_lock); 1006 } 1007 1008 /* Called by the mount code to queue recovery the last part of 1009 * recovery for it's own slot. */ 1010 void ocfs2_complete_mount_recovery(struct ocfs2_super *osb) 1011 { 1012 struct ocfs2_journal *journal = osb->journal; 1013 1014 if (osb->dirty) { 1015 /* No need to queue up our truncate_log as regular 1016 * cleanup will catch that. */ 1017 ocfs2_queue_recovery_completion(journal, 1018 osb->slot_num, 1019 osb->local_alloc_copy, 1020 NULL); 1021 ocfs2_schedule_truncate_log_flush(osb, 0); 1022 1023 osb->local_alloc_copy = NULL; 1024 osb->dirty = 0; 1025 } 1026 } 1027 1028 static int __ocfs2_recovery_thread(void *arg) 1029 { 1030 int status, node_num; 1031 struct ocfs2_super *osb = arg; 1032 1033 mlog_entry_void(); 1034 1035 status = ocfs2_wait_on_mount(osb); 1036 if (status < 0) { 1037 goto bail; 1038 } 1039 1040 restart: 1041 status = ocfs2_super_lock(osb, 1); 1042 if (status < 0) { 1043 mlog_errno(status); 1044 goto bail; 1045 } 1046 1047 while(!ocfs2_node_map_is_empty(osb, &osb->recovery_map)) { 1048 node_num = ocfs2_node_map_first_set_bit(osb, 1049 &osb->recovery_map); 1050 if (node_num == O2NM_INVALID_NODE_NUM) { 1051 mlog(0, "Out of nodes to recover.\n"); 1052 break; 1053 } 1054 1055 status = ocfs2_recover_node(osb, node_num); 1056 if (status < 0) { 1057 mlog(ML_ERROR, 1058 "Error %d recovering node %d on device (%u,%u)!\n", 1059 status, node_num, 1060 MAJOR(osb->sb->s_dev), MINOR(osb->sb->s_dev)); 1061 mlog(ML_ERROR, "Volume requires unmount.\n"); 1062 continue; 1063 } 1064 1065 ocfs2_recovery_map_clear(osb, node_num); 1066 } 1067 ocfs2_super_unlock(osb, 1); 1068 1069 /* We always run recovery on our own orphan dir - the dead 1070 * node(s) may have voted "no" on an inode delete earlier. A 1071 * revote is therefore required. */ 1072 ocfs2_queue_recovery_completion(osb->journal, osb->slot_num, NULL, 1073 NULL); 1074 1075 bail: 1076 mutex_lock(&osb->recovery_lock); 1077 if (!status && 1078 !ocfs2_node_map_is_empty(osb, &osb->recovery_map)) { 1079 mutex_unlock(&osb->recovery_lock); 1080 goto restart; 1081 } 1082 1083 osb->recovery_thread_task = NULL; 1084 mb(); /* sync with ocfs2_recovery_thread_running */ 1085 wake_up(&osb->recovery_event); 1086 1087 mutex_unlock(&osb->recovery_lock); 1088 1089 mlog_exit(status); 1090 /* no one is callint kthread_stop() for us so the kthread() api 1091 * requires that we call do_exit(). And it isn't exported, but 1092 * complete_and_exit() seems to be a minimal wrapper around it. */ 1093 complete_and_exit(NULL, status); 1094 return status; 1095 } 1096 1097 void ocfs2_recovery_thread(struct ocfs2_super *osb, int node_num) 1098 { 1099 mlog_entry("(node_num=%d, osb->node_num = %d)\n", 1100 node_num, osb->node_num); 1101 1102 mutex_lock(&osb->recovery_lock); 1103 if (osb->disable_recovery) 1104 goto out; 1105 1106 /* People waiting on recovery will wait on 1107 * the recovery map to empty. */ 1108 if (!ocfs2_recovery_map_set(osb, node_num)) 1109 mlog(0, "node %d already be in recovery.\n", node_num); 1110 1111 mlog(0, "starting recovery thread...\n"); 1112 1113 if (osb->recovery_thread_task) 1114 goto out; 1115 1116 osb->recovery_thread_task = kthread_run(__ocfs2_recovery_thread, osb, 1117 "ocfs2rec-%d", osb->osb_id); 1118 if (IS_ERR(osb->recovery_thread_task)) { 1119 mlog_errno((int)PTR_ERR(osb->recovery_thread_task)); 1120 osb->recovery_thread_task = NULL; 1121 } 1122 1123 out: 1124 mutex_unlock(&osb->recovery_lock); 1125 wake_up(&osb->recovery_event); 1126 1127 mlog_exit_void(); 1128 } 1129 1130 /* Does the actual journal replay and marks the journal inode as 1131 * clean. Will only replay if the journal inode is marked dirty. */ 1132 static int ocfs2_replay_journal(struct ocfs2_super *osb, 1133 int node_num, 1134 int slot_num) 1135 { 1136 int status; 1137 int got_lock = 0; 1138 unsigned int flags; 1139 struct inode *inode = NULL; 1140 struct ocfs2_dinode *fe; 1141 journal_t *journal = NULL; 1142 struct buffer_head *bh = NULL; 1143 1144 inode = ocfs2_get_system_file_inode(osb, JOURNAL_SYSTEM_INODE, 1145 slot_num); 1146 if (inode == NULL) { 1147 status = -EACCES; 1148 mlog_errno(status); 1149 goto done; 1150 } 1151 if (is_bad_inode(inode)) { 1152 status = -EACCES; 1153 iput(inode); 1154 inode = NULL; 1155 mlog_errno(status); 1156 goto done; 1157 } 1158 SET_INODE_JOURNAL(inode); 1159 1160 status = ocfs2_meta_lock_full(inode, NULL, &bh, 1, 1161 OCFS2_META_LOCK_RECOVERY); 1162 if (status < 0) { 1163 mlog(0, "status returned from ocfs2_meta_lock=%d\n", status); 1164 if (status != -ERESTARTSYS) 1165 mlog(ML_ERROR, "Could not lock journal!\n"); 1166 goto done; 1167 } 1168 got_lock = 1; 1169 1170 fe = (struct ocfs2_dinode *) bh->b_data; 1171 1172 flags = le32_to_cpu(fe->id1.journal1.ij_flags); 1173 1174 if (!(flags & OCFS2_JOURNAL_DIRTY_FL)) { 1175 mlog(0, "No recovery required for node %d\n", node_num); 1176 goto done; 1177 } 1178 1179 mlog(ML_NOTICE, "Recovering node %d from slot %d on device (%u,%u)\n", 1180 node_num, slot_num, 1181 MAJOR(osb->sb->s_dev), MINOR(osb->sb->s_dev)); 1182 1183 OCFS2_I(inode)->ip_clusters = le32_to_cpu(fe->i_clusters); 1184 1185 status = ocfs2_force_read_journal(inode); 1186 if (status < 0) { 1187 mlog_errno(status); 1188 goto done; 1189 } 1190 1191 mlog(0, "calling journal_init_inode\n"); 1192 journal = journal_init_inode(inode); 1193 if (journal == NULL) { 1194 mlog(ML_ERROR, "Linux journal layer error\n"); 1195 status = -EIO; 1196 goto done; 1197 } 1198 1199 status = journal_load(journal); 1200 if (status < 0) { 1201 mlog_errno(status); 1202 if (!igrab(inode)) 1203 BUG(); 1204 journal_destroy(journal); 1205 goto done; 1206 } 1207 1208 ocfs2_clear_journal_error(osb->sb, journal, slot_num); 1209 1210 /* wipe the journal */ 1211 mlog(0, "flushing the journal.\n"); 1212 journal_lock_updates(journal); 1213 status = journal_flush(journal); 1214 journal_unlock_updates(journal); 1215 if (status < 0) 1216 mlog_errno(status); 1217 1218 /* This will mark the node clean */ 1219 flags = le32_to_cpu(fe->id1.journal1.ij_flags); 1220 flags &= ~OCFS2_JOURNAL_DIRTY_FL; 1221 fe->id1.journal1.ij_flags = cpu_to_le32(flags); 1222 1223 status = ocfs2_write_block(osb, bh, inode); 1224 if (status < 0) 1225 mlog_errno(status); 1226 1227 if (!igrab(inode)) 1228 BUG(); 1229 1230 journal_destroy(journal); 1231 1232 done: 1233 /* drop the lock on this nodes journal */ 1234 if (got_lock) 1235 ocfs2_meta_unlock(inode, 1); 1236 1237 if (inode) 1238 iput(inode); 1239 1240 if (bh) 1241 brelse(bh); 1242 1243 mlog_exit(status); 1244 return status; 1245 } 1246 1247 /* 1248 * Do the most important parts of node recovery: 1249 * - Replay it's journal 1250 * - Stamp a clean local allocator file 1251 * - Stamp a clean truncate log 1252 * - Mark the node clean 1253 * 1254 * If this function completes without error, a node in OCFS2 can be 1255 * said to have been safely recovered. As a result, failure during the 1256 * second part of a nodes recovery process (local alloc recovery) is 1257 * far less concerning. 1258 */ 1259 static int ocfs2_recover_node(struct ocfs2_super *osb, 1260 int node_num) 1261 { 1262 int status = 0; 1263 int slot_num; 1264 struct ocfs2_slot_info *si = osb->slot_info; 1265 struct ocfs2_dinode *la_copy = NULL; 1266 struct ocfs2_dinode *tl_copy = NULL; 1267 1268 mlog_entry("(node_num=%d, osb->node_num = %d)\n", 1269 node_num, osb->node_num); 1270 1271 mlog(0, "checking node %d\n", node_num); 1272 1273 /* Should not ever be called to recover ourselves -- in that 1274 * case we should've called ocfs2_journal_load instead. */ 1275 BUG_ON(osb->node_num == node_num); 1276 1277 slot_num = ocfs2_node_num_to_slot(si, node_num); 1278 if (slot_num == OCFS2_INVALID_SLOT) { 1279 status = 0; 1280 mlog(0, "no slot for this node, so no recovery required.\n"); 1281 goto done; 1282 } 1283 1284 mlog(0, "node %d was using slot %d\n", node_num, slot_num); 1285 1286 status = ocfs2_replay_journal(osb, node_num, slot_num); 1287 if (status < 0) { 1288 mlog_errno(status); 1289 goto done; 1290 } 1291 1292 /* Stamp a clean local alloc file AFTER recovering the journal... */ 1293 status = ocfs2_begin_local_alloc_recovery(osb, slot_num, &la_copy); 1294 if (status < 0) { 1295 mlog_errno(status); 1296 goto done; 1297 } 1298 1299 /* An error from begin_truncate_log_recovery is not 1300 * serious enough to warrant halting the rest of 1301 * recovery. */ 1302 status = ocfs2_begin_truncate_log_recovery(osb, slot_num, &tl_copy); 1303 if (status < 0) 1304 mlog_errno(status); 1305 1306 /* Likewise, this would be a strange but ultimately not so 1307 * harmful place to get an error... */ 1308 ocfs2_clear_slot(si, slot_num); 1309 status = ocfs2_update_disk_slots(osb, si); 1310 if (status < 0) 1311 mlog_errno(status); 1312 1313 /* This will kfree the memory pointed to by la_copy and tl_copy */ 1314 ocfs2_queue_recovery_completion(osb->journal, slot_num, la_copy, 1315 tl_copy); 1316 1317 status = 0; 1318 done: 1319 1320 mlog_exit(status); 1321 return status; 1322 } 1323 1324 /* Test node liveness by trylocking his journal. If we get the lock, 1325 * we drop it here. Return 0 if we got the lock, -EAGAIN if node is 1326 * still alive (we couldn't get the lock) and < 0 on error. */ 1327 static int ocfs2_trylock_journal(struct ocfs2_super *osb, 1328 int slot_num) 1329 { 1330 int status, flags; 1331 struct inode *inode = NULL; 1332 1333 inode = ocfs2_get_system_file_inode(osb, JOURNAL_SYSTEM_INODE, 1334 slot_num); 1335 if (inode == NULL) { 1336 mlog(ML_ERROR, "access error\n"); 1337 status = -EACCES; 1338 goto bail; 1339 } 1340 if (is_bad_inode(inode)) { 1341 mlog(ML_ERROR, "access error (bad inode)\n"); 1342 iput(inode); 1343 inode = NULL; 1344 status = -EACCES; 1345 goto bail; 1346 } 1347 SET_INODE_JOURNAL(inode); 1348 1349 flags = OCFS2_META_LOCK_RECOVERY | OCFS2_META_LOCK_NOQUEUE; 1350 status = ocfs2_meta_lock_full(inode, NULL, NULL, 1, flags); 1351 if (status < 0) { 1352 if (status != -EAGAIN) 1353 mlog_errno(status); 1354 goto bail; 1355 } 1356 1357 ocfs2_meta_unlock(inode, 1); 1358 bail: 1359 if (inode) 1360 iput(inode); 1361 1362 return status; 1363 } 1364 1365 /* Call this underneath ocfs2_super_lock. It also assumes that the 1366 * slot info struct has been updated from disk. */ 1367 int ocfs2_mark_dead_nodes(struct ocfs2_super *osb) 1368 { 1369 int status, i, node_num; 1370 struct ocfs2_slot_info *si = osb->slot_info; 1371 1372 /* This is called with the super block cluster lock, so we 1373 * know that the slot map can't change underneath us. */ 1374 1375 spin_lock(&si->si_lock); 1376 for(i = 0; i < si->si_num_slots; i++) { 1377 if (i == osb->slot_num) 1378 continue; 1379 if (ocfs2_is_empty_slot(si, i)) 1380 continue; 1381 1382 node_num = si->si_global_node_nums[i]; 1383 if (ocfs2_node_map_test_bit(osb, &osb->recovery_map, node_num)) 1384 continue; 1385 spin_unlock(&si->si_lock); 1386 1387 /* Ok, we have a slot occupied by another node which 1388 * is not in the recovery map. We trylock his journal 1389 * file here to test if he's alive. */ 1390 status = ocfs2_trylock_journal(osb, i); 1391 if (!status) { 1392 /* Since we're called from mount, we know that 1393 * the recovery thread can't race us on 1394 * setting / checking the recovery bits. */ 1395 ocfs2_recovery_thread(osb, node_num); 1396 } else if ((status < 0) && (status != -EAGAIN)) { 1397 mlog_errno(status); 1398 goto bail; 1399 } 1400 1401 spin_lock(&si->si_lock); 1402 } 1403 spin_unlock(&si->si_lock); 1404 1405 status = 0; 1406 bail: 1407 mlog_exit(status); 1408 return status; 1409 } 1410 1411 static int ocfs2_recover_orphans(struct ocfs2_super *osb, 1412 int slot) 1413 { 1414 int status = 0; 1415 int have_disk_lock = 0; 1416 struct inode *inode = NULL; 1417 struct inode *iter; 1418 struct inode *orphan_dir_inode = NULL; 1419 unsigned long offset, blk, local; 1420 struct buffer_head *bh = NULL; 1421 struct ocfs2_dir_entry *de; 1422 struct super_block *sb = osb->sb; 1423 struct ocfs2_inode_info *oi; 1424 1425 mlog(0, "Recover inodes from orphan dir in slot %d\n", slot); 1426 1427 orphan_dir_inode = ocfs2_get_system_file_inode(osb, 1428 ORPHAN_DIR_SYSTEM_INODE, 1429 slot); 1430 if (!orphan_dir_inode) { 1431 status = -ENOENT; 1432 mlog_errno(status); 1433 goto out; 1434 } 1435 1436 mutex_lock(&orphan_dir_inode->i_mutex); 1437 status = ocfs2_meta_lock(orphan_dir_inode, NULL, NULL, 0); 1438 if (status < 0) { 1439 mutex_unlock(&orphan_dir_inode->i_mutex); 1440 mlog_errno(status); 1441 goto out; 1442 } 1443 have_disk_lock = 1; 1444 1445 offset = 0; 1446 iter = NULL; 1447 while(offset < i_size_read(orphan_dir_inode)) { 1448 blk = offset >> sb->s_blocksize_bits; 1449 1450 bh = ocfs2_bread(orphan_dir_inode, blk, &status, 0); 1451 if (!bh) 1452 status = -EINVAL; 1453 if (status < 0) { 1454 mutex_unlock(&orphan_dir_inode->i_mutex); 1455 if (bh) 1456 brelse(bh); 1457 mlog_errno(status); 1458 goto out; 1459 } 1460 1461 local = 0; 1462 while(offset < i_size_read(orphan_dir_inode) 1463 && local < sb->s_blocksize) { 1464 de = (struct ocfs2_dir_entry *) (bh->b_data + local); 1465 1466 if (!ocfs2_check_dir_entry(orphan_dir_inode, 1467 de, bh, local)) { 1468 mutex_unlock(&orphan_dir_inode->i_mutex); 1469 status = -EINVAL; 1470 mlog_errno(status); 1471 brelse(bh); 1472 goto out; 1473 } 1474 1475 local += le16_to_cpu(de->rec_len); 1476 offset += le16_to_cpu(de->rec_len); 1477 1478 /* I guess we silently fail on no inode? */ 1479 if (!le64_to_cpu(de->inode)) 1480 continue; 1481 if (de->file_type > OCFS2_FT_MAX) { 1482 mlog(ML_ERROR, 1483 "block %llu contains invalid de: " 1484 "inode = %"MLFu64", rec_len = %u, " 1485 "name_len = %u, file_type = %u, " 1486 "name='%.*s'\n", 1487 (unsigned long long)bh->b_blocknr, 1488 le64_to_cpu(de->inode), 1489 le16_to_cpu(de->rec_len), 1490 de->name_len, 1491 de->file_type, 1492 de->name_len, 1493 de->name); 1494 continue; 1495 } 1496 if (de->name_len == 1 && !strncmp(".", de->name, 1)) 1497 continue; 1498 if (de->name_len == 2 && !strncmp("..", de->name, 2)) 1499 continue; 1500 1501 iter = ocfs2_iget(osb, le64_to_cpu(de->inode)); 1502 if (IS_ERR(iter)) 1503 continue; 1504 1505 mlog(0, "queue orphan %"MLFu64"\n", 1506 OCFS2_I(iter)->ip_blkno); 1507 OCFS2_I(iter)->ip_next_orphan = inode; 1508 inode = iter; 1509 } 1510 brelse(bh); 1511 } 1512 mutex_unlock(&orphan_dir_inode->i_mutex); 1513 1514 ocfs2_meta_unlock(orphan_dir_inode, 0); 1515 have_disk_lock = 0; 1516 1517 iput(orphan_dir_inode); 1518 orphan_dir_inode = NULL; 1519 1520 while (inode) { 1521 oi = OCFS2_I(inode); 1522 mlog(0, "iput orphan %"MLFu64"\n", oi->ip_blkno); 1523 1524 iter = oi->ip_next_orphan; 1525 1526 spin_lock(&oi->ip_lock); 1527 /* Delete voting may have set these on the assumption 1528 * that the other node would wipe them successfully. 1529 * If they are still in the node's orphan dir, we need 1530 * to reset that state. */ 1531 oi->ip_flags &= ~(OCFS2_INODE_DELETED|OCFS2_INODE_SKIP_DELETE); 1532 1533 /* Set the proper information to get us going into 1534 * ocfs2_delete_inode. */ 1535 oi->ip_flags |= OCFS2_INODE_MAYBE_ORPHANED; 1536 oi->ip_orphaned_slot = slot; 1537 spin_unlock(&oi->ip_lock); 1538 1539 iput(inode); 1540 1541 inode = iter; 1542 } 1543 1544 out: 1545 if (have_disk_lock) 1546 ocfs2_meta_unlock(orphan_dir_inode, 0); 1547 1548 if (orphan_dir_inode) 1549 iput(orphan_dir_inode); 1550 1551 return status; 1552 } 1553 1554 static int ocfs2_wait_on_mount(struct ocfs2_super *osb) 1555 { 1556 /* This check is good because ocfs2 will wait on our recovery 1557 * thread before changing it to something other than MOUNTED 1558 * or DISABLED. */ 1559 wait_event(osb->osb_mount_event, 1560 atomic_read(&osb->vol_state) == VOLUME_MOUNTED || 1561 atomic_read(&osb->vol_state) == VOLUME_DISABLED); 1562 1563 /* If there's an error on mount, then we may never get to the 1564 * MOUNTED flag, but this is set right before 1565 * dismount_volume() so we can trust it. */ 1566 if (atomic_read(&osb->vol_state) == VOLUME_DISABLED) { 1567 mlog(0, "mount error, exiting!\n"); 1568 return -EBUSY; 1569 } 1570 1571 return 0; 1572 } 1573 1574 static int ocfs2_commit_thread(void *arg) 1575 { 1576 int status; 1577 struct ocfs2_super *osb = arg; 1578 struct ocfs2_journal *journal = osb->journal; 1579 1580 /* we can trust j_num_trans here because _should_stop() is only set in 1581 * shutdown and nobody other than ourselves should be able to start 1582 * transactions. committing on shutdown might take a few iterations 1583 * as final transactions put deleted inodes on the list */ 1584 while (!(kthread_should_stop() && 1585 atomic_read(&journal->j_num_trans) == 0)) { 1586 1587 wait_event_interruptible(osb->checkpoint_event, 1588 atomic_read(&journal->j_num_trans) 1589 || kthread_should_stop()); 1590 1591 status = ocfs2_commit_cache(osb); 1592 if (status < 0) 1593 mlog_errno(status); 1594 1595 if (kthread_should_stop() && atomic_read(&journal->j_num_trans)){ 1596 mlog(ML_KTHREAD, 1597 "commit_thread: %u transactions pending on " 1598 "shutdown\n", 1599 atomic_read(&journal->j_num_trans)); 1600 } 1601 } 1602 1603 return 0; 1604 } 1605 1606 /* Look for a dirty journal without taking any cluster locks. Used for 1607 * hard readonly access to determine whether the file system journals 1608 * require recovery. */ 1609 int ocfs2_check_journals_nolocks(struct ocfs2_super *osb) 1610 { 1611 int ret = 0; 1612 unsigned int slot; 1613 struct buffer_head *di_bh; 1614 struct ocfs2_dinode *di; 1615 struct inode *journal = NULL; 1616 1617 for(slot = 0; slot < osb->max_slots; slot++) { 1618 journal = ocfs2_get_system_file_inode(osb, 1619 JOURNAL_SYSTEM_INODE, 1620 slot); 1621 if (!journal || is_bad_inode(journal)) { 1622 ret = -EACCES; 1623 mlog_errno(ret); 1624 goto out; 1625 } 1626 1627 di_bh = NULL; 1628 ret = ocfs2_read_block(osb, OCFS2_I(journal)->ip_blkno, &di_bh, 1629 0, journal); 1630 if (ret < 0) { 1631 mlog_errno(ret); 1632 goto out; 1633 } 1634 1635 di = (struct ocfs2_dinode *) di_bh->b_data; 1636 1637 if (le32_to_cpu(di->id1.journal1.ij_flags) & 1638 OCFS2_JOURNAL_DIRTY_FL) 1639 ret = -EROFS; 1640 1641 brelse(di_bh); 1642 if (ret) 1643 break; 1644 } 1645 1646 out: 1647 if (journal) 1648 iput(journal); 1649 1650 return ret; 1651 } 1652