1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2000-2005 Silicon Graphics, Inc. 4 * All Rights Reserved. 5 */ 6 #include "xfs.h" 7 #include "xfs_fs.h" 8 #include "xfs_shared.h" 9 #include "xfs_format.h" 10 #include "xfs_log_format.h" 11 #include "xfs_trans_resv.h" 12 #include "xfs_mount.h" 13 #include "xfs_errortag.h" 14 #include "xfs_error.h" 15 #include "xfs_trans.h" 16 #include "xfs_trans_priv.h" 17 #include "xfs_log.h" 18 #include "xfs_log_priv.h" 19 #include "xfs_trace.h" 20 #include "xfs_sysfs.h" 21 #include "xfs_sb.h" 22 #include "xfs_health.h" 23 24 kmem_zone_t *xfs_log_ticket_zone; 25 26 /* Local miscellaneous function prototypes */ 27 STATIC struct xlog * 28 xlog_alloc_log( 29 struct xfs_mount *mp, 30 struct xfs_buftarg *log_target, 31 xfs_daddr_t blk_offset, 32 int num_bblks); 33 STATIC int 34 xlog_space_left( 35 struct xlog *log, 36 atomic64_t *head); 37 STATIC void 38 xlog_dealloc_log( 39 struct xlog *log); 40 41 /* local state machine functions */ 42 STATIC void xlog_state_done_syncing( 43 struct xlog_in_core *iclog); 44 STATIC int 45 xlog_state_get_iclog_space( 46 struct xlog *log, 47 int len, 48 struct xlog_in_core **iclog, 49 struct xlog_ticket *ticket, 50 int *continued_write, 51 int *logoffsetp); 52 STATIC void 53 xlog_state_switch_iclogs( 54 struct xlog *log, 55 struct xlog_in_core *iclog, 56 int eventual_size); 57 STATIC void 58 xlog_grant_push_ail( 59 struct xlog *log, 60 int need_bytes); 61 STATIC void 62 xlog_sync( 63 struct xlog *log, 64 struct xlog_in_core *iclog); 65 #if defined(DEBUG) 66 STATIC void 67 xlog_verify_dest_ptr( 68 struct xlog *log, 69 void *ptr); 70 STATIC void 71 xlog_verify_grant_tail( 72 struct xlog *log); 73 STATIC void 74 xlog_verify_iclog( 75 struct xlog *log, 76 struct xlog_in_core *iclog, 77 int count); 78 STATIC void 79 xlog_verify_tail_lsn( 80 struct xlog *log, 81 struct xlog_in_core *iclog, 82 xfs_lsn_t tail_lsn); 83 #else 84 #define xlog_verify_dest_ptr(a,b) 85 #define xlog_verify_grant_tail(a) 86 #define xlog_verify_iclog(a,b,c) 87 #define xlog_verify_tail_lsn(a,b,c) 88 #endif 89 90 STATIC int 91 xlog_iclogs_empty( 92 struct xlog *log); 93 94 static void 95 xlog_grant_sub_space( 96 struct xlog *log, 97 atomic64_t *head, 98 int bytes) 99 { 100 int64_t head_val = atomic64_read(head); 101 int64_t new, old; 102 103 do { 104 int cycle, space; 105 106 xlog_crack_grant_head_val(head_val, &cycle, &space); 107 108 space -= bytes; 109 if (space < 0) { 110 space += log->l_logsize; 111 cycle--; 112 } 113 114 old = head_val; 115 new = xlog_assign_grant_head_val(cycle, space); 116 head_val = atomic64_cmpxchg(head, old, new); 117 } while (head_val != old); 118 } 119 120 static void 121 xlog_grant_add_space( 122 struct xlog *log, 123 atomic64_t *head, 124 int bytes) 125 { 126 int64_t head_val = atomic64_read(head); 127 int64_t new, old; 128 129 do { 130 int tmp; 131 int cycle, space; 132 133 xlog_crack_grant_head_val(head_val, &cycle, &space); 134 135 tmp = log->l_logsize - space; 136 if (tmp > bytes) 137 space += bytes; 138 else { 139 space = bytes - tmp; 140 cycle++; 141 } 142 143 old = head_val; 144 new = xlog_assign_grant_head_val(cycle, space); 145 head_val = atomic64_cmpxchg(head, old, new); 146 } while (head_val != old); 147 } 148 149 STATIC void 150 xlog_grant_head_init( 151 struct xlog_grant_head *head) 152 { 153 xlog_assign_grant_head(&head->grant, 1, 0); 154 INIT_LIST_HEAD(&head->waiters); 155 spin_lock_init(&head->lock); 156 } 157 158 STATIC void 159 xlog_grant_head_wake_all( 160 struct xlog_grant_head *head) 161 { 162 struct xlog_ticket *tic; 163 164 spin_lock(&head->lock); 165 list_for_each_entry(tic, &head->waiters, t_queue) 166 wake_up_process(tic->t_task); 167 spin_unlock(&head->lock); 168 } 169 170 static inline int 171 xlog_ticket_reservation( 172 struct xlog *log, 173 struct xlog_grant_head *head, 174 struct xlog_ticket *tic) 175 { 176 if (head == &log->l_write_head) { 177 ASSERT(tic->t_flags & XLOG_TIC_PERM_RESERV); 178 return tic->t_unit_res; 179 } else { 180 if (tic->t_flags & XLOG_TIC_PERM_RESERV) 181 return tic->t_unit_res * tic->t_cnt; 182 else 183 return tic->t_unit_res; 184 } 185 } 186 187 STATIC bool 188 xlog_grant_head_wake( 189 struct xlog *log, 190 struct xlog_grant_head *head, 191 int *free_bytes) 192 { 193 struct xlog_ticket *tic; 194 int need_bytes; 195 bool woken_task = false; 196 197 list_for_each_entry(tic, &head->waiters, t_queue) { 198 199 /* 200 * There is a chance that the size of the CIL checkpoints in 201 * progress at the last AIL push target calculation resulted in 202 * limiting the target to the log head (l_last_sync_lsn) at the 203 * time. This may not reflect where the log head is now as the 204 * CIL checkpoints may have completed. 205 * 206 * Hence when we are woken here, it may be that the head of the 207 * log that has moved rather than the tail. As the tail didn't 208 * move, there still won't be space available for the 209 * reservation we require. However, if the AIL has already 210 * pushed to the target defined by the old log head location, we 211 * will hang here waiting for something else to update the AIL 212 * push target. 213 * 214 * Therefore, if there isn't space to wake the first waiter on 215 * the grant head, we need to push the AIL again to ensure the 216 * target reflects both the current log tail and log head 217 * position before we wait for the tail to move again. 218 */ 219 220 need_bytes = xlog_ticket_reservation(log, head, tic); 221 if (*free_bytes < need_bytes) { 222 if (!woken_task) 223 xlog_grant_push_ail(log, need_bytes); 224 return false; 225 } 226 227 *free_bytes -= need_bytes; 228 trace_xfs_log_grant_wake_up(log, tic); 229 wake_up_process(tic->t_task); 230 woken_task = true; 231 } 232 233 return true; 234 } 235 236 STATIC int 237 xlog_grant_head_wait( 238 struct xlog *log, 239 struct xlog_grant_head *head, 240 struct xlog_ticket *tic, 241 int need_bytes) __releases(&head->lock) 242 __acquires(&head->lock) 243 { 244 list_add_tail(&tic->t_queue, &head->waiters); 245 246 do { 247 if (XLOG_FORCED_SHUTDOWN(log)) 248 goto shutdown; 249 xlog_grant_push_ail(log, need_bytes); 250 251 __set_current_state(TASK_UNINTERRUPTIBLE); 252 spin_unlock(&head->lock); 253 254 XFS_STATS_INC(log->l_mp, xs_sleep_logspace); 255 256 trace_xfs_log_grant_sleep(log, tic); 257 schedule(); 258 trace_xfs_log_grant_wake(log, tic); 259 260 spin_lock(&head->lock); 261 if (XLOG_FORCED_SHUTDOWN(log)) 262 goto shutdown; 263 } while (xlog_space_left(log, &head->grant) < need_bytes); 264 265 list_del_init(&tic->t_queue); 266 return 0; 267 shutdown: 268 list_del_init(&tic->t_queue); 269 return -EIO; 270 } 271 272 /* 273 * Atomically get the log space required for a log ticket. 274 * 275 * Once a ticket gets put onto head->waiters, it will only return after the 276 * needed reservation is satisfied. 277 * 278 * This function is structured so that it has a lock free fast path. This is 279 * necessary because every new transaction reservation will come through this 280 * path. Hence any lock will be globally hot if we take it unconditionally on 281 * every pass. 282 * 283 * As tickets are only ever moved on and off head->waiters under head->lock, we 284 * only need to take that lock if we are going to add the ticket to the queue 285 * and sleep. We can avoid taking the lock if the ticket was never added to 286 * head->waiters because the t_queue list head will be empty and we hold the 287 * only reference to it so it can safely be checked unlocked. 288 */ 289 STATIC int 290 xlog_grant_head_check( 291 struct xlog *log, 292 struct xlog_grant_head *head, 293 struct xlog_ticket *tic, 294 int *need_bytes) 295 { 296 int free_bytes; 297 int error = 0; 298 299 ASSERT(!(log->l_flags & XLOG_ACTIVE_RECOVERY)); 300 301 /* 302 * If there are other waiters on the queue then give them a chance at 303 * logspace before us. Wake up the first waiters, if we do not wake 304 * up all the waiters then go to sleep waiting for more free space, 305 * otherwise try to get some space for this transaction. 306 */ 307 *need_bytes = xlog_ticket_reservation(log, head, tic); 308 free_bytes = xlog_space_left(log, &head->grant); 309 if (!list_empty_careful(&head->waiters)) { 310 spin_lock(&head->lock); 311 if (!xlog_grant_head_wake(log, head, &free_bytes) || 312 free_bytes < *need_bytes) { 313 error = xlog_grant_head_wait(log, head, tic, 314 *need_bytes); 315 } 316 spin_unlock(&head->lock); 317 } else if (free_bytes < *need_bytes) { 318 spin_lock(&head->lock); 319 error = xlog_grant_head_wait(log, head, tic, *need_bytes); 320 spin_unlock(&head->lock); 321 } 322 323 return error; 324 } 325 326 static void 327 xlog_tic_reset_res(xlog_ticket_t *tic) 328 { 329 tic->t_res_num = 0; 330 tic->t_res_arr_sum = 0; 331 tic->t_res_num_ophdrs = 0; 332 } 333 334 static void 335 xlog_tic_add_region(xlog_ticket_t *tic, uint len, uint type) 336 { 337 if (tic->t_res_num == XLOG_TIC_LEN_MAX) { 338 /* add to overflow and start again */ 339 tic->t_res_o_flow += tic->t_res_arr_sum; 340 tic->t_res_num = 0; 341 tic->t_res_arr_sum = 0; 342 } 343 344 tic->t_res_arr[tic->t_res_num].r_len = len; 345 tic->t_res_arr[tic->t_res_num].r_type = type; 346 tic->t_res_arr_sum += len; 347 tic->t_res_num++; 348 } 349 350 /* 351 * Replenish the byte reservation required by moving the grant write head. 352 */ 353 int 354 xfs_log_regrant( 355 struct xfs_mount *mp, 356 struct xlog_ticket *tic) 357 { 358 struct xlog *log = mp->m_log; 359 int need_bytes; 360 int error = 0; 361 362 if (XLOG_FORCED_SHUTDOWN(log)) 363 return -EIO; 364 365 XFS_STATS_INC(mp, xs_try_logspace); 366 367 /* 368 * This is a new transaction on the ticket, so we need to change the 369 * transaction ID so that the next transaction has a different TID in 370 * the log. Just add one to the existing tid so that we can see chains 371 * of rolling transactions in the log easily. 372 */ 373 tic->t_tid++; 374 375 xlog_grant_push_ail(log, tic->t_unit_res); 376 377 tic->t_curr_res = tic->t_unit_res; 378 xlog_tic_reset_res(tic); 379 380 if (tic->t_cnt > 0) 381 return 0; 382 383 trace_xfs_log_regrant(log, tic); 384 385 error = xlog_grant_head_check(log, &log->l_write_head, tic, 386 &need_bytes); 387 if (error) 388 goto out_error; 389 390 xlog_grant_add_space(log, &log->l_write_head.grant, need_bytes); 391 trace_xfs_log_regrant_exit(log, tic); 392 xlog_verify_grant_tail(log); 393 return 0; 394 395 out_error: 396 /* 397 * If we are failing, make sure the ticket doesn't have any current 398 * reservations. We don't want to add this back when the ticket/ 399 * transaction gets cancelled. 400 */ 401 tic->t_curr_res = 0; 402 tic->t_cnt = 0; /* ungrant will give back unit_res * t_cnt. */ 403 return error; 404 } 405 406 /* 407 * Reserve log space and return a ticket corresponding to the reservation. 408 * 409 * Each reservation is going to reserve extra space for a log record header. 410 * When writes happen to the on-disk log, we don't subtract the length of the 411 * log record header from any reservation. By wasting space in each 412 * reservation, we prevent over allocation problems. 413 */ 414 int 415 xfs_log_reserve( 416 struct xfs_mount *mp, 417 int unit_bytes, 418 int cnt, 419 struct xlog_ticket **ticp, 420 uint8_t client, 421 bool permanent) 422 { 423 struct xlog *log = mp->m_log; 424 struct xlog_ticket *tic; 425 int need_bytes; 426 int error = 0; 427 428 ASSERT(client == XFS_TRANSACTION || client == XFS_LOG); 429 430 if (XLOG_FORCED_SHUTDOWN(log)) 431 return -EIO; 432 433 XFS_STATS_INC(mp, xs_try_logspace); 434 435 ASSERT(*ticp == NULL); 436 tic = xlog_ticket_alloc(log, unit_bytes, cnt, client, permanent, 0); 437 *ticp = tic; 438 439 xlog_grant_push_ail(log, tic->t_cnt ? tic->t_unit_res * tic->t_cnt 440 : tic->t_unit_res); 441 442 trace_xfs_log_reserve(log, tic); 443 444 error = xlog_grant_head_check(log, &log->l_reserve_head, tic, 445 &need_bytes); 446 if (error) 447 goto out_error; 448 449 xlog_grant_add_space(log, &log->l_reserve_head.grant, need_bytes); 450 xlog_grant_add_space(log, &log->l_write_head.grant, need_bytes); 451 trace_xfs_log_reserve_exit(log, tic); 452 xlog_verify_grant_tail(log); 453 return 0; 454 455 out_error: 456 /* 457 * If we are failing, make sure the ticket doesn't have any current 458 * reservations. We don't want to add this back when the ticket/ 459 * transaction gets cancelled. 460 */ 461 tic->t_curr_res = 0; 462 tic->t_cnt = 0; /* ungrant will give back unit_res * t_cnt. */ 463 return error; 464 } 465 466 static bool 467 __xlog_state_release_iclog( 468 struct xlog *log, 469 struct xlog_in_core *iclog) 470 { 471 lockdep_assert_held(&log->l_icloglock); 472 473 if (iclog->ic_state == XLOG_STATE_WANT_SYNC) { 474 /* update tail before writing to iclog */ 475 xfs_lsn_t tail_lsn = xlog_assign_tail_lsn(log->l_mp); 476 477 iclog->ic_state = XLOG_STATE_SYNCING; 478 iclog->ic_header.h_tail_lsn = cpu_to_be64(tail_lsn); 479 xlog_verify_tail_lsn(log, iclog, tail_lsn); 480 /* cycle incremented when incrementing curr_block */ 481 return true; 482 } 483 484 ASSERT(iclog->ic_state == XLOG_STATE_ACTIVE); 485 return false; 486 } 487 488 /* 489 * Flush iclog to disk if this is the last reference to the given iclog and the 490 * it is in the WANT_SYNC state. 491 */ 492 static int 493 xlog_state_release_iclog( 494 struct xlog *log, 495 struct xlog_in_core *iclog) 496 { 497 lockdep_assert_held(&log->l_icloglock); 498 499 if (iclog->ic_state == XLOG_STATE_IOERROR) 500 return -EIO; 501 502 if (atomic_dec_and_test(&iclog->ic_refcnt) && 503 __xlog_state_release_iclog(log, iclog)) { 504 spin_unlock(&log->l_icloglock); 505 xlog_sync(log, iclog); 506 spin_lock(&log->l_icloglock); 507 } 508 509 return 0; 510 } 511 512 void 513 xfs_log_release_iclog( 514 struct xlog_in_core *iclog) 515 { 516 struct xlog *log = iclog->ic_log; 517 bool sync = false; 518 519 if (atomic_dec_and_lock(&iclog->ic_refcnt, &log->l_icloglock)) { 520 if (iclog->ic_state != XLOG_STATE_IOERROR) 521 sync = __xlog_state_release_iclog(log, iclog); 522 spin_unlock(&log->l_icloglock); 523 } 524 525 if (sync) 526 xlog_sync(log, iclog); 527 } 528 529 /* 530 * Mount a log filesystem 531 * 532 * mp - ubiquitous xfs mount point structure 533 * log_target - buftarg of on-disk log device 534 * blk_offset - Start block # where block size is 512 bytes (BBSIZE) 535 * num_bblocks - Number of BBSIZE blocks in on-disk log 536 * 537 * Return error or zero. 538 */ 539 int 540 xfs_log_mount( 541 xfs_mount_t *mp, 542 xfs_buftarg_t *log_target, 543 xfs_daddr_t blk_offset, 544 int num_bblks) 545 { 546 bool fatal = xfs_sb_version_hascrc(&mp->m_sb); 547 int error = 0; 548 int min_logfsbs; 549 550 if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) { 551 xfs_notice(mp, "Mounting V%d Filesystem", 552 XFS_SB_VERSION_NUM(&mp->m_sb)); 553 } else { 554 xfs_notice(mp, 555 "Mounting V%d filesystem in no-recovery mode. Filesystem will be inconsistent.", 556 XFS_SB_VERSION_NUM(&mp->m_sb)); 557 ASSERT(mp->m_flags & XFS_MOUNT_RDONLY); 558 } 559 560 mp->m_log = xlog_alloc_log(mp, log_target, blk_offset, num_bblks); 561 if (IS_ERR(mp->m_log)) { 562 error = PTR_ERR(mp->m_log); 563 goto out; 564 } 565 566 /* 567 * Validate the given log space and drop a critical message via syslog 568 * if the log size is too small that would lead to some unexpected 569 * situations in transaction log space reservation stage. 570 * 571 * Note: we can't just reject the mount if the validation fails. This 572 * would mean that people would have to downgrade their kernel just to 573 * remedy the situation as there is no way to grow the log (short of 574 * black magic surgery with xfs_db). 575 * 576 * We can, however, reject mounts for CRC format filesystems, as the 577 * mkfs binary being used to make the filesystem should never create a 578 * filesystem with a log that is too small. 579 */ 580 min_logfsbs = xfs_log_calc_minimum_size(mp); 581 582 if (mp->m_sb.sb_logblocks < min_logfsbs) { 583 xfs_warn(mp, 584 "Log size %d blocks too small, minimum size is %d blocks", 585 mp->m_sb.sb_logblocks, min_logfsbs); 586 error = -EINVAL; 587 } else if (mp->m_sb.sb_logblocks > XFS_MAX_LOG_BLOCKS) { 588 xfs_warn(mp, 589 "Log size %d blocks too large, maximum size is %lld blocks", 590 mp->m_sb.sb_logblocks, XFS_MAX_LOG_BLOCKS); 591 error = -EINVAL; 592 } else if (XFS_FSB_TO_B(mp, mp->m_sb.sb_logblocks) > XFS_MAX_LOG_BYTES) { 593 xfs_warn(mp, 594 "log size %lld bytes too large, maximum size is %lld bytes", 595 XFS_FSB_TO_B(mp, mp->m_sb.sb_logblocks), 596 XFS_MAX_LOG_BYTES); 597 error = -EINVAL; 598 } else if (mp->m_sb.sb_logsunit > 1 && 599 mp->m_sb.sb_logsunit % mp->m_sb.sb_blocksize) { 600 xfs_warn(mp, 601 "log stripe unit %u bytes must be a multiple of block size", 602 mp->m_sb.sb_logsunit); 603 error = -EINVAL; 604 fatal = true; 605 } 606 if (error) { 607 /* 608 * Log check errors are always fatal on v5; or whenever bad 609 * metadata leads to a crash. 610 */ 611 if (fatal) { 612 xfs_crit(mp, "AAIEEE! Log failed size checks. Abort!"); 613 ASSERT(0); 614 goto out_free_log; 615 } 616 xfs_crit(mp, "Log size out of supported range."); 617 xfs_crit(mp, 618 "Continuing onwards, but if log hangs are experienced then please report this message in the bug report."); 619 } 620 621 /* 622 * Initialize the AIL now we have a log. 623 */ 624 error = xfs_trans_ail_init(mp); 625 if (error) { 626 xfs_warn(mp, "AIL initialisation failed: error %d", error); 627 goto out_free_log; 628 } 629 mp->m_log->l_ailp = mp->m_ail; 630 631 /* 632 * skip log recovery on a norecovery mount. pretend it all 633 * just worked. 634 */ 635 if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) { 636 int readonly = (mp->m_flags & XFS_MOUNT_RDONLY); 637 638 if (readonly) 639 mp->m_flags &= ~XFS_MOUNT_RDONLY; 640 641 error = xlog_recover(mp->m_log); 642 643 if (readonly) 644 mp->m_flags |= XFS_MOUNT_RDONLY; 645 if (error) { 646 xfs_warn(mp, "log mount/recovery failed: error %d", 647 error); 648 xlog_recover_cancel(mp->m_log); 649 goto out_destroy_ail; 650 } 651 } 652 653 error = xfs_sysfs_init(&mp->m_log->l_kobj, &xfs_log_ktype, &mp->m_kobj, 654 "log"); 655 if (error) 656 goto out_destroy_ail; 657 658 /* Normal transactions can now occur */ 659 mp->m_log->l_flags &= ~XLOG_ACTIVE_RECOVERY; 660 661 /* 662 * Now the log has been fully initialised and we know were our 663 * space grant counters are, we can initialise the permanent ticket 664 * needed for delayed logging to work. 665 */ 666 xlog_cil_init_post_recovery(mp->m_log); 667 668 return 0; 669 670 out_destroy_ail: 671 xfs_trans_ail_destroy(mp); 672 out_free_log: 673 xlog_dealloc_log(mp->m_log); 674 out: 675 return error; 676 } 677 678 /* 679 * Finish the recovery of the file system. This is separate from the 680 * xfs_log_mount() call, because it depends on the code in xfs_mountfs() to read 681 * in the root and real-time bitmap inodes between calling xfs_log_mount() and 682 * here. 683 * 684 * If we finish recovery successfully, start the background log work. If we are 685 * not doing recovery, then we have a RO filesystem and we don't need to start 686 * it. 687 */ 688 int 689 xfs_log_mount_finish( 690 struct xfs_mount *mp) 691 { 692 int error = 0; 693 bool readonly = (mp->m_flags & XFS_MOUNT_RDONLY); 694 bool recovered = mp->m_log->l_flags & XLOG_RECOVERY_NEEDED; 695 696 if (mp->m_flags & XFS_MOUNT_NORECOVERY) { 697 ASSERT(mp->m_flags & XFS_MOUNT_RDONLY); 698 return 0; 699 } else if (readonly) { 700 /* Allow unlinked processing to proceed */ 701 mp->m_flags &= ~XFS_MOUNT_RDONLY; 702 } 703 704 /* 705 * During the second phase of log recovery, we need iget and 706 * iput to behave like they do for an active filesystem. 707 * xfs_fs_drop_inode needs to be able to prevent the deletion 708 * of inodes before we're done replaying log items on those 709 * inodes. Turn it off immediately after recovery finishes 710 * so that we don't leak the quota inodes if subsequent mount 711 * activities fail. 712 * 713 * We let all inodes involved in redo item processing end up on 714 * the LRU instead of being evicted immediately so that if we do 715 * something to an unlinked inode, the irele won't cause 716 * premature truncation and freeing of the inode, which results 717 * in log recovery failure. We have to evict the unreferenced 718 * lru inodes after clearing SB_ACTIVE because we don't 719 * otherwise clean up the lru if there's a subsequent failure in 720 * xfs_mountfs, which leads to us leaking the inodes if nothing 721 * else (e.g. quotacheck) references the inodes before the 722 * mount failure occurs. 723 */ 724 mp->m_super->s_flags |= SB_ACTIVE; 725 error = xlog_recover_finish(mp->m_log); 726 if (!error) 727 xfs_log_work_queue(mp); 728 mp->m_super->s_flags &= ~SB_ACTIVE; 729 evict_inodes(mp->m_super); 730 731 /* 732 * Drain the buffer LRU after log recovery. This is required for v4 733 * filesystems to avoid leaving around buffers with NULL verifier ops, 734 * but we do it unconditionally to make sure we're always in a clean 735 * cache state after mount. 736 * 737 * Don't push in the error case because the AIL may have pending intents 738 * that aren't removed until recovery is cancelled. 739 */ 740 if (!error && recovered) { 741 xfs_log_force(mp, XFS_LOG_SYNC); 742 xfs_ail_push_all_sync(mp->m_ail); 743 } 744 xfs_wait_buftarg(mp->m_ddev_targp); 745 746 if (readonly) 747 mp->m_flags |= XFS_MOUNT_RDONLY; 748 749 return error; 750 } 751 752 /* 753 * The mount has failed. Cancel the recovery if it hasn't completed and destroy 754 * the log. 755 */ 756 void 757 xfs_log_mount_cancel( 758 struct xfs_mount *mp) 759 { 760 xlog_recover_cancel(mp->m_log); 761 xfs_log_unmount(mp); 762 } 763 764 /* 765 * Wait for the iclog to be written disk, or return an error if the log has been 766 * shut down. 767 */ 768 static int 769 xlog_wait_on_iclog( 770 struct xlog_in_core *iclog) 771 __releases(iclog->ic_log->l_icloglock) 772 { 773 struct xlog *log = iclog->ic_log; 774 775 if (!XLOG_FORCED_SHUTDOWN(log) && 776 iclog->ic_state != XLOG_STATE_ACTIVE && 777 iclog->ic_state != XLOG_STATE_DIRTY) { 778 XFS_STATS_INC(log->l_mp, xs_log_force_sleep); 779 xlog_wait(&iclog->ic_force_wait, &log->l_icloglock); 780 } else { 781 spin_unlock(&log->l_icloglock); 782 } 783 784 if (XLOG_FORCED_SHUTDOWN(log)) 785 return -EIO; 786 return 0; 787 } 788 789 /* 790 * Write out an unmount record using the ticket provided. We have to account for 791 * the data space used in the unmount ticket as this write is not done from a 792 * transaction context that has already done the accounting for us. 793 */ 794 static int 795 xlog_write_unmount_record( 796 struct xlog *log, 797 struct xlog_ticket *ticket, 798 xfs_lsn_t *lsn, 799 uint flags) 800 { 801 struct xfs_unmount_log_format ulf = { 802 .magic = XLOG_UNMOUNT_TYPE, 803 }; 804 struct xfs_log_iovec reg = { 805 .i_addr = &ulf, 806 .i_len = sizeof(ulf), 807 .i_type = XLOG_REG_TYPE_UNMOUNT, 808 }; 809 struct xfs_log_vec vec = { 810 .lv_niovecs = 1, 811 .lv_iovecp = ®, 812 }; 813 814 /* account for space used by record data */ 815 ticket->t_curr_res -= sizeof(ulf); 816 return xlog_write(log, &vec, ticket, lsn, NULL, flags, false); 817 } 818 819 /* 820 * Mark the filesystem clean by writing an unmount record to the head of the 821 * log. 822 */ 823 static void 824 xlog_unmount_write( 825 struct xlog *log) 826 { 827 struct xfs_mount *mp = log->l_mp; 828 struct xlog_in_core *iclog; 829 struct xlog_ticket *tic = NULL; 830 xfs_lsn_t lsn; 831 uint flags = XLOG_UNMOUNT_TRANS; 832 int error; 833 834 error = xfs_log_reserve(mp, 600, 1, &tic, XFS_LOG, 0); 835 if (error) 836 goto out_err; 837 838 error = xlog_write_unmount_record(log, tic, &lsn, flags); 839 /* 840 * At this point, we're umounting anyway, so there's no point in 841 * transitioning log state to IOERROR. Just continue... 842 */ 843 out_err: 844 if (error) 845 xfs_alert(mp, "%s: unmount record failed", __func__); 846 847 spin_lock(&log->l_icloglock); 848 iclog = log->l_iclog; 849 atomic_inc(&iclog->ic_refcnt); 850 if (iclog->ic_state == XLOG_STATE_ACTIVE) 851 xlog_state_switch_iclogs(log, iclog, 0); 852 else 853 ASSERT(iclog->ic_state == XLOG_STATE_WANT_SYNC || 854 iclog->ic_state == XLOG_STATE_IOERROR); 855 error = xlog_state_release_iclog(log, iclog); 856 xlog_wait_on_iclog(iclog); 857 858 if (tic) { 859 trace_xfs_log_umount_write(log, tic); 860 xfs_log_ticket_ungrant(log, tic); 861 } 862 } 863 864 static void 865 xfs_log_unmount_verify_iclog( 866 struct xlog *log) 867 { 868 struct xlog_in_core *iclog = log->l_iclog; 869 870 do { 871 ASSERT(iclog->ic_state == XLOG_STATE_ACTIVE); 872 ASSERT(iclog->ic_offset == 0); 873 } while ((iclog = iclog->ic_next) != log->l_iclog); 874 } 875 876 /* 877 * Unmount record used to have a string "Unmount filesystem--" in the 878 * data section where the "Un" was really a magic number (XLOG_UNMOUNT_TYPE). 879 * We just write the magic number now since that particular field isn't 880 * currently architecture converted and "Unmount" is a bit foo. 881 * As far as I know, there weren't any dependencies on the old behaviour. 882 */ 883 static void 884 xfs_log_unmount_write( 885 struct xfs_mount *mp) 886 { 887 struct xlog *log = mp->m_log; 888 889 /* 890 * Don't write out unmount record on norecovery mounts or ro devices. 891 * Or, if we are doing a forced umount (typically because of IO errors). 892 */ 893 if (mp->m_flags & XFS_MOUNT_NORECOVERY || 894 xfs_readonly_buftarg(log->l_targ)) { 895 ASSERT(mp->m_flags & XFS_MOUNT_RDONLY); 896 return; 897 } 898 899 xfs_log_force(mp, XFS_LOG_SYNC); 900 901 if (XLOG_FORCED_SHUTDOWN(log)) 902 return; 903 904 /* 905 * If we think the summary counters are bad, avoid writing the unmount 906 * record to force log recovery at next mount, after which the summary 907 * counters will be recalculated. Refer to xlog_check_unmount_rec for 908 * more details. 909 */ 910 if (XFS_TEST_ERROR(xfs_fs_has_sickness(mp, XFS_SICK_FS_COUNTERS), mp, 911 XFS_ERRTAG_FORCE_SUMMARY_RECALC)) { 912 xfs_alert(mp, "%s: will fix summary counters at next mount", 913 __func__); 914 return; 915 } 916 917 xfs_log_unmount_verify_iclog(log); 918 xlog_unmount_write(log); 919 } 920 921 /* 922 * Empty the log for unmount/freeze. 923 * 924 * To do this, we first need to shut down the background log work so it is not 925 * trying to cover the log as we clean up. We then need to unpin all objects in 926 * the log so we can then flush them out. Once they have completed their IO and 927 * run the callbacks removing themselves from the AIL, we can write the unmount 928 * record. 929 */ 930 void 931 xfs_log_quiesce( 932 struct xfs_mount *mp) 933 { 934 cancel_delayed_work_sync(&mp->m_log->l_work); 935 xfs_log_force(mp, XFS_LOG_SYNC); 936 937 /* 938 * The superblock buffer is uncached and while xfs_ail_push_all_sync() 939 * will push it, xfs_wait_buftarg() will not wait for it. Further, 940 * xfs_buf_iowait() cannot be used because it was pushed with the 941 * XBF_ASYNC flag set, so we need to use a lock/unlock pair to wait for 942 * the IO to complete. 943 */ 944 xfs_ail_push_all_sync(mp->m_ail); 945 xfs_wait_buftarg(mp->m_ddev_targp); 946 xfs_buf_lock(mp->m_sb_bp); 947 xfs_buf_unlock(mp->m_sb_bp); 948 949 xfs_log_unmount_write(mp); 950 } 951 952 /* 953 * Shut down and release the AIL and Log. 954 * 955 * During unmount, we need to ensure we flush all the dirty metadata objects 956 * from the AIL so that the log is empty before we write the unmount record to 957 * the log. Once this is done, we can tear down the AIL and the log. 958 */ 959 void 960 xfs_log_unmount( 961 struct xfs_mount *mp) 962 { 963 xfs_log_quiesce(mp); 964 965 xfs_trans_ail_destroy(mp); 966 967 xfs_sysfs_del(&mp->m_log->l_kobj); 968 969 xlog_dealloc_log(mp->m_log); 970 } 971 972 void 973 xfs_log_item_init( 974 struct xfs_mount *mp, 975 struct xfs_log_item *item, 976 int type, 977 const struct xfs_item_ops *ops) 978 { 979 item->li_mountp = mp; 980 item->li_ailp = mp->m_ail; 981 item->li_type = type; 982 item->li_ops = ops; 983 item->li_lv = NULL; 984 985 INIT_LIST_HEAD(&item->li_ail); 986 INIT_LIST_HEAD(&item->li_cil); 987 INIT_LIST_HEAD(&item->li_bio_list); 988 INIT_LIST_HEAD(&item->li_trans); 989 } 990 991 /* 992 * Wake up processes waiting for log space after we have moved the log tail. 993 */ 994 void 995 xfs_log_space_wake( 996 struct xfs_mount *mp) 997 { 998 struct xlog *log = mp->m_log; 999 int free_bytes; 1000 1001 if (XLOG_FORCED_SHUTDOWN(log)) 1002 return; 1003 1004 if (!list_empty_careful(&log->l_write_head.waiters)) { 1005 ASSERT(!(log->l_flags & XLOG_ACTIVE_RECOVERY)); 1006 1007 spin_lock(&log->l_write_head.lock); 1008 free_bytes = xlog_space_left(log, &log->l_write_head.grant); 1009 xlog_grant_head_wake(log, &log->l_write_head, &free_bytes); 1010 spin_unlock(&log->l_write_head.lock); 1011 } 1012 1013 if (!list_empty_careful(&log->l_reserve_head.waiters)) { 1014 ASSERT(!(log->l_flags & XLOG_ACTIVE_RECOVERY)); 1015 1016 spin_lock(&log->l_reserve_head.lock); 1017 free_bytes = xlog_space_left(log, &log->l_reserve_head.grant); 1018 xlog_grant_head_wake(log, &log->l_reserve_head, &free_bytes); 1019 spin_unlock(&log->l_reserve_head.lock); 1020 } 1021 } 1022 1023 /* 1024 * Determine if we have a transaction that has gone to disk that needs to be 1025 * covered. To begin the transition to the idle state firstly the log needs to 1026 * be idle. That means the CIL, the AIL and the iclogs needs to be empty before 1027 * we start attempting to cover the log. 1028 * 1029 * Only if we are then in a state where covering is needed, the caller is 1030 * informed that dummy transactions are required to move the log into the idle 1031 * state. 1032 * 1033 * If there are any items in the AIl or CIL, then we do not want to attempt to 1034 * cover the log as we may be in a situation where there isn't log space 1035 * available to run a dummy transaction and this can lead to deadlocks when the 1036 * tail of the log is pinned by an item that is modified in the CIL. Hence 1037 * there's no point in running a dummy transaction at this point because we 1038 * can't start trying to idle the log until both the CIL and AIL are empty. 1039 */ 1040 static int 1041 xfs_log_need_covered(xfs_mount_t *mp) 1042 { 1043 struct xlog *log = mp->m_log; 1044 int needed = 0; 1045 1046 if (!xfs_fs_writable(mp, SB_FREEZE_WRITE)) 1047 return 0; 1048 1049 if (!xlog_cil_empty(log)) 1050 return 0; 1051 1052 spin_lock(&log->l_icloglock); 1053 switch (log->l_covered_state) { 1054 case XLOG_STATE_COVER_DONE: 1055 case XLOG_STATE_COVER_DONE2: 1056 case XLOG_STATE_COVER_IDLE: 1057 break; 1058 case XLOG_STATE_COVER_NEED: 1059 case XLOG_STATE_COVER_NEED2: 1060 if (xfs_ail_min_lsn(log->l_ailp)) 1061 break; 1062 if (!xlog_iclogs_empty(log)) 1063 break; 1064 1065 needed = 1; 1066 if (log->l_covered_state == XLOG_STATE_COVER_NEED) 1067 log->l_covered_state = XLOG_STATE_COVER_DONE; 1068 else 1069 log->l_covered_state = XLOG_STATE_COVER_DONE2; 1070 break; 1071 default: 1072 needed = 1; 1073 break; 1074 } 1075 spin_unlock(&log->l_icloglock); 1076 return needed; 1077 } 1078 1079 /* 1080 * We may be holding the log iclog lock upon entering this routine. 1081 */ 1082 xfs_lsn_t 1083 xlog_assign_tail_lsn_locked( 1084 struct xfs_mount *mp) 1085 { 1086 struct xlog *log = mp->m_log; 1087 struct xfs_log_item *lip; 1088 xfs_lsn_t tail_lsn; 1089 1090 assert_spin_locked(&mp->m_ail->ail_lock); 1091 1092 /* 1093 * To make sure we always have a valid LSN for the log tail we keep 1094 * track of the last LSN which was committed in log->l_last_sync_lsn, 1095 * and use that when the AIL was empty. 1096 */ 1097 lip = xfs_ail_min(mp->m_ail); 1098 if (lip) 1099 tail_lsn = lip->li_lsn; 1100 else 1101 tail_lsn = atomic64_read(&log->l_last_sync_lsn); 1102 trace_xfs_log_assign_tail_lsn(log, tail_lsn); 1103 atomic64_set(&log->l_tail_lsn, tail_lsn); 1104 return tail_lsn; 1105 } 1106 1107 xfs_lsn_t 1108 xlog_assign_tail_lsn( 1109 struct xfs_mount *mp) 1110 { 1111 xfs_lsn_t tail_lsn; 1112 1113 spin_lock(&mp->m_ail->ail_lock); 1114 tail_lsn = xlog_assign_tail_lsn_locked(mp); 1115 spin_unlock(&mp->m_ail->ail_lock); 1116 1117 return tail_lsn; 1118 } 1119 1120 /* 1121 * Return the space in the log between the tail and the head. The head 1122 * is passed in the cycle/bytes formal parms. In the special case where 1123 * the reserve head has wrapped passed the tail, this calculation is no 1124 * longer valid. In this case, just return 0 which means there is no space 1125 * in the log. This works for all places where this function is called 1126 * with the reserve head. Of course, if the write head were to ever 1127 * wrap the tail, we should blow up. Rather than catch this case here, 1128 * we depend on other ASSERTions in other parts of the code. XXXmiken 1129 * 1130 * This code also handles the case where the reservation head is behind 1131 * the tail. The details of this case are described below, but the end 1132 * result is that we return the size of the log as the amount of space left. 1133 */ 1134 STATIC int 1135 xlog_space_left( 1136 struct xlog *log, 1137 atomic64_t *head) 1138 { 1139 int free_bytes; 1140 int tail_bytes; 1141 int tail_cycle; 1142 int head_cycle; 1143 int head_bytes; 1144 1145 xlog_crack_grant_head(head, &head_cycle, &head_bytes); 1146 xlog_crack_atomic_lsn(&log->l_tail_lsn, &tail_cycle, &tail_bytes); 1147 tail_bytes = BBTOB(tail_bytes); 1148 if (tail_cycle == head_cycle && head_bytes >= tail_bytes) 1149 free_bytes = log->l_logsize - (head_bytes - tail_bytes); 1150 else if (tail_cycle + 1 < head_cycle) 1151 return 0; 1152 else if (tail_cycle < head_cycle) { 1153 ASSERT(tail_cycle == (head_cycle - 1)); 1154 free_bytes = tail_bytes - head_bytes; 1155 } else { 1156 /* 1157 * The reservation head is behind the tail. 1158 * In this case we just want to return the size of the 1159 * log as the amount of space left. 1160 */ 1161 xfs_alert(log->l_mp, "xlog_space_left: head behind tail"); 1162 xfs_alert(log->l_mp, 1163 " tail_cycle = %d, tail_bytes = %d", 1164 tail_cycle, tail_bytes); 1165 xfs_alert(log->l_mp, 1166 " GH cycle = %d, GH bytes = %d", 1167 head_cycle, head_bytes); 1168 ASSERT(0); 1169 free_bytes = log->l_logsize; 1170 } 1171 return free_bytes; 1172 } 1173 1174 1175 static void 1176 xlog_ioend_work( 1177 struct work_struct *work) 1178 { 1179 struct xlog_in_core *iclog = 1180 container_of(work, struct xlog_in_core, ic_end_io_work); 1181 struct xlog *log = iclog->ic_log; 1182 int error; 1183 1184 error = blk_status_to_errno(iclog->ic_bio.bi_status); 1185 #ifdef DEBUG 1186 /* treat writes with injected CRC errors as failed */ 1187 if (iclog->ic_fail_crc) 1188 error = -EIO; 1189 #endif 1190 1191 /* 1192 * Race to shutdown the filesystem if we see an error. 1193 */ 1194 if (XFS_TEST_ERROR(error, log->l_mp, XFS_ERRTAG_IODONE_IOERR)) { 1195 xfs_alert(log->l_mp, "log I/O error %d", error); 1196 xfs_force_shutdown(log->l_mp, SHUTDOWN_LOG_IO_ERROR); 1197 } 1198 1199 xlog_state_done_syncing(iclog); 1200 bio_uninit(&iclog->ic_bio); 1201 1202 /* 1203 * Drop the lock to signal that we are done. Nothing references the 1204 * iclog after this, so an unmount waiting on this lock can now tear it 1205 * down safely. As such, it is unsafe to reference the iclog after the 1206 * unlock as we could race with it being freed. 1207 */ 1208 up(&iclog->ic_sema); 1209 } 1210 1211 /* 1212 * Return size of each in-core log record buffer. 1213 * 1214 * All machines get 8 x 32kB buffers by default, unless tuned otherwise. 1215 * 1216 * If the filesystem blocksize is too large, we may need to choose a 1217 * larger size since the directory code currently logs entire blocks. 1218 */ 1219 STATIC void 1220 xlog_get_iclog_buffer_size( 1221 struct xfs_mount *mp, 1222 struct xlog *log) 1223 { 1224 if (mp->m_logbufs <= 0) 1225 mp->m_logbufs = XLOG_MAX_ICLOGS; 1226 if (mp->m_logbsize <= 0) 1227 mp->m_logbsize = XLOG_BIG_RECORD_BSIZE; 1228 1229 log->l_iclog_bufs = mp->m_logbufs; 1230 log->l_iclog_size = mp->m_logbsize; 1231 1232 /* 1233 * # headers = size / 32k - one header holds cycles from 32k of data. 1234 */ 1235 log->l_iclog_heads = 1236 DIV_ROUND_UP(mp->m_logbsize, XLOG_HEADER_CYCLE_SIZE); 1237 log->l_iclog_hsize = log->l_iclog_heads << BBSHIFT; 1238 } 1239 1240 void 1241 xfs_log_work_queue( 1242 struct xfs_mount *mp) 1243 { 1244 queue_delayed_work(mp->m_sync_workqueue, &mp->m_log->l_work, 1245 msecs_to_jiffies(xfs_syncd_centisecs * 10)); 1246 } 1247 1248 /* 1249 * Every sync period we need to unpin all items in the AIL and push them to 1250 * disk. If there is nothing dirty, then we might need to cover the log to 1251 * indicate that the filesystem is idle. 1252 */ 1253 static void 1254 xfs_log_worker( 1255 struct work_struct *work) 1256 { 1257 struct xlog *log = container_of(to_delayed_work(work), 1258 struct xlog, l_work); 1259 struct xfs_mount *mp = log->l_mp; 1260 1261 /* dgc: errors ignored - not fatal and nowhere to report them */ 1262 if (xfs_log_need_covered(mp)) { 1263 /* 1264 * Dump a transaction into the log that contains no real change. 1265 * This is needed to stamp the current tail LSN into the log 1266 * during the covering operation. 1267 * 1268 * We cannot use an inode here for this - that will push dirty 1269 * state back up into the VFS and then periodic inode flushing 1270 * will prevent log covering from making progress. Hence we 1271 * synchronously log the superblock instead to ensure the 1272 * superblock is immediately unpinned and can be written back. 1273 */ 1274 xfs_sync_sb(mp, true); 1275 } else 1276 xfs_log_force(mp, 0); 1277 1278 /* start pushing all the metadata that is currently dirty */ 1279 xfs_ail_push_all(mp->m_ail); 1280 1281 /* queue us up again */ 1282 xfs_log_work_queue(mp); 1283 } 1284 1285 /* 1286 * This routine initializes some of the log structure for a given mount point. 1287 * Its primary purpose is to fill in enough, so recovery can occur. However, 1288 * some other stuff may be filled in too. 1289 */ 1290 STATIC struct xlog * 1291 xlog_alloc_log( 1292 struct xfs_mount *mp, 1293 struct xfs_buftarg *log_target, 1294 xfs_daddr_t blk_offset, 1295 int num_bblks) 1296 { 1297 struct xlog *log; 1298 xlog_rec_header_t *head; 1299 xlog_in_core_t **iclogp; 1300 xlog_in_core_t *iclog, *prev_iclog=NULL; 1301 int i; 1302 int error = -ENOMEM; 1303 uint log2_size = 0; 1304 1305 log = kmem_zalloc(sizeof(struct xlog), KM_MAYFAIL); 1306 if (!log) { 1307 xfs_warn(mp, "Log allocation failed: No memory!"); 1308 goto out; 1309 } 1310 1311 log->l_mp = mp; 1312 log->l_targ = log_target; 1313 log->l_logsize = BBTOB(num_bblks); 1314 log->l_logBBstart = blk_offset; 1315 log->l_logBBsize = num_bblks; 1316 log->l_covered_state = XLOG_STATE_COVER_IDLE; 1317 log->l_flags |= XLOG_ACTIVE_RECOVERY; 1318 INIT_DELAYED_WORK(&log->l_work, xfs_log_worker); 1319 1320 log->l_prev_block = -1; 1321 /* log->l_tail_lsn = 0x100000000LL; cycle = 1; current block = 0 */ 1322 xlog_assign_atomic_lsn(&log->l_tail_lsn, 1, 0); 1323 xlog_assign_atomic_lsn(&log->l_last_sync_lsn, 1, 0); 1324 log->l_curr_cycle = 1; /* 0 is bad since this is initial value */ 1325 1326 xlog_grant_head_init(&log->l_reserve_head); 1327 xlog_grant_head_init(&log->l_write_head); 1328 1329 error = -EFSCORRUPTED; 1330 if (xfs_sb_version_hassector(&mp->m_sb)) { 1331 log2_size = mp->m_sb.sb_logsectlog; 1332 if (log2_size < BBSHIFT) { 1333 xfs_warn(mp, "Log sector size too small (0x%x < 0x%x)", 1334 log2_size, BBSHIFT); 1335 goto out_free_log; 1336 } 1337 1338 log2_size -= BBSHIFT; 1339 if (log2_size > mp->m_sectbb_log) { 1340 xfs_warn(mp, "Log sector size too large (0x%x > 0x%x)", 1341 log2_size, mp->m_sectbb_log); 1342 goto out_free_log; 1343 } 1344 1345 /* for larger sector sizes, must have v2 or external log */ 1346 if (log2_size && log->l_logBBstart > 0 && 1347 !xfs_sb_version_haslogv2(&mp->m_sb)) { 1348 xfs_warn(mp, 1349 "log sector size (0x%x) invalid for configuration.", 1350 log2_size); 1351 goto out_free_log; 1352 } 1353 } 1354 log->l_sectBBsize = 1 << log2_size; 1355 1356 xlog_get_iclog_buffer_size(mp, log); 1357 1358 spin_lock_init(&log->l_icloglock); 1359 init_waitqueue_head(&log->l_flush_wait); 1360 1361 iclogp = &log->l_iclog; 1362 /* 1363 * The amount of memory to allocate for the iclog structure is 1364 * rather funky due to the way the structure is defined. It is 1365 * done this way so that we can use different sizes for machines 1366 * with different amounts of memory. See the definition of 1367 * xlog_in_core_t in xfs_log_priv.h for details. 1368 */ 1369 ASSERT(log->l_iclog_size >= 4096); 1370 for (i = 0; i < log->l_iclog_bufs; i++) { 1371 int align_mask = xfs_buftarg_dma_alignment(mp->m_logdev_targp); 1372 size_t bvec_size = howmany(log->l_iclog_size, PAGE_SIZE) * 1373 sizeof(struct bio_vec); 1374 1375 iclog = kmem_zalloc(sizeof(*iclog) + bvec_size, KM_MAYFAIL); 1376 if (!iclog) 1377 goto out_free_iclog; 1378 1379 *iclogp = iclog; 1380 iclog->ic_prev = prev_iclog; 1381 prev_iclog = iclog; 1382 1383 iclog->ic_data = kmem_alloc_io(log->l_iclog_size, align_mask, 1384 KM_MAYFAIL | KM_ZERO); 1385 if (!iclog->ic_data) 1386 goto out_free_iclog; 1387 #ifdef DEBUG 1388 log->l_iclog_bak[i] = &iclog->ic_header; 1389 #endif 1390 head = &iclog->ic_header; 1391 memset(head, 0, sizeof(xlog_rec_header_t)); 1392 head->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM); 1393 head->h_version = cpu_to_be32( 1394 xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1); 1395 head->h_size = cpu_to_be32(log->l_iclog_size); 1396 /* new fields */ 1397 head->h_fmt = cpu_to_be32(XLOG_FMT); 1398 memcpy(&head->h_fs_uuid, &mp->m_sb.sb_uuid, sizeof(uuid_t)); 1399 1400 iclog->ic_size = log->l_iclog_size - log->l_iclog_hsize; 1401 iclog->ic_state = XLOG_STATE_ACTIVE; 1402 iclog->ic_log = log; 1403 atomic_set(&iclog->ic_refcnt, 0); 1404 spin_lock_init(&iclog->ic_callback_lock); 1405 INIT_LIST_HEAD(&iclog->ic_callbacks); 1406 iclog->ic_datap = (char *)iclog->ic_data + log->l_iclog_hsize; 1407 1408 init_waitqueue_head(&iclog->ic_force_wait); 1409 init_waitqueue_head(&iclog->ic_write_wait); 1410 INIT_WORK(&iclog->ic_end_io_work, xlog_ioend_work); 1411 sema_init(&iclog->ic_sema, 1); 1412 1413 iclogp = &iclog->ic_next; 1414 } 1415 *iclogp = log->l_iclog; /* complete ring */ 1416 log->l_iclog->ic_prev = prev_iclog; /* re-write 1st prev ptr */ 1417 1418 log->l_ioend_workqueue = alloc_workqueue("xfs-log/%s", 1419 WQ_MEM_RECLAIM | WQ_FREEZABLE | WQ_HIGHPRI, 0, 1420 mp->m_super->s_id); 1421 if (!log->l_ioend_workqueue) 1422 goto out_free_iclog; 1423 1424 error = xlog_cil_init(log); 1425 if (error) 1426 goto out_destroy_workqueue; 1427 return log; 1428 1429 out_destroy_workqueue: 1430 destroy_workqueue(log->l_ioend_workqueue); 1431 out_free_iclog: 1432 for (iclog = log->l_iclog; iclog; iclog = prev_iclog) { 1433 prev_iclog = iclog->ic_next; 1434 kmem_free(iclog->ic_data); 1435 kmem_free(iclog); 1436 if (prev_iclog == log->l_iclog) 1437 break; 1438 } 1439 out_free_log: 1440 kmem_free(log); 1441 out: 1442 return ERR_PTR(error); 1443 } /* xlog_alloc_log */ 1444 1445 /* 1446 * Write out the commit record of a transaction associated with the given 1447 * ticket to close off a running log write. Return the lsn of the commit record. 1448 */ 1449 int 1450 xlog_commit_record( 1451 struct xlog *log, 1452 struct xlog_ticket *ticket, 1453 struct xlog_in_core **iclog, 1454 xfs_lsn_t *lsn) 1455 { 1456 struct xfs_log_iovec reg = { 1457 .i_addr = NULL, 1458 .i_len = 0, 1459 .i_type = XLOG_REG_TYPE_COMMIT, 1460 }; 1461 struct xfs_log_vec vec = { 1462 .lv_niovecs = 1, 1463 .lv_iovecp = ®, 1464 }; 1465 int error; 1466 1467 if (XLOG_FORCED_SHUTDOWN(log)) 1468 return -EIO; 1469 1470 error = xlog_write(log, &vec, ticket, lsn, iclog, XLOG_COMMIT_TRANS, 1471 false); 1472 if (error) 1473 xfs_force_shutdown(log->l_mp, SHUTDOWN_LOG_IO_ERROR); 1474 return error; 1475 } 1476 1477 /* 1478 * Push on the buffer cache code if we ever use more than 75% of the on-disk 1479 * log space. This code pushes on the lsn which would supposedly free up 1480 * the 25% which we want to leave free. We may need to adopt a policy which 1481 * pushes on an lsn which is further along in the log once we reach the high 1482 * water mark. In this manner, we would be creating a low water mark. 1483 */ 1484 STATIC void 1485 xlog_grant_push_ail( 1486 struct xlog *log, 1487 int need_bytes) 1488 { 1489 xfs_lsn_t threshold_lsn = 0; 1490 xfs_lsn_t last_sync_lsn; 1491 int free_blocks; 1492 int free_bytes; 1493 int threshold_block; 1494 int threshold_cycle; 1495 int free_threshold; 1496 1497 ASSERT(BTOBB(need_bytes) < log->l_logBBsize); 1498 1499 free_bytes = xlog_space_left(log, &log->l_reserve_head.grant); 1500 free_blocks = BTOBBT(free_bytes); 1501 1502 /* 1503 * Set the threshold for the minimum number of free blocks in the 1504 * log to the maximum of what the caller needs, one quarter of the 1505 * log, and 256 blocks. 1506 */ 1507 free_threshold = BTOBB(need_bytes); 1508 free_threshold = max(free_threshold, (log->l_logBBsize >> 2)); 1509 free_threshold = max(free_threshold, 256); 1510 if (free_blocks >= free_threshold) 1511 return; 1512 1513 xlog_crack_atomic_lsn(&log->l_tail_lsn, &threshold_cycle, 1514 &threshold_block); 1515 threshold_block += free_threshold; 1516 if (threshold_block >= log->l_logBBsize) { 1517 threshold_block -= log->l_logBBsize; 1518 threshold_cycle += 1; 1519 } 1520 threshold_lsn = xlog_assign_lsn(threshold_cycle, 1521 threshold_block); 1522 /* 1523 * Don't pass in an lsn greater than the lsn of the last 1524 * log record known to be on disk. Use a snapshot of the last sync lsn 1525 * so that it doesn't change between the compare and the set. 1526 */ 1527 last_sync_lsn = atomic64_read(&log->l_last_sync_lsn); 1528 if (XFS_LSN_CMP(threshold_lsn, last_sync_lsn) > 0) 1529 threshold_lsn = last_sync_lsn; 1530 1531 /* 1532 * Get the transaction layer to kick the dirty buffers out to 1533 * disk asynchronously. No point in trying to do this if 1534 * the filesystem is shutting down. 1535 */ 1536 if (!XLOG_FORCED_SHUTDOWN(log)) 1537 xfs_ail_push(log->l_ailp, threshold_lsn); 1538 } 1539 1540 /* 1541 * Stamp cycle number in every block 1542 */ 1543 STATIC void 1544 xlog_pack_data( 1545 struct xlog *log, 1546 struct xlog_in_core *iclog, 1547 int roundoff) 1548 { 1549 int i, j, k; 1550 int size = iclog->ic_offset + roundoff; 1551 __be32 cycle_lsn; 1552 char *dp; 1553 1554 cycle_lsn = CYCLE_LSN_DISK(iclog->ic_header.h_lsn); 1555 1556 dp = iclog->ic_datap; 1557 for (i = 0; i < BTOBB(size); i++) { 1558 if (i >= (XLOG_HEADER_CYCLE_SIZE / BBSIZE)) 1559 break; 1560 iclog->ic_header.h_cycle_data[i] = *(__be32 *)dp; 1561 *(__be32 *)dp = cycle_lsn; 1562 dp += BBSIZE; 1563 } 1564 1565 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) { 1566 xlog_in_core_2_t *xhdr = iclog->ic_data; 1567 1568 for ( ; i < BTOBB(size); i++) { 1569 j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE); 1570 k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE); 1571 xhdr[j].hic_xheader.xh_cycle_data[k] = *(__be32 *)dp; 1572 *(__be32 *)dp = cycle_lsn; 1573 dp += BBSIZE; 1574 } 1575 1576 for (i = 1; i < log->l_iclog_heads; i++) 1577 xhdr[i].hic_xheader.xh_cycle = cycle_lsn; 1578 } 1579 } 1580 1581 /* 1582 * Calculate the checksum for a log buffer. 1583 * 1584 * This is a little more complicated than it should be because the various 1585 * headers and the actual data are non-contiguous. 1586 */ 1587 __le32 1588 xlog_cksum( 1589 struct xlog *log, 1590 struct xlog_rec_header *rhead, 1591 char *dp, 1592 int size) 1593 { 1594 uint32_t crc; 1595 1596 /* first generate the crc for the record header ... */ 1597 crc = xfs_start_cksum_update((char *)rhead, 1598 sizeof(struct xlog_rec_header), 1599 offsetof(struct xlog_rec_header, h_crc)); 1600 1601 /* ... then for additional cycle data for v2 logs ... */ 1602 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) { 1603 union xlog_in_core2 *xhdr = (union xlog_in_core2 *)rhead; 1604 int i; 1605 int xheads; 1606 1607 xheads = size / XLOG_HEADER_CYCLE_SIZE; 1608 if (size % XLOG_HEADER_CYCLE_SIZE) 1609 xheads++; 1610 1611 for (i = 1; i < xheads; i++) { 1612 crc = crc32c(crc, &xhdr[i].hic_xheader, 1613 sizeof(struct xlog_rec_ext_header)); 1614 } 1615 } 1616 1617 /* ... and finally for the payload */ 1618 crc = crc32c(crc, dp, size); 1619 1620 return xfs_end_cksum(crc); 1621 } 1622 1623 static void 1624 xlog_bio_end_io( 1625 struct bio *bio) 1626 { 1627 struct xlog_in_core *iclog = bio->bi_private; 1628 1629 queue_work(iclog->ic_log->l_ioend_workqueue, 1630 &iclog->ic_end_io_work); 1631 } 1632 1633 static int 1634 xlog_map_iclog_data( 1635 struct bio *bio, 1636 void *data, 1637 size_t count) 1638 { 1639 do { 1640 struct page *page = kmem_to_page(data); 1641 unsigned int off = offset_in_page(data); 1642 size_t len = min_t(size_t, count, PAGE_SIZE - off); 1643 1644 if (bio_add_page(bio, page, len, off) != len) 1645 return -EIO; 1646 1647 data += len; 1648 count -= len; 1649 } while (count); 1650 1651 return 0; 1652 } 1653 1654 STATIC void 1655 xlog_write_iclog( 1656 struct xlog *log, 1657 struct xlog_in_core *iclog, 1658 uint64_t bno, 1659 unsigned int count, 1660 bool need_flush) 1661 { 1662 ASSERT(bno < log->l_logBBsize); 1663 1664 /* 1665 * We lock the iclogbufs here so that we can serialise against I/O 1666 * completion during unmount. We might be processing a shutdown 1667 * triggered during unmount, and that can occur asynchronously to the 1668 * unmount thread, and hence we need to ensure that completes before 1669 * tearing down the iclogbufs. Hence we need to hold the buffer lock 1670 * across the log IO to archieve that. 1671 */ 1672 down(&iclog->ic_sema); 1673 if (unlikely(iclog->ic_state == XLOG_STATE_IOERROR)) { 1674 /* 1675 * It would seem logical to return EIO here, but we rely on 1676 * the log state machine to propagate I/O errors instead of 1677 * doing it here. We kick of the state machine and unlock 1678 * the buffer manually, the code needs to be kept in sync 1679 * with the I/O completion path. 1680 */ 1681 xlog_state_done_syncing(iclog); 1682 up(&iclog->ic_sema); 1683 return; 1684 } 1685 1686 bio_init(&iclog->ic_bio, iclog->ic_bvec, howmany(count, PAGE_SIZE)); 1687 bio_set_dev(&iclog->ic_bio, log->l_targ->bt_bdev); 1688 iclog->ic_bio.bi_iter.bi_sector = log->l_logBBstart + bno; 1689 iclog->ic_bio.bi_end_io = xlog_bio_end_io; 1690 iclog->ic_bio.bi_private = iclog; 1691 1692 /* 1693 * We use REQ_SYNC | REQ_IDLE here to tell the block layer the are more 1694 * IOs coming immediately after this one. This prevents the block layer 1695 * writeback throttle from throttling log writes behind background 1696 * metadata writeback and causing priority inversions. 1697 */ 1698 iclog->ic_bio.bi_opf = REQ_OP_WRITE | REQ_META | REQ_SYNC | 1699 REQ_IDLE | REQ_FUA; 1700 if (need_flush) 1701 iclog->ic_bio.bi_opf |= REQ_PREFLUSH; 1702 1703 if (xlog_map_iclog_data(&iclog->ic_bio, iclog->ic_data, count)) { 1704 xfs_force_shutdown(log->l_mp, SHUTDOWN_LOG_IO_ERROR); 1705 return; 1706 } 1707 if (is_vmalloc_addr(iclog->ic_data)) 1708 flush_kernel_vmap_range(iclog->ic_data, count); 1709 1710 /* 1711 * If this log buffer would straddle the end of the log we will have 1712 * to split it up into two bios, so that we can continue at the start. 1713 */ 1714 if (bno + BTOBB(count) > log->l_logBBsize) { 1715 struct bio *split; 1716 1717 split = bio_split(&iclog->ic_bio, log->l_logBBsize - bno, 1718 GFP_NOIO, &fs_bio_set); 1719 bio_chain(split, &iclog->ic_bio); 1720 submit_bio(split); 1721 1722 /* restart at logical offset zero for the remainder */ 1723 iclog->ic_bio.bi_iter.bi_sector = log->l_logBBstart; 1724 } 1725 1726 submit_bio(&iclog->ic_bio); 1727 } 1728 1729 /* 1730 * We need to bump cycle number for the part of the iclog that is 1731 * written to the start of the log. Watch out for the header magic 1732 * number case, though. 1733 */ 1734 static void 1735 xlog_split_iclog( 1736 struct xlog *log, 1737 void *data, 1738 uint64_t bno, 1739 unsigned int count) 1740 { 1741 unsigned int split_offset = BBTOB(log->l_logBBsize - bno); 1742 unsigned int i; 1743 1744 for (i = split_offset; i < count; i += BBSIZE) { 1745 uint32_t cycle = get_unaligned_be32(data + i); 1746 1747 if (++cycle == XLOG_HEADER_MAGIC_NUM) 1748 cycle++; 1749 put_unaligned_be32(cycle, data + i); 1750 } 1751 } 1752 1753 static int 1754 xlog_calc_iclog_size( 1755 struct xlog *log, 1756 struct xlog_in_core *iclog, 1757 uint32_t *roundoff) 1758 { 1759 uint32_t count_init, count; 1760 bool use_lsunit; 1761 1762 use_lsunit = xfs_sb_version_haslogv2(&log->l_mp->m_sb) && 1763 log->l_mp->m_sb.sb_logsunit > 1; 1764 1765 /* Add for LR header */ 1766 count_init = log->l_iclog_hsize + iclog->ic_offset; 1767 1768 /* Round out the log write size */ 1769 if (use_lsunit) { 1770 /* we have a v2 stripe unit to use */ 1771 count = XLOG_LSUNITTOB(log, XLOG_BTOLSUNIT(log, count_init)); 1772 } else { 1773 count = BBTOB(BTOBB(count_init)); 1774 } 1775 1776 ASSERT(count >= count_init); 1777 *roundoff = count - count_init; 1778 1779 if (use_lsunit) 1780 ASSERT(*roundoff < log->l_mp->m_sb.sb_logsunit); 1781 else 1782 ASSERT(*roundoff < BBTOB(1)); 1783 return count; 1784 } 1785 1786 /* 1787 * Flush out the in-core log (iclog) to the on-disk log in an asynchronous 1788 * fashion. Previously, we should have moved the current iclog 1789 * ptr in the log to point to the next available iclog. This allows further 1790 * write to continue while this code syncs out an iclog ready to go. 1791 * Before an in-core log can be written out, the data section must be scanned 1792 * to save away the 1st word of each BBSIZE block into the header. We replace 1793 * it with the current cycle count. Each BBSIZE block is tagged with the 1794 * cycle count because there in an implicit assumption that drives will 1795 * guarantee that entire 512 byte blocks get written at once. In other words, 1796 * we can't have part of a 512 byte block written and part not written. By 1797 * tagging each block, we will know which blocks are valid when recovering 1798 * after an unclean shutdown. 1799 * 1800 * This routine is single threaded on the iclog. No other thread can be in 1801 * this routine with the same iclog. Changing contents of iclog can there- 1802 * fore be done without grabbing the state machine lock. Updating the global 1803 * log will require grabbing the lock though. 1804 * 1805 * The entire log manager uses a logical block numbering scheme. Only 1806 * xlog_write_iclog knows about the fact that the log may not start with 1807 * block zero on a given device. 1808 */ 1809 STATIC void 1810 xlog_sync( 1811 struct xlog *log, 1812 struct xlog_in_core *iclog) 1813 { 1814 unsigned int count; /* byte count of bwrite */ 1815 unsigned int roundoff; /* roundoff to BB or stripe */ 1816 uint64_t bno; 1817 unsigned int size; 1818 bool need_flush = true, split = false; 1819 1820 ASSERT(atomic_read(&iclog->ic_refcnt) == 0); 1821 1822 count = xlog_calc_iclog_size(log, iclog, &roundoff); 1823 1824 /* move grant heads by roundoff in sync */ 1825 xlog_grant_add_space(log, &log->l_reserve_head.grant, roundoff); 1826 xlog_grant_add_space(log, &log->l_write_head.grant, roundoff); 1827 1828 /* put cycle number in every block */ 1829 xlog_pack_data(log, iclog, roundoff); 1830 1831 /* real byte length */ 1832 size = iclog->ic_offset; 1833 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) 1834 size += roundoff; 1835 iclog->ic_header.h_len = cpu_to_be32(size); 1836 1837 XFS_STATS_INC(log->l_mp, xs_log_writes); 1838 XFS_STATS_ADD(log->l_mp, xs_log_blocks, BTOBB(count)); 1839 1840 bno = BLOCK_LSN(be64_to_cpu(iclog->ic_header.h_lsn)); 1841 1842 /* Do we need to split this write into 2 parts? */ 1843 if (bno + BTOBB(count) > log->l_logBBsize) { 1844 xlog_split_iclog(log, &iclog->ic_header, bno, count); 1845 split = true; 1846 } 1847 1848 /* calculcate the checksum */ 1849 iclog->ic_header.h_crc = xlog_cksum(log, &iclog->ic_header, 1850 iclog->ic_datap, size); 1851 /* 1852 * Intentionally corrupt the log record CRC based on the error injection 1853 * frequency, if defined. This facilitates testing log recovery in the 1854 * event of torn writes. Hence, set the IOABORT state to abort the log 1855 * write on I/O completion and shutdown the fs. The subsequent mount 1856 * detects the bad CRC and attempts to recover. 1857 */ 1858 #ifdef DEBUG 1859 if (XFS_TEST_ERROR(false, log->l_mp, XFS_ERRTAG_LOG_BAD_CRC)) { 1860 iclog->ic_header.h_crc &= cpu_to_le32(0xAAAAAAAA); 1861 iclog->ic_fail_crc = true; 1862 xfs_warn(log->l_mp, 1863 "Intentionally corrupted log record at LSN 0x%llx. Shutdown imminent.", 1864 be64_to_cpu(iclog->ic_header.h_lsn)); 1865 } 1866 #endif 1867 1868 /* 1869 * Flush the data device before flushing the log to make sure all meta 1870 * data written back from the AIL actually made it to disk before 1871 * stamping the new log tail LSN into the log buffer. For an external 1872 * log we need to issue the flush explicitly, and unfortunately 1873 * synchronously here; for an internal log we can simply use the block 1874 * layer state machine for preflushes. 1875 */ 1876 if (log->l_targ != log->l_mp->m_ddev_targp || split) { 1877 xfs_blkdev_issue_flush(log->l_mp->m_ddev_targp); 1878 need_flush = false; 1879 } 1880 1881 xlog_verify_iclog(log, iclog, count); 1882 xlog_write_iclog(log, iclog, bno, count, need_flush); 1883 } 1884 1885 /* 1886 * Deallocate a log structure 1887 */ 1888 STATIC void 1889 xlog_dealloc_log( 1890 struct xlog *log) 1891 { 1892 xlog_in_core_t *iclog, *next_iclog; 1893 int i; 1894 1895 xlog_cil_destroy(log); 1896 1897 /* 1898 * Cycle all the iclogbuf locks to make sure all log IO completion 1899 * is done before we tear down these buffers. 1900 */ 1901 iclog = log->l_iclog; 1902 for (i = 0; i < log->l_iclog_bufs; i++) { 1903 down(&iclog->ic_sema); 1904 up(&iclog->ic_sema); 1905 iclog = iclog->ic_next; 1906 } 1907 1908 iclog = log->l_iclog; 1909 for (i = 0; i < log->l_iclog_bufs; i++) { 1910 next_iclog = iclog->ic_next; 1911 kmem_free(iclog->ic_data); 1912 kmem_free(iclog); 1913 iclog = next_iclog; 1914 } 1915 1916 log->l_mp->m_log = NULL; 1917 destroy_workqueue(log->l_ioend_workqueue); 1918 kmem_free(log); 1919 } 1920 1921 /* 1922 * Update counters atomically now that memcpy is done. 1923 */ 1924 static inline void 1925 xlog_state_finish_copy( 1926 struct xlog *log, 1927 struct xlog_in_core *iclog, 1928 int record_cnt, 1929 int copy_bytes) 1930 { 1931 lockdep_assert_held(&log->l_icloglock); 1932 1933 be32_add_cpu(&iclog->ic_header.h_num_logops, record_cnt); 1934 iclog->ic_offset += copy_bytes; 1935 } 1936 1937 /* 1938 * print out info relating to regions written which consume 1939 * the reservation 1940 */ 1941 void 1942 xlog_print_tic_res( 1943 struct xfs_mount *mp, 1944 struct xlog_ticket *ticket) 1945 { 1946 uint i; 1947 uint ophdr_spc = ticket->t_res_num_ophdrs * (uint)sizeof(xlog_op_header_t); 1948 1949 /* match with XLOG_REG_TYPE_* in xfs_log.h */ 1950 #define REG_TYPE_STR(type, str) [XLOG_REG_TYPE_##type] = str 1951 static char *res_type_str[] = { 1952 REG_TYPE_STR(BFORMAT, "bformat"), 1953 REG_TYPE_STR(BCHUNK, "bchunk"), 1954 REG_TYPE_STR(EFI_FORMAT, "efi_format"), 1955 REG_TYPE_STR(EFD_FORMAT, "efd_format"), 1956 REG_TYPE_STR(IFORMAT, "iformat"), 1957 REG_TYPE_STR(ICORE, "icore"), 1958 REG_TYPE_STR(IEXT, "iext"), 1959 REG_TYPE_STR(IBROOT, "ibroot"), 1960 REG_TYPE_STR(ILOCAL, "ilocal"), 1961 REG_TYPE_STR(IATTR_EXT, "iattr_ext"), 1962 REG_TYPE_STR(IATTR_BROOT, "iattr_broot"), 1963 REG_TYPE_STR(IATTR_LOCAL, "iattr_local"), 1964 REG_TYPE_STR(QFORMAT, "qformat"), 1965 REG_TYPE_STR(DQUOT, "dquot"), 1966 REG_TYPE_STR(QUOTAOFF, "quotaoff"), 1967 REG_TYPE_STR(LRHEADER, "LR header"), 1968 REG_TYPE_STR(UNMOUNT, "unmount"), 1969 REG_TYPE_STR(COMMIT, "commit"), 1970 REG_TYPE_STR(TRANSHDR, "trans header"), 1971 REG_TYPE_STR(ICREATE, "inode create"), 1972 REG_TYPE_STR(RUI_FORMAT, "rui_format"), 1973 REG_TYPE_STR(RUD_FORMAT, "rud_format"), 1974 REG_TYPE_STR(CUI_FORMAT, "cui_format"), 1975 REG_TYPE_STR(CUD_FORMAT, "cud_format"), 1976 REG_TYPE_STR(BUI_FORMAT, "bui_format"), 1977 REG_TYPE_STR(BUD_FORMAT, "bud_format"), 1978 }; 1979 BUILD_BUG_ON(ARRAY_SIZE(res_type_str) != XLOG_REG_TYPE_MAX + 1); 1980 #undef REG_TYPE_STR 1981 1982 xfs_warn(mp, "ticket reservation summary:"); 1983 xfs_warn(mp, " unit res = %d bytes", 1984 ticket->t_unit_res); 1985 xfs_warn(mp, " current res = %d bytes", 1986 ticket->t_curr_res); 1987 xfs_warn(mp, " total reg = %u bytes (o/flow = %u bytes)", 1988 ticket->t_res_arr_sum, ticket->t_res_o_flow); 1989 xfs_warn(mp, " ophdrs = %u (ophdr space = %u bytes)", 1990 ticket->t_res_num_ophdrs, ophdr_spc); 1991 xfs_warn(mp, " ophdr + reg = %u bytes", 1992 ticket->t_res_arr_sum + ticket->t_res_o_flow + ophdr_spc); 1993 xfs_warn(mp, " num regions = %u", 1994 ticket->t_res_num); 1995 1996 for (i = 0; i < ticket->t_res_num; i++) { 1997 uint r_type = ticket->t_res_arr[i].r_type; 1998 xfs_warn(mp, "region[%u]: %s - %u bytes", i, 1999 ((r_type <= 0 || r_type > XLOG_REG_TYPE_MAX) ? 2000 "bad-rtype" : res_type_str[r_type]), 2001 ticket->t_res_arr[i].r_len); 2002 } 2003 } 2004 2005 /* 2006 * Print a summary of the transaction. 2007 */ 2008 void 2009 xlog_print_trans( 2010 struct xfs_trans *tp) 2011 { 2012 struct xfs_mount *mp = tp->t_mountp; 2013 struct xfs_log_item *lip; 2014 2015 /* dump core transaction and ticket info */ 2016 xfs_warn(mp, "transaction summary:"); 2017 xfs_warn(mp, " log res = %d", tp->t_log_res); 2018 xfs_warn(mp, " log count = %d", tp->t_log_count); 2019 xfs_warn(mp, " flags = 0x%x", tp->t_flags); 2020 2021 xlog_print_tic_res(mp, tp->t_ticket); 2022 2023 /* dump each log item */ 2024 list_for_each_entry(lip, &tp->t_items, li_trans) { 2025 struct xfs_log_vec *lv = lip->li_lv; 2026 struct xfs_log_iovec *vec; 2027 int i; 2028 2029 xfs_warn(mp, "log item: "); 2030 xfs_warn(mp, " type = 0x%x", lip->li_type); 2031 xfs_warn(mp, " flags = 0x%lx", lip->li_flags); 2032 if (!lv) 2033 continue; 2034 xfs_warn(mp, " niovecs = %d", lv->lv_niovecs); 2035 xfs_warn(mp, " size = %d", lv->lv_size); 2036 xfs_warn(mp, " bytes = %d", lv->lv_bytes); 2037 xfs_warn(mp, " buf len = %d", lv->lv_buf_len); 2038 2039 /* dump each iovec for the log item */ 2040 vec = lv->lv_iovecp; 2041 for (i = 0; i < lv->lv_niovecs; i++) { 2042 int dumplen = min(vec->i_len, 32); 2043 2044 xfs_warn(mp, " iovec[%d]", i); 2045 xfs_warn(mp, " type = 0x%x", vec->i_type); 2046 xfs_warn(mp, " len = %d", vec->i_len); 2047 xfs_warn(mp, " first %d bytes of iovec[%d]:", dumplen, i); 2048 xfs_hex_dump(vec->i_addr, dumplen); 2049 2050 vec++; 2051 } 2052 } 2053 } 2054 2055 /* 2056 * Calculate the potential space needed by the log vector. We may need a start 2057 * record, and each region gets its own struct xlog_op_header and may need to be 2058 * double word aligned. 2059 */ 2060 static int 2061 xlog_write_calc_vec_length( 2062 struct xlog_ticket *ticket, 2063 struct xfs_log_vec *log_vector, 2064 bool need_start_rec) 2065 { 2066 struct xfs_log_vec *lv; 2067 int headers = need_start_rec ? 1 : 0; 2068 int len = 0; 2069 int i; 2070 2071 for (lv = log_vector; lv; lv = lv->lv_next) { 2072 /* we don't write ordered log vectors */ 2073 if (lv->lv_buf_len == XFS_LOG_VEC_ORDERED) 2074 continue; 2075 2076 headers += lv->lv_niovecs; 2077 2078 for (i = 0; i < lv->lv_niovecs; i++) { 2079 struct xfs_log_iovec *vecp = &lv->lv_iovecp[i]; 2080 2081 len += vecp->i_len; 2082 xlog_tic_add_region(ticket, vecp->i_len, vecp->i_type); 2083 } 2084 } 2085 2086 ticket->t_res_num_ophdrs += headers; 2087 len += headers * sizeof(struct xlog_op_header); 2088 2089 return len; 2090 } 2091 2092 static void 2093 xlog_write_start_rec( 2094 struct xlog_op_header *ophdr, 2095 struct xlog_ticket *ticket) 2096 { 2097 ophdr->oh_tid = cpu_to_be32(ticket->t_tid); 2098 ophdr->oh_clientid = ticket->t_clientid; 2099 ophdr->oh_len = 0; 2100 ophdr->oh_flags = XLOG_START_TRANS; 2101 ophdr->oh_res2 = 0; 2102 } 2103 2104 static xlog_op_header_t * 2105 xlog_write_setup_ophdr( 2106 struct xlog *log, 2107 struct xlog_op_header *ophdr, 2108 struct xlog_ticket *ticket, 2109 uint flags) 2110 { 2111 ophdr->oh_tid = cpu_to_be32(ticket->t_tid); 2112 ophdr->oh_clientid = ticket->t_clientid; 2113 ophdr->oh_res2 = 0; 2114 2115 /* are we copying a commit or unmount record? */ 2116 ophdr->oh_flags = flags; 2117 2118 /* 2119 * We've seen logs corrupted with bad transaction client ids. This 2120 * makes sure that XFS doesn't generate them on. Turn this into an EIO 2121 * and shut down the filesystem. 2122 */ 2123 switch (ophdr->oh_clientid) { 2124 case XFS_TRANSACTION: 2125 case XFS_VOLUME: 2126 case XFS_LOG: 2127 break; 2128 default: 2129 xfs_warn(log->l_mp, 2130 "Bad XFS transaction clientid 0x%x in ticket "PTR_FMT, 2131 ophdr->oh_clientid, ticket); 2132 return NULL; 2133 } 2134 2135 return ophdr; 2136 } 2137 2138 /* 2139 * Set up the parameters of the region copy into the log. This has 2140 * to handle region write split across multiple log buffers - this 2141 * state is kept external to this function so that this code can 2142 * be written in an obvious, self documenting manner. 2143 */ 2144 static int 2145 xlog_write_setup_copy( 2146 struct xlog_ticket *ticket, 2147 struct xlog_op_header *ophdr, 2148 int space_available, 2149 int space_required, 2150 int *copy_off, 2151 int *copy_len, 2152 int *last_was_partial_copy, 2153 int *bytes_consumed) 2154 { 2155 int still_to_copy; 2156 2157 still_to_copy = space_required - *bytes_consumed; 2158 *copy_off = *bytes_consumed; 2159 2160 if (still_to_copy <= space_available) { 2161 /* write of region completes here */ 2162 *copy_len = still_to_copy; 2163 ophdr->oh_len = cpu_to_be32(*copy_len); 2164 if (*last_was_partial_copy) 2165 ophdr->oh_flags |= (XLOG_END_TRANS|XLOG_WAS_CONT_TRANS); 2166 *last_was_partial_copy = 0; 2167 *bytes_consumed = 0; 2168 return 0; 2169 } 2170 2171 /* partial write of region, needs extra log op header reservation */ 2172 *copy_len = space_available; 2173 ophdr->oh_len = cpu_to_be32(*copy_len); 2174 ophdr->oh_flags |= XLOG_CONTINUE_TRANS; 2175 if (*last_was_partial_copy) 2176 ophdr->oh_flags |= XLOG_WAS_CONT_TRANS; 2177 *bytes_consumed += *copy_len; 2178 (*last_was_partial_copy)++; 2179 2180 /* account for new log op header */ 2181 ticket->t_curr_res -= sizeof(struct xlog_op_header); 2182 ticket->t_res_num_ophdrs++; 2183 2184 return sizeof(struct xlog_op_header); 2185 } 2186 2187 static int 2188 xlog_write_copy_finish( 2189 struct xlog *log, 2190 struct xlog_in_core *iclog, 2191 uint flags, 2192 int *record_cnt, 2193 int *data_cnt, 2194 int *partial_copy, 2195 int *partial_copy_len, 2196 int log_offset, 2197 struct xlog_in_core **commit_iclog) 2198 { 2199 int error; 2200 2201 if (*partial_copy) { 2202 /* 2203 * This iclog has already been marked WANT_SYNC by 2204 * xlog_state_get_iclog_space. 2205 */ 2206 spin_lock(&log->l_icloglock); 2207 xlog_state_finish_copy(log, iclog, *record_cnt, *data_cnt); 2208 *record_cnt = 0; 2209 *data_cnt = 0; 2210 goto release_iclog; 2211 } 2212 2213 *partial_copy = 0; 2214 *partial_copy_len = 0; 2215 2216 if (iclog->ic_size - log_offset <= sizeof(xlog_op_header_t)) { 2217 /* no more space in this iclog - push it. */ 2218 spin_lock(&log->l_icloglock); 2219 xlog_state_finish_copy(log, iclog, *record_cnt, *data_cnt); 2220 *record_cnt = 0; 2221 *data_cnt = 0; 2222 2223 if (iclog->ic_state == XLOG_STATE_ACTIVE) 2224 xlog_state_switch_iclogs(log, iclog, 0); 2225 else 2226 ASSERT(iclog->ic_state == XLOG_STATE_WANT_SYNC || 2227 iclog->ic_state == XLOG_STATE_IOERROR); 2228 if (!commit_iclog) 2229 goto release_iclog; 2230 spin_unlock(&log->l_icloglock); 2231 ASSERT(flags & XLOG_COMMIT_TRANS); 2232 *commit_iclog = iclog; 2233 } 2234 2235 return 0; 2236 2237 release_iclog: 2238 error = xlog_state_release_iclog(log, iclog); 2239 spin_unlock(&log->l_icloglock); 2240 return error; 2241 } 2242 2243 /* 2244 * Write some region out to in-core log 2245 * 2246 * This will be called when writing externally provided regions or when 2247 * writing out a commit record for a given transaction. 2248 * 2249 * General algorithm: 2250 * 1. Find total length of this write. This may include adding to the 2251 * lengths passed in. 2252 * 2. Check whether we violate the tickets reservation. 2253 * 3. While writing to this iclog 2254 * A. Reserve as much space in this iclog as can get 2255 * B. If this is first write, save away start lsn 2256 * C. While writing this region: 2257 * 1. If first write of transaction, write start record 2258 * 2. Write log operation header (header per region) 2259 * 3. Find out if we can fit entire region into this iclog 2260 * 4. Potentially, verify destination memcpy ptr 2261 * 5. Memcpy (partial) region 2262 * 6. If partial copy, release iclog; otherwise, continue 2263 * copying more regions into current iclog 2264 * 4. Mark want sync bit (in simulation mode) 2265 * 5. Release iclog for potential flush to on-disk log. 2266 * 2267 * ERRORS: 2268 * 1. Panic if reservation is overrun. This should never happen since 2269 * reservation amounts are generated internal to the filesystem. 2270 * NOTES: 2271 * 1. Tickets are single threaded data structures. 2272 * 2. The XLOG_END_TRANS & XLOG_CONTINUE_TRANS flags are passed down to the 2273 * syncing routine. When a single log_write region needs to span 2274 * multiple in-core logs, the XLOG_CONTINUE_TRANS bit should be set 2275 * on all log operation writes which don't contain the end of the 2276 * region. The XLOG_END_TRANS bit is used for the in-core log 2277 * operation which contains the end of the continued log_write region. 2278 * 3. When xlog_state_get_iclog_space() grabs the rest of the current iclog, 2279 * we don't really know exactly how much space will be used. As a result, 2280 * we don't update ic_offset until the end when we know exactly how many 2281 * bytes have been written out. 2282 */ 2283 int 2284 xlog_write( 2285 struct xlog *log, 2286 struct xfs_log_vec *log_vector, 2287 struct xlog_ticket *ticket, 2288 xfs_lsn_t *start_lsn, 2289 struct xlog_in_core **commit_iclog, 2290 uint flags, 2291 bool need_start_rec) 2292 { 2293 struct xlog_in_core *iclog = NULL; 2294 struct xfs_log_vec *lv = log_vector; 2295 struct xfs_log_iovec *vecp = lv->lv_iovecp; 2296 int index = 0; 2297 int len; 2298 int partial_copy = 0; 2299 int partial_copy_len = 0; 2300 int contwr = 0; 2301 int record_cnt = 0; 2302 int data_cnt = 0; 2303 int error = 0; 2304 2305 /* 2306 * If this is a commit or unmount transaction, we don't need a start 2307 * record to be written. We do, however, have to account for the 2308 * commit or unmount header that gets written. Hence we always have 2309 * to account for an extra xlog_op_header here. 2310 */ 2311 ticket->t_curr_res -= sizeof(struct xlog_op_header); 2312 if (ticket->t_curr_res < 0) { 2313 xfs_alert_tag(log->l_mp, XFS_PTAG_LOGRES, 2314 "ctx ticket reservation ran out. Need to up reservation"); 2315 xlog_print_tic_res(log->l_mp, ticket); 2316 xfs_force_shutdown(log->l_mp, SHUTDOWN_LOG_IO_ERROR); 2317 } 2318 2319 len = xlog_write_calc_vec_length(ticket, log_vector, need_start_rec); 2320 *start_lsn = 0; 2321 while (lv && (!lv->lv_niovecs || index < lv->lv_niovecs)) { 2322 void *ptr; 2323 int log_offset; 2324 2325 error = xlog_state_get_iclog_space(log, len, &iclog, ticket, 2326 &contwr, &log_offset); 2327 if (error) 2328 return error; 2329 2330 ASSERT(log_offset <= iclog->ic_size - 1); 2331 ptr = iclog->ic_datap + log_offset; 2332 2333 /* start_lsn is the first lsn written to. That's all we need. */ 2334 if (!*start_lsn) 2335 *start_lsn = be64_to_cpu(iclog->ic_header.h_lsn); 2336 2337 /* 2338 * This loop writes out as many regions as can fit in the amount 2339 * of space which was allocated by xlog_state_get_iclog_space(). 2340 */ 2341 while (lv && (!lv->lv_niovecs || index < lv->lv_niovecs)) { 2342 struct xfs_log_iovec *reg; 2343 struct xlog_op_header *ophdr; 2344 int copy_len; 2345 int copy_off; 2346 bool ordered = false; 2347 2348 /* ordered log vectors have no regions to write */ 2349 if (lv->lv_buf_len == XFS_LOG_VEC_ORDERED) { 2350 ASSERT(lv->lv_niovecs == 0); 2351 ordered = true; 2352 goto next_lv; 2353 } 2354 2355 reg = &vecp[index]; 2356 ASSERT(reg->i_len % sizeof(int32_t) == 0); 2357 ASSERT((unsigned long)ptr % sizeof(int32_t) == 0); 2358 2359 /* 2360 * Before we start formatting log vectors, we need to 2361 * write a start record. Only do this for the first 2362 * iclog we write to. 2363 */ 2364 if (need_start_rec) { 2365 xlog_write_start_rec(ptr, ticket); 2366 xlog_write_adv_cnt(&ptr, &len, &log_offset, 2367 sizeof(struct xlog_op_header)); 2368 } 2369 2370 ophdr = xlog_write_setup_ophdr(log, ptr, ticket, flags); 2371 if (!ophdr) 2372 return -EIO; 2373 2374 xlog_write_adv_cnt(&ptr, &len, &log_offset, 2375 sizeof(struct xlog_op_header)); 2376 2377 len += xlog_write_setup_copy(ticket, ophdr, 2378 iclog->ic_size-log_offset, 2379 reg->i_len, 2380 ©_off, ©_len, 2381 &partial_copy, 2382 &partial_copy_len); 2383 xlog_verify_dest_ptr(log, ptr); 2384 2385 /* 2386 * Copy region. 2387 * 2388 * Unmount records just log an opheader, so can have 2389 * empty payloads with no data region to copy. Hence we 2390 * only copy the payload if the vector says it has data 2391 * to copy. 2392 */ 2393 ASSERT(copy_len >= 0); 2394 if (copy_len > 0) { 2395 memcpy(ptr, reg->i_addr + copy_off, copy_len); 2396 xlog_write_adv_cnt(&ptr, &len, &log_offset, 2397 copy_len); 2398 } 2399 copy_len += sizeof(struct xlog_op_header); 2400 record_cnt++; 2401 if (need_start_rec) { 2402 copy_len += sizeof(struct xlog_op_header); 2403 record_cnt++; 2404 need_start_rec = false; 2405 } 2406 data_cnt += contwr ? copy_len : 0; 2407 2408 error = xlog_write_copy_finish(log, iclog, flags, 2409 &record_cnt, &data_cnt, 2410 &partial_copy, 2411 &partial_copy_len, 2412 log_offset, 2413 commit_iclog); 2414 if (error) 2415 return error; 2416 2417 /* 2418 * if we had a partial copy, we need to get more iclog 2419 * space but we don't want to increment the region 2420 * index because there is still more is this region to 2421 * write. 2422 * 2423 * If we completed writing this region, and we flushed 2424 * the iclog (indicated by resetting of the record 2425 * count), then we also need to get more log space. If 2426 * this was the last record, though, we are done and 2427 * can just return. 2428 */ 2429 if (partial_copy) 2430 break; 2431 2432 if (++index == lv->lv_niovecs) { 2433 next_lv: 2434 lv = lv->lv_next; 2435 index = 0; 2436 if (lv) 2437 vecp = lv->lv_iovecp; 2438 } 2439 if (record_cnt == 0 && !ordered) { 2440 if (!lv) 2441 return 0; 2442 break; 2443 } 2444 } 2445 } 2446 2447 ASSERT(len == 0); 2448 2449 spin_lock(&log->l_icloglock); 2450 xlog_state_finish_copy(log, iclog, record_cnt, data_cnt); 2451 if (commit_iclog) { 2452 ASSERT(flags & XLOG_COMMIT_TRANS); 2453 *commit_iclog = iclog; 2454 } else { 2455 error = xlog_state_release_iclog(log, iclog); 2456 } 2457 spin_unlock(&log->l_icloglock); 2458 2459 return error; 2460 } 2461 2462 static void 2463 xlog_state_activate_iclog( 2464 struct xlog_in_core *iclog, 2465 int *iclogs_changed) 2466 { 2467 ASSERT(list_empty_careful(&iclog->ic_callbacks)); 2468 2469 /* 2470 * If the number of ops in this iclog indicate it just contains the 2471 * dummy transaction, we can change state into IDLE (the second time 2472 * around). Otherwise we should change the state into NEED a dummy. 2473 * We don't need to cover the dummy. 2474 */ 2475 if (*iclogs_changed == 0 && 2476 iclog->ic_header.h_num_logops == cpu_to_be32(XLOG_COVER_OPS)) { 2477 *iclogs_changed = 1; 2478 } else { 2479 /* 2480 * We have two dirty iclogs so start over. This could also be 2481 * num of ops indicating this is not the dummy going out. 2482 */ 2483 *iclogs_changed = 2; 2484 } 2485 2486 iclog->ic_state = XLOG_STATE_ACTIVE; 2487 iclog->ic_offset = 0; 2488 iclog->ic_header.h_num_logops = 0; 2489 memset(iclog->ic_header.h_cycle_data, 0, 2490 sizeof(iclog->ic_header.h_cycle_data)); 2491 iclog->ic_header.h_lsn = 0; 2492 } 2493 2494 /* 2495 * Loop through all iclogs and mark all iclogs currently marked DIRTY as 2496 * ACTIVE after iclog I/O has completed. 2497 */ 2498 static void 2499 xlog_state_activate_iclogs( 2500 struct xlog *log, 2501 int *iclogs_changed) 2502 { 2503 struct xlog_in_core *iclog = log->l_iclog; 2504 2505 do { 2506 if (iclog->ic_state == XLOG_STATE_DIRTY) 2507 xlog_state_activate_iclog(iclog, iclogs_changed); 2508 /* 2509 * The ordering of marking iclogs ACTIVE must be maintained, so 2510 * an iclog doesn't become ACTIVE beyond one that is SYNCING. 2511 */ 2512 else if (iclog->ic_state != XLOG_STATE_ACTIVE) 2513 break; 2514 } while ((iclog = iclog->ic_next) != log->l_iclog); 2515 } 2516 2517 static int 2518 xlog_covered_state( 2519 int prev_state, 2520 int iclogs_changed) 2521 { 2522 /* 2523 * We usually go to NEED. But we go to NEED2 if the changed indicates we 2524 * are done writing the dummy record. If we are done with the second 2525 * dummy recored (DONE2), then we go to IDLE. 2526 */ 2527 switch (prev_state) { 2528 case XLOG_STATE_COVER_IDLE: 2529 case XLOG_STATE_COVER_NEED: 2530 case XLOG_STATE_COVER_NEED2: 2531 break; 2532 case XLOG_STATE_COVER_DONE: 2533 if (iclogs_changed == 1) 2534 return XLOG_STATE_COVER_NEED2; 2535 break; 2536 case XLOG_STATE_COVER_DONE2: 2537 if (iclogs_changed == 1) 2538 return XLOG_STATE_COVER_IDLE; 2539 break; 2540 default: 2541 ASSERT(0); 2542 } 2543 2544 return XLOG_STATE_COVER_NEED; 2545 } 2546 2547 STATIC void 2548 xlog_state_clean_iclog( 2549 struct xlog *log, 2550 struct xlog_in_core *dirty_iclog) 2551 { 2552 int iclogs_changed = 0; 2553 2554 dirty_iclog->ic_state = XLOG_STATE_DIRTY; 2555 2556 xlog_state_activate_iclogs(log, &iclogs_changed); 2557 wake_up_all(&dirty_iclog->ic_force_wait); 2558 2559 if (iclogs_changed) { 2560 log->l_covered_state = xlog_covered_state(log->l_covered_state, 2561 iclogs_changed); 2562 } 2563 } 2564 2565 STATIC xfs_lsn_t 2566 xlog_get_lowest_lsn( 2567 struct xlog *log) 2568 { 2569 struct xlog_in_core *iclog = log->l_iclog; 2570 xfs_lsn_t lowest_lsn = 0, lsn; 2571 2572 do { 2573 if (iclog->ic_state == XLOG_STATE_ACTIVE || 2574 iclog->ic_state == XLOG_STATE_DIRTY) 2575 continue; 2576 2577 lsn = be64_to_cpu(iclog->ic_header.h_lsn); 2578 if ((lsn && !lowest_lsn) || XFS_LSN_CMP(lsn, lowest_lsn) < 0) 2579 lowest_lsn = lsn; 2580 } while ((iclog = iclog->ic_next) != log->l_iclog); 2581 2582 return lowest_lsn; 2583 } 2584 2585 /* 2586 * Completion of a iclog IO does not imply that a transaction has completed, as 2587 * transactions can be large enough to span many iclogs. We cannot change the 2588 * tail of the log half way through a transaction as this may be the only 2589 * transaction in the log and moving the tail to point to the middle of it 2590 * will prevent recovery from finding the start of the transaction. Hence we 2591 * should only update the last_sync_lsn if this iclog contains transaction 2592 * completion callbacks on it. 2593 * 2594 * We have to do this before we drop the icloglock to ensure we are the only one 2595 * that can update it. 2596 * 2597 * If we are moving the last_sync_lsn forwards, we also need to ensure we kick 2598 * the reservation grant head pushing. This is due to the fact that the push 2599 * target is bound by the current last_sync_lsn value. Hence if we have a large 2600 * amount of log space bound up in this committing transaction then the 2601 * last_sync_lsn value may be the limiting factor preventing tail pushing from 2602 * freeing space in the log. Hence once we've updated the last_sync_lsn we 2603 * should push the AIL to ensure the push target (and hence the grant head) is 2604 * no longer bound by the old log head location and can move forwards and make 2605 * progress again. 2606 */ 2607 static void 2608 xlog_state_set_callback( 2609 struct xlog *log, 2610 struct xlog_in_core *iclog, 2611 xfs_lsn_t header_lsn) 2612 { 2613 iclog->ic_state = XLOG_STATE_CALLBACK; 2614 2615 ASSERT(XFS_LSN_CMP(atomic64_read(&log->l_last_sync_lsn), 2616 header_lsn) <= 0); 2617 2618 if (list_empty_careful(&iclog->ic_callbacks)) 2619 return; 2620 2621 atomic64_set(&log->l_last_sync_lsn, header_lsn); 2622 xlog_grant_push_ail(log, 0); 2623 } 2624 2625 /* 2626 * Return true if we need to stop processing, false to continue to the next 2627 * iclog. The caller will need to run callbacks if the iclog is returned in the 2628 * XLOG_STATE_CALLBACK state. 2629 */ 2630 static bool 2631 xlog_state_iodone_process_iclog( 2632 struct xlog *log, 2633 struct xlog_in_core *iclog, 2634 bool *ioerror) 2635 { 2636 xfs_lsn_t lowest_lsn; 2637 xfs_lsn_t header_lsn; 2638 2639 switch (iclog->ic_state) { 2640 case XLOG_STATE_ACTIVE: 2641 case XLOG_STATE_DIRTY: 2642 /* 2643 * Skip all iclogs in the ACTIVE & DIRTY states: 2644 */ 2645 return false; 2646 case XLOG_STATE_IOERROR: 2647 /* 2648 * Between marking a filesystem SHUTDOWN and stopping the log, 2649 * we do flush all iclogs to disk (if there wasn't a log I/O 2650 * error). So, we do want things to go smoothly in case of just 2651 * a SHUTDOWN w/o a LOG_IO_ERROR. 2652 */ 2653 *ioerror = true; 2654 return false; 2655 case XLOG_STATE_DONE_SYNC: 2656 /* 2657 * Now that we have an iclog that is in the DONE_SYNC state, do 2658 * one more check here to see if we have chased our tail around. 2659 * If this is not the lowest lsn iclog, then we will leave it 2660 * for another completion to process. 2661 */ 2662 header_lsn = be64_to_cpu(iclog->ic_header.h_lsn); 2663 lowest_lsn = xlog_get_lowest_lsn(log); 2664 if (lowest_lsn && XFS_LSN_CMP(lowest_lsn, header_lsn) < 0) 2665 return false; 2666 xlog_state_set_callback(log, iclog, header_lsn); 2667 return false; 2668 default: 2669 /* 2670 * Can only perform callbacks in order. Since this iclog is not 2671 * in the DONE_SYNC state, we skip the rest and just try to 2672 * clean up. 2673 */ 2674 return true; 2675 } 2676 } 2677 2678 /* 2679 * Keep processing entries in the iclog callback list until we come around and 2680 * it is empty. We need to atomically see that the list is empty and change the 2681 * state to DIRTY so that we don't miss any more callbacks being added. 2682 * 2683 * This function is called with the icloglock held and returns with it held. We 2684 * drop it while running callbacks, however, as holding it over thousands of 2685 * callbacks is unnecessary and causes excessive contention if we do. 2686 */ 2687 static void 2688 xlog_state_do_iclog_callbacks( 2689 struct xlog *log, 2690 struct xlog_in_core *iclog) 2691 __releases(&log->l_icloglock) 2692 __acquires(&log->l_icloglock) 2693 { 2694 spin_unlock(&log->l_icloglock); 2695 spin_lock(&iclog->ic_callback_lock); 2696 while (!list_empty(&iclog->ic_callbacks)) { 2697 LIST_HEAD(tmp); 2698 2699 list_splice_init(&iclog->ic_callbacks, &tmp); 2700 2701 spin_unlock(&iclog->ic_callback_lock); 2702 xlog_cil_process_committed(&tmp); 2703 spin_lock(&iclog->ic_callback_lock); 2704 } 2705 2706 /* 2707 * Pick up the icloglock while still holding the callback lock so we 2708 * serialise against anyone trying to add more callbacks to this iclog 2709 * now we've finished processing. 2710 */ 2711 spin_lock(&log->l_icloglock); 2712 spin_unlock(&iclog->ic_callback_lock); 2713 } 2714 2715 STATIC void 2716 xlog_state_do_callback( 2717 struct xlog *log) 2718 { 2719 struct xlog_in_core *iclog; 2720 struct xlog_in_core *first_iclog; 2721 bool cycled_icloglock; 2722 bool ioerror; 2723 int flushcnt = 0; 2724 int repeats = 0; 2725 2726 spin_lock(&log->l_icloglock); 2727 do { 2728 /* 2729 * Scan all iclogs starting with the one pointed to by the 2730 * log. Reset this starting point each time the log is 2731 * unlocked (during callbacks). 2732 * 2733 * Keep looping through iclogs until one full pass is made 2734 * without running any callbacks. 2735 */ 2736 first_iclog = log->l_iclog; 2737 iclog = log->l_iclog; 2738 cycled_icloglock = false; 2739 ioerror = false; 2740 repeats++; 2741 2742 do { 2743 if (xlog_state_iodone_process_iclog(log, iclog, 2744 &ioerror)) 2745 break; 2746 2747 if (iclog->ic_state != XLOG_STATE_CALLBACK && 2748 iclog->ic_state != XLOG_STATE_IOERROR) { 2749 iclog = iclog->ic_next; 2750 continue; 2751 } 2752 2753 /* 2754 * Running callbacks will drop the icloglock which means 2755 * we'll have to run at least one more complete loop. 2756 */ 2757 cycled_icloglock = true; 2758 xlog_state_do_iclog_callbacks(log, iclog); 2759 if (XLOG_FORCED_SHUTDOWN(log)) 2760 wake_up_all(&iclog->ic_force_wait); 2761 else 2762 xlog_state_clean_iclog(log, iclog); 2763 iclog = iclog->ic_next; 2764 } while (first_iclog != iclog); 2765 2766 if (repeats > 5000) { 2767 flushcnt += repeats; 2768 repeats = 0; 2769 xfs_warn(log->l_mp, 2770 "%s: possible infinite loop (%d iterations)", 2771 __func__, flushcnt); 2772 } 2773 } while (!ioerror && cycled_icloglock); 2774 2775 if (log->l_iclog->ic_state == XLOG_STATE_ACTIVE || 2776 log->l_iclog->ic_state == XLOG_STATE_IOERROR) 2777 wake_up_all(&log->l_flush_wait); 2778 2779 spin_unlock(&log->l_icloglock); 2780 } 2781 2782 2783 /* 2784 * Finish transitioning this iclog to the dirty state. 2785 * 2786 * Make sure that we completely execute this routine only when this is 2787 * the last call to the iclog. There is a good chance that iclog flushes, 2788 * when we reach the end of the physical log, get turned into 2 separate 2789 * calls to bwrite. Hence, one iclog flush could generate two calls to this 2790 * routine. By using the reference count bwritecnt, we guarantee that only 2791 * the second completion goes through. 2792 * 2793 * Callbacks could take time, so they are done outside the scope of the 2794 * global state machine log lock. 2795 */ 2796 STATIC void 2797 xlog_state_done_syncing( 2798 struct xlog_in_core *iclog) 2799 { 2800 struct xlog *log = iclog->ic_log; 2801 2802 spin_lock(&log->l_icloglock); 2803 ASSERT(atomic_read(&iclog->ic_refcnt) == 0); 2804 2805 /* 2806 * If we got an error, either on the first buffer, or in the case of 2807 * split log writes, on the second, we shut down the file system and 2808 * no iclogs should ever be attempted to be written to disk again. 2809 */ 2810 if (!XLOG_FORCED_SHUTDOWN(log)) { 2811 ASSERT(iclog->ic_state == XLOG_STATE_SYNCING); 2812 iclog->ic_state = XLOG_STATE_DONE_SYNC; 2813 } 2814 2815 /* 2816 * Someone could be sleeping prior to writing out the next 2817 * iclog buffer, we wake them all, one will get to do the 2818 * I/O, the others get to wait for the result. 2819 */ 2820 wake_up_all(&iclog->ic_write_wait); 2821 spin_unlock(&log->l_icloglock); 2822 xlog_state_do_callback(log); 2823 } 2824 2825 /* 2826 * If the head of the in-core log ring is not (ACTIVE or DIRTY), then we must 2827 * sleep. We wait on the flush queue on the head iclog as that should be 2828 * the first iclog to complete flushing. Hence if all iclogs are syncing, 2829 * we will wait here and all new writes will sleep until a sync completes. 2830 * 2831 * The in-core logs are used in a circular fashion. They are not used 2832 * out-of-order even when an iclog past the head is free. 2833 * 2834 * return: 2835 * * log_offset where xlog_write() can start writing into the in-core 2836 * log's data space. 2837 * * in-core log pointer to which xlog_write() should write. 2838 * * boolean indicating this is a continued write to an in-core log. 2839 * If this is the last write, then the in-core log's offset field 2840 * needs to be incremented, depending on the amount of data which 2841 * is copied. 2842 */ 2843 STATIC int 2844 xlog_state_get_iclog_space( 2845 struct xlog *log, 2846 int len, 2847 struct xlog_in_core **iclogp, 2848 struct xlog_ticket *ticket, 2849 int *continued_write, 2850 int *logoffsetp) 2851 { 2852 int log_offset; 2853 xlog_rec_header_t *head; 2854 xlog_in_core_t *iclog; 2855 2856 restart: 2857 spin_lock(&log->l_icloglock); 2858 if (XLOG_FORCED_SHUTDOWN(log)) { 2859 spin_unlock(&log->l_icloglock); 2860 return -EIO; 2861 } 2862 2863 iclog = log->l_iclog; 2864 if (iclog->ic_state != XLOG_STATE_ACTIVE) { 2865 XFS_STATS_INC(log->l_mp, xs_log_noiclogs); 2866 2867 /* Wait for log writes to have flushed */ 2868 xlog_wait(&log->l_flush_wait, &log->l_icloglock); 2869 goto restart; 2870 } 2871 2872 head = &iclog->ic_header; 2873 2874 atomic_inc(&iclog->ic_refcnt); /* prevents sync */ 2875 log_offset = iclog->ic_offset; 2876 2877 /* On the 1st write to an iclog, figure out lsn. This works 2878 * if iclogs marked XLOG_STATE_WANT_SYNC always write out what they are 2879 * committing to. If the offset is set, that's how many blocks 2880 * must be written. 2881 */ 2882 if (log_offset == 0) { 2883 ticket->t_curr_res -= log->l_iclog_hsize; 2884 xlog_tic_add_region(ticket, 2885 log->l_iclog_hsize, 2886 XLOG_REG_TYPE_LRHEADER); 2887 head->h_cycle = cpu_to_be32(log->l_curr_cycle); 2888 head->h_lsn = cpu_to_be64( 2889 xlog_assign_lsn(log->l_curr_cycle, log->l_curr_block)); 2890 ASSERT(log->l_curr_block >= 0); 2891 } 2892 2893 /* If there is enough room to write everything, then do it. Otherwise, 2894 * claim the rest of the region and make sure the XLOG_STATE_WANT_SYNC 2895 * bit is on, so this will get flushed out. Don't update ic_offset 2896 * until you know exactly how many bytes get copied. Therefore, wait 2897 * until later to update ic_offset. 2898 * 2899 * xlog_write() algorithm assumes that at least 2 xlog_op_header_t's 2900 * can fit into remaining data section. 2901 */ 2902 if (iclog->ic_size - iclog->ic_offset < 2*sizeof(xlog_op_header_t)) { 2903 int error = 0; 2904 2905 xlog_state_switch_iclogs(log, iclog, iclog->ic_size); 2906 2907 /* 2908 * If we are the only one writing to this iclog, sync it to 2909 * disk. We need to do an atomic compare and decrement here to 2910 * avoid racing with concurrent atomic_dec_and_lock() calls in 2911 * xlog_state_release_iclog() when there is more than one 2912 * reference to the iclog. 2913 */ 2914 if (!atomic_add_unless(&iclog->ic_refcnt, -1, 1)) 2915 error = xlog_state_release_iclog(log, iclog); 2916 spin_unlock(&log->l_icloglock); 2917 if (error) 2918 return error; 2919 goto restart; 2920 } 2921 2922 /* Do we have enough room to write the full amount in the remainder 2923 * of this iclog? Or must we continue a write on the next iclog and 2924 * mark this iclog as completely taken? In the case where we switch 2925 * iclogs (to mark it taken), this particular iclog will release/sync 2926 * to disk in xlog_write(). 2927 */ 2928 if (len <= iclog->ic_size - iclog->ic_offset) { 2929 *continued_write = 0; 2930 iclog->ic_offset += len; 2931 } else { 2932 *continued_write = 1; 2933 xlog_state_switch_iclogs(log, iclog, iclog->ic_size); 2934 } 2935 *iclogp = iclog; 2936 2937 ASSERT(iclog->ic_offset <= iclog->ic_size); 2938 spin_unlock(&log->l_icloglock); 2939 2940 *logoffsetp = log_offset; 2941 return 0; 2942 } 2943 2944 /* 2945 * The first cnt-1 times a ticket goes through here we don't need to move the 2946 * grant write head because the permanent reservation has reserved cnt times the 2947 * unit amount. Release part of current permanent unit reservation and reset 2948 * current reservation to be one units worth. Also move grant reservation head 2949 * forward. 2950 */ 2951 void 2952 xfs_log_ticket_regrant( 2953 struct xlog *log, 2954 struct xlog_ticket *ticket) 2955 { 2956 trace_xfs_log_ticket_regrant(log, ticket); 2957 2958 if (ticket->t_cnt > 0) 2959 ticket->t_cnt--; 2960 2961 xlog_grant_sub_space(log, &log->l_reserve_head.grant, 2962 ticket->t_curr_res); 2963 xlog_grant_sub_space(log, &log->l_write_head.grant, 2964 ticket->t_curr_res); 2965 ticket->t_curr_res = ticket->t_unit_res; 2966 xlog_tic_reset_res(ticket); 2967 2968 trace_xfs_log_ticket_regrant_sub(log, ticket); 2969 2970 /* just return if we still have some of the pre-reserved space */ 2971 if (!ticket->t_cnt) { 2972 xlog_grant_add_space(log, &log->l_reserve_head.grant, 2973 ticket->t_unit_res); 2974 trace_xfs_log_ticket_regrant_exit(log, ticket); 2975 2976 ticket->t_curr_res = ticket->t_unit_res; 2977 xlog_tic_reset_res(ticket); 2978 } 2979 2980 xfs_log_ticket_put(ticket); 2981 } 2982 2983 /* 2984 * Give back the space left from a reservation. 2985 * 2986 * All the information we need to make a correct determination of space left 2987 * is present. For non-permanent reservations, things are quite easy. The 2988 * count should have been decremented to zero. We only need to deal with the 2989 * space remaining in the current reservation part of the ticket. If the 2990 * ticket contains a permanent reservation, there may be left over space which 2991 * needs to be released. A count of N means that N-1 refills of the current 2992 * reservation can be done before we need to ask for more space. The first 2993 * one goes to fill up the first current reservation. Once we run out of 2994 * space, the count will stay at zero and the only space remaining will be 2995 * in the current reservation field. 2996 */ 2997 void 2998 xfs_log_ticket_ungrant( 2999 struct xlog *log, 3000 struct xlog_ticket *ticket) 3001 { 3002 int bytes; 3003 3004 trace_xfs_log_ticket_ungrant(log, ticket); 3005 3006 if (ticket->t_cnt > 0) 3007 ticket->t_cnt--; 3008 3009 trace_xfs_log_ticket_ungrant_sub(log, ticket); 3010 3011 /* 3012 * If this is a permanent reservation ticket, we may be able to free 3013 * up more space based on the remaining count. 3014 */ 3015 bytes = ticket->t_curr_res; 3016 if (ticket->t_cnt > 0) { 3017 ASSERT(ticket->t_flags & XLOG_TIC_PERM_RESERV); 3018 bytes += ticket->t_unit_res*ticket->t_cnt; 3019 } 3020 3021 xlog_grant_sub_space(log, &log->l_reserve_head.grant, bytes); 3022 xlog_grant_sub_space(log, &log->l_write_head.grant, bytes); 3023 3024 trace_xfs_log_ticket_ungrant_exit(log, ticket); 3025 3026 xfs_log_space_wake(log->l_mp); 3027 xfs_log_ticket_put(ticket); 3028 } 3029 3030 /* 3031 * This routine will mark the current iclog in the ring as WANT_SYNC and move 3032 * the current iclog pointer to the next iclog in the ring. 3033 */ 3034 STATIC void 3035 xlog_state_switch_iclogs( 3036 struct xlog *log, 3037 struct xlog_in_core *iclog, 3038 int eventual_size) 3039 { 3040 ASSERT(iclog->ic_state == XLOG_STATE_ACTIVE); 3041 assert_spin_locked(&log->l_icloglock); 3042 3043 if (!eventual_size) 3044 eventual_size = iclog->ic_offset; 3045 iclog->ic_state = XLOG_STATE_WANT_SYNC; 3046 iclog->ic_header.h_prev_block = cpu_to_be32(log->l_prev_block); 3047 log->l_prev_block = log->l_curr_block; 3048 log->l_prev_cycle = log->l_curr_cycle; 3049 3050 /* roll log?: ic_offset changed later */ 3051 log->l_curr_block += BTOBB(eventual_size)+BTOBB(log->l_iclog_hsize); 3052 3053 /* Round up to next log-sunit */ 3054 if (xfs_sb_version_haslogv2(&log->l_mp->m_sb) && 3055 log->l_mp->m_sb.sb_logsunit > 1) { 3056 uint32_t sunit_bb = BTOBB(log->l_mp->m_sb.sb_logsunit); 3057 log->l_curr_block = roundup(log->l_curr_block, sunit_bb); 3058 } 3059 3060 if (log->l_curr_block >= log->l_logBBsize) { 3061 /* 3062 * Rewind the current block before the cycle is bumped to make 3063 * sure that the combined LSN never transiently moves forward 3064 * when the log wraps to the next cycle. This is to support the 3065 * unlocked sample of these fields from xlog_valid_lsn(). Most 3066 * other cases should acquire l_icloglock. 3067 */ 3068 log->l_curr_block -= log->l_logBBsize; 3069 ASSERT(log->l_curr_block >= 0); 3070 smp_wmb(); 3071 log->l_curr_cycle++; 3072 if (log->l_curr_cycle == XLOG_HEADER_MAGIC_NUM) 3073 log->l_curr_cycle++; 3074 } 3075 ASSERT(iclog == log->l_iclog); 3076 log->l_iclog = iclog->ic_next; 3077 } 3078 3079 /* 3080 * Write out all data in the in-core log as of this exact moment in time. 3081 * 3082 * Data may be written to the in-core log during this call. However, 3083 * we don't guarantee this data will be written out. A change from past 3084 * implementation means this routine will *not* write out zero length LRs. 3085 * 3086 * Basically, we try and perform an intelligent scan of the in-core logs. 3087 * If we determine there is no flushable data, we just return. There is no 3088 * flushable data if: 3089 * 3090 * 1. the current iclog is active and has no data; the previous iclog 3091 * is in the active or dirty state. 3092 * 2. the current iclog is drity, and the previous iclog is in the 3093 * active or dirty state. 3094 * 3095 * We may sleep if: 3096 * 3097 * 1. the current iclog is not in the active nor dirty state. 3098 * 2. the current iclog dirty, and the previous iclog is not in the 3099 * active nor dirty state. 3100 * 3. the current iclog is active, and there is another thread writing 3101 * to this particular iclog. 3102 * 4. a) the current iclog is active and has no other writers 3103 * b) when we return from flushing out this iclog, it is still 3104 * not in the active nor dirty state. 3105 */ 3106 int 3107 xfs_log_force( 3108 struct xfs_mount *mp, 3109 uint flags) 3110 { 3111 struct xlog *log = mp->m_log; 3112 struct xlog_in_core *iclog; 3113 xfs_lsn_t lsn; 3114 3115 XFS_STATS_INC(mp, xs_log_force); 3116 trace_xfs_log_force(mp, 0, _RET_IP_); 3117 3118 xlog_cil_force(log); 3119 3120 spin_lock(&log->l_icloglock); 3121 iclog = log->l_iclog; 3122 if (iclog->ic_state == XLOG_STATE_IOERROR) 3123 goto out_error; 3124 3125 if (iclog->ic_state == XLOG_STATE_DIRTY || 3126 (iclog->ic_state == XLOG_STATE_ACTIVE && 3127 atomic_read(&iclog->ic_refcnt) == 0 && iclog->ic_offset == 0)) { 3128 /* 3129 * If the head is dirty or (active and empty), then we need to 3130 * look at the previous iclog. 3131 * 3132 * If the previous iclog is active or dirty we are done. There 3133 * is nothing to sync out. Otherwise, we attach ourselves to the 3134 * previous iclog and go to sleep. 3135 */ 3136 iclog = iclog->ic_prev; 3137 } else if (iclog->ic_state == XLOG_STATE_ACTIVE) { 3138 if (atomic_read(&iclog->ic_refcnt) == 0) { 3139 /* 3140 * We are the only one with access to this iclog. 3141 * 3142 * Flush it out now. There should be a roundoff of zero 3143 * to show that someone has already taken care of the 3144 * roundoff from the previous sync. 3145 */ 3146 atomic_inc(&iclog->ic_refcnt); 3147 lsn = be64_to_cpu(iclog->ic_header.h_lsn); 3148 xlog_state_switch_iclogs(log, iclog, 0); 3149 if (xlog_state_release_iclog(log, iclog)) 3150 goto out_error; 3151 3152 if (be64_to_cpu(iclog->ic_header.h_lsn) != lsn) 3153 goto out_unlock; 3154 } else { 3155 /* 3156 * Someone else is writing to this iclog. 3157 * 3158 * Use its call to flush out the data. However, the 3159 * other thread may not force out this LR, so we mark 3160 * it WANT_SYNC. 3161 */ 3162 xlog_state_switch_iclogs(log, iclog, 0); 3163 } 3164 } else { 3165 /* 3166 * If the head iclog is not active nor dirty, we just attach 3167 * ourselves to the head and go to sleep if necessary. 3168 */ 3169 ; 3170 } 3171 3172 if (flags & XFS_LOG_SYNC) 3173 return xlog_wait_on_iclog(iclog); 3174 out_unlock: 3175 spin_unlock(&log->l_icloglock); 3176 return 0; 3177 out_error: 3178 spin_unlock(&log->l_icloglock); 3179 return -EIO; 3180 } 3181 3182 static int 3183 __xfs_log_force_lsn( 3184 struct xfs_mount *mp, 3185 xfs_lsn_t lsn, 3186 uint flags, 3187 int *log_flushed, 3188 bool already_slept) 3189 { 3190 struct xlog *log = mp->m_log; 3191 struct xlog_in_core *iclog; 3192 3193 spin_lock(&log->l_icloglock); 3194 iclog = log->l_iclog; 3195 if (iclog->ic_state == XLOG_STATE_IOERROR) 3196 goto out_error; 3197 3198 while (be64_to_cpu(iclog->ic_header.h_lsn) != lsn) { 3199 iclog = iclog->ic_next; 3200 if (iclog == log->l_iclog) 3201 goto out_unlock; 3202 } 3203 3204 if (iclog->ic_state == XLOG_STATE_ACTIVE) { 3205 /* 3206 * We sleep here if we haven't already slept (e.g. this is the 3207 * first time we've looked at the correct iclog buf) and the 3208 * buffer before us is going to be sync'ed. The reason for this 3209 * is that if we are doing sync transactions here, by waiting 3210 * for the previous I/O to complete, we can allow a few more 3211 * transactions into this iclog before we close it down. 3212 * 3213 * Otherwise, we mark the buffer WANT_SYNC, and bump up the 3214 * refcnt so we can release the log (which drops the ref count). 3215 * The state switch keeps new transaction commits from using 3216 * this buffer. When the current commits finish writing into 3217 * the buffer, the refcount will drop to zero and the buffer 3218 * will go out then. 3219 */ 3220 if (!already_slept && 3221 (iclog->ic_prev->ic_state == XLOG_STATE_WANT_SYNC || 3222 iclog->ic_prev->ic_state == XLOG_STATE_SYNCING)) { 3223 XFS_STATS_INC(mp, xs_log_force_sleep); 3224 3225 xlog_wait(&iclog->ic_prev->ic_write_wait, 3226 &log->l_icloglock); 3227 return -EAGAIN; 3228 } 3229 atomic_inc(&iclog->ic_refcnt); 3230 xlog_state_switch_iclogs(log, iclog, 0); 3231 if (xlog_state_release_iclog(log, iclog)) 3232 goto out_error; 3233 if (log_flushed) 3234 *log_flushed = 1; 3235 } 3236 3237 if (flags & XFS_LOG_SYNC) 3238 return xlog_wait_on_iclog(iclog); 3239 out_unlock: 3240 spin_unlock(&log->l_icloglock); 3241 return 0; 3242 out_error: 3243 spin_unlock(&log->l_icloglock); 3244 return -EIO; 3245 } 3246 3247 /* 3248 * Force the in-core log to disk for a specific LSN. 3249 * 3250 * Find in-core log with lsn. 3251 * If it is in the DIRTY state, just return. 3252 * If it is in the ACTIVE state, move the in-core log into the WANT_SYNC 3253 * state and go to sleep or return. 3254 * If it is in any other state, go to sleep or return. 3255 * 3256 * Synchronous forces are implemented with a wait queue. All callers trying 3257 * to force a given lsn to disk must wait on the queue attached to the 3258 * specific in-core log. When given in-core log finally completes its write 3259 * to disk, that thread will wake up all threads waiting on the queue. 3260 */ 3261 int 3262 xfs_log_force_lsn( 3263 struct xfs_mount *mp, 3264 xfs_lsn_t lsn, 3265 uint flags, 3266 int *log_flushed) 3267 { 3268 int ret; 3269 ASSERT(lsn != 0); 3270 3271 XFS_STATS_INC(mp, xs_log_force); 3272 trace_xfs_log_force(mp, lsn, _RET_IP_); 3273 3274 lsn = xlog_cil_force_lsn(mp->m_log, lsn); 3275 if (lsn == NULLCOMMITLSN) 3276 return 0; 3277 3278 ret = __xfs_log_force_lsn(mp, lsn, flags, log_flushed, false); 3279 if (ret == -EAGAIN) 3280 ret = __xfs_log_force_lsn(mp, lsn, flags, log_flushed, true); 3281 return ret; 3282 } 3283 3284 /* 3285 * Free a used ticket when its refcount falls to zero. 3286 */ 3287 void 3288 xfs_log_ticket_put( 3289 xlog_ticket_t *ticket) 3290 { 3291 ASSERT(atomic_read(&ticket->t_ref) > 0); 3292 if (atomic_dec_and_test(&ticket->t_ref)) 3293 kmem_cache_free(xfs_log_ticket_zone, ticket); 3294 } 3295 3296 xlog_ticket_t * 3297 xfs_log_ticket_get( 3298 xlog_ticket_t *ticket) 3299 { 3300 ASSERT(atomic_read(&ticket->t_ref) > 0); 3301 atomic_inc(&ticket->t_ref); 3302 return ticket; 3303 } 3304 3305 /* 3306 * Figure out the total log space unit (in bytes) that would be 3307 * required for a log ticket. 3308 */ 3309 int 3310 xfs_log_calc_unit_res( 3311 struct xfs_mount *mp, 3312 int unit_bytes) 3313 { 3314 struct xlog *log = mp->m_log; 3315 int iclog_space; 3316 uint num_headers; 3317 3318 /* 3319 * Permanent reservations have up to 'cnt'-1 active log operations 3320 * in the log. A unit in this case is the amount of space for one 3321 * of these log operations. Normal reservations have a cnt of 1 3322 * and their unit amount is the total amount of space required. 3323 * 3324 * The following lines of code account for non-transaction data 3325 * which occupy space in the on-disk log. 3326 * 3327 * Normal form of a transaction is: 3328 * <oph><trans-hdr><start-oph><reg1-oph><reg1><reg2-oph>...<commit-oph> 3329 * and then there are LR hdrs, split-recs and roundoff at end of syncs. 3330 * 3331 * We need to account for all the leadup data and trailer data 3332 * around the transaction data. 3333 * And then we need to account for the worst case in terms of using 3334 * more space. 3335 * The worst case will happen if: 3336 * - the placement of the transaction happens to be such that the 3337 * roundoff is at its maximum 3338 * - the transaction data is synced before the commit record is synced 3339 * i.e. <transaction-data><roundoff> | <commit-rec><roundoff> 3340 * Therefore the commit record is in its own Log Record. 3341 * This can happen as the commit record is called with its 3342 * own region to xlog_write(). 3343 * This then means that in the worst case, roundoff can happen for 3344 * the commit-rec as well. 3345 * The commit-rec is smaller than padding in this scenario and so it is 3346 * not added separately. 3347 */ 3348 3349 /* for trans header */ 3350 unit_bytes += sizeof(xlog_op_header_t); 3351 unit_bytes += sizeof(xfs_trans_header_t); 3352 3353 /* for start-rec */ 3354 unit_bytes += sizeof(xlog_op_header_t); 3355 3356 /* 3357 * for LR headers - the space for data in an iclog is the size minus 3358 * the space used for the headers. If we use the iclog size, then we 3359 * undercalculate the number of headers required. 3360 * 3361 * Furthermore - the addition of op headers for split-recs might 3362 * increase the space required enough to require more log and op 3363 * headers, so take that into account too. 3364 * 3365 * IMPORTANT: This reservation makes the assumption that if this 3366 * transaction is the first in an iclog and hence has the LR headers 3367 * accounted to it, then the remaining space in the iclog is 3368 * exclusively for this transaction. i.e. if the transaction is larger 3369 * than the iclog, it will be the only thing in that iclog. 3370 * Fundamentally, this means we must pass the entire log vector to 3371 * xlog_write to guarantee this. 3372 */ 3373 iclog_space = log->l_iclog_size - log->l_iclog_hsize; 3374 num_headers = howmany(unit_bytes, iclog_space); 3375 3376 /* for split-recs - ophdrs added when data split over LRs */ 3377 unit_bytes += sizeof(xlog_op_header_t) * num_headers; 3378 3379 /* add extra header reservations if we overrun */ 3380 while (!num_headers || 3381 howmany(unit_bytes, iclog_space) > num_headers) { 3382 unit_bytes += sizeof(xlog_op_header_t); 3383 num_headers++; 3384 } 3385 unit_bytes += log->l_iclog_hsize * num_headers; 3386 3387 /* for commit-rec LR header - note: padding will subsume the ophdr */ 3388 unit_bytes += log->l_iclog_hsize; 3389 3390 /* for roundoff padding for transaction data and one for commit record */ 3391 if (xfs_sb_version_haslogv2(&mp->m_sb) && mp->m_sb.sb_logsunit > 1) { 3392 /* log su roundoff */ 3393 unit_bytes += 2 * mp->m_sb.sb_logsunit; 3394 } else { 3395 /* BB roundoff */ 3396 unit_bytes += 2 * BBSIZE; 3397 } 3398 3399 return unit_bytes; 3400 } 3401 3402 /* 3403 * Allocate and initialise a new log ticket. 3404 */ 3405 struct xlog_ticket * 3406 xlog_ticket_alloc( 3407 struct xlog *log, 3408 int unit_bytes, 3409 int cnt, 3410 char client, 3411 bool permanent, 3412 xfs_km_flags_t alloc_flags) 3413 { 3414 struct xlog_ticket *tic; 3415 int unit_res; 3416 3417 tic = kmem_zone_zalloc(xfs_log_ticket_zone, alloc_flags); 3418 if (!tic) 3419 return NULL; 3420 3421 unit_res = xfs_log_calc_unit_res(log->l_mp, unit_bytes); 3422 3423 atomic_set(&tic->t_ref, 1); 3424 tic->t_task = current; 3425 INIT_LIST_HEAD(&tic->t_queue); 3426 tic->t_unit_res = unit_res; 3427 tic->t_curr_res = unit_res; 3428 tic->t_cnt = cnt; 3429 tic->t_ocnt = cnt; 3430 tic->t_tid = prandom_u32(); 3431 tic->t_clientid = client; 3432 if (permanent) 3433 tic->t_flags |= XLOG_TIC_PERM_RESERV; 3434 3435 xlog_tic_reset_res(tic); 3436 3437 return tic; 3438 } 3439 3440 #if defined(DEBUG) 3441 /* 3442 * Make sure that the destination ptr is within the valid data region of 3443 * one of the iclogs. This uses backup pointers stored in a different 3444 * part of the log in case we trash the log structure. 3445 */ 3446 STATIC void 3447 xlog_verify_dest_ptr( 3448 struct xlog *log, 3449 void *ptr) 3450 { 3451 int i; 3452 int good_ptr = 0; 3453 3454 for (i = 0; i < log->l_iclog_bufs; i++) { 3455 if (ptr >= log->l_iclog_bak[i] && 3456 ptr <= log->l_iclog_bak[i] + log->l_iclog_size) 3457 good_ptr++; 3458 } 3459 3460 if (!good_ptr) 3461 xfs_emerg(log->l_mp, "%s: invalid ptr", __func__); 3462 } 3463 3464 /* 3465 * Check to make sure the grant write head didn't just over lap the tail. If 3466 * the cycles are the same, we can't be overlapping. Otherwise, make sure that 3467 * the cycles differ by exactly one and check the byte count. 3468 * 3469 * This check is run unlocked, so can give false positives. Rather than assert 3470 * on failures, use a warn-once flag and a panic tag to allow the admin to 3471 * determine if they want to panic the machine when such an error occurs. For 3472 * debug kernels this will have the same effect as using an assert but, unlinke 3473 * an assert, it can be turned off at runtime. 3474 */ 3475 STATIC void 3476 xlog_verify_grant_tail( 3477 struct xlog *log) 3478 { 3479 int tail_cycle, tail_blocks; 3480 int cycle, space; 3481 3482 xlog_crack_grant_head(&log->l_write_head.grant, &cycle, &space); 3483 xlog_crack_atomic_lsn(&log->l_tail_lsn, &tail_cycle, &tail_blocks); 3484 if (tail_cycle != cycle) { 3485 if (cycle - 1 != tail_cycle && 3486 !(log->l_flags & XLOG_TAIL_WARN)) { 3487 xfs_alert_tag(log->l_mp, XFS_PTAG_LOGRES, 3488 "%s: cycle - 1 != tail_cycle", __func__); 3489 log->l_flags |= XLOG_TAIL_WARN; 3490 } 3491 3492 if (space > BBTOB(tail_blocks) && 3493 !(log->l_flags & XLOG_TAIL_WARN)) { 3494 xfs_alert_tag(log->l_mp, XFS_PTAG_LOGRES, 3495 "%s: space > BBTOB(tail_blocks)", __func__); 3496 log->l_flags |= XLOG_TAIL_WARN; 3497 } 3498 } 3499 } 3500 3501 /* check if it will fit */ 3502 STATIC void 3503 xlog_verify_tail_lsn( 3504 struct xlog *log, 3505 struct xlog_in_core *iclog, 3506 xfs_lsn_t tail_lsn) 3507 { 3508 int blocks; 3509 3510 if (CYCLE_LSN(tail_lsn) == log->l_prev_cycle) { 3511 blocks = 3512 log->l_logBBsize - (log->l_prev_block - BLOCK_LSN(tail_lsn)); 3513 if (blocks < BTOBB(iclog->ic_offset)+BTOBB(log->l_iclog_hsize)) 3514 xfs_emerg(log->l_mp, "%s: ran out of log space", __func__); 3515 } else { 3516 ASSERT(CYCLE_LSN(tail_lsn)+1 == log->l_prev_cycle); 3517 3518 if (BLOCK_LSN(tail_lsn) == log->l_prev_block) 3519 xfs_emerg(log->l_mp, "%s: tail wrapped", __func__); 3520 3521 blocks = BLOCK_LSN(tail_lsn) - log->l_prev_block; 3522 if (blocks < BTOBB(iclog->ic_offset) + 1) 3523 xfs_emerg(log->l_mp, "%s: ran out of log space", __func__); 3524 } 3525 } 3526 3527 /* 3528 * Perform a number of checks on the iclog before writing to disk. 3529 * 3530 * 1. Make sure the iclogs are still circular 3531 * 2. Make sure we have a good magic number 3532 * 3. Make sure we don't have magic numbers in the data 3533 * 4. Check fields of each log operation header for: 3534 * A. Valid client identifier 3535 * B. tid ptr value falls in valid ptr space (user space code) 3536 * C. Length in log record header is correct according to the 3537 * individual operation headers within record. 3538 * 5. When a bwrite will occur within 5 blocks of the front of the physical 3539 * log, check the preceding blocks of the physical log to make sure all 3540 * the cycle numbers agree with the current cycle number. 3541 */ 3542 STATIC void 3543 xlog_verify_iclog( 3544 struct xlog *log, 3545 struct xlog_in_core *iclog, 3546 int count) 3547 { 3548 xlog_op_header_t *ophead; 3549 xlog_in_core_t *icptr; 3550 xlog_in_core_2_t *xhdr; 3551 void *base_ptr, *ptr, *p; 3552 ptrdiff_t field_offset; 3553 uint8_t clientid; 3554 int len, i, j, k, op_len; 3555 int idx; 3556 3557 /* check validity of iclog pointers */ 3558 spin_lock(&log->l_icloglock); 3559 icptr = log->l_iclog; 3560 for (i = 0; i < log->l_iclog_bufs; i++, icptr = icptr->ic_next) 3561 ASSERT(icptr); 3562 3563 if (icptr != log->l_iclog) 3564 xfs_emerg(log->l_mp, "%s: corrupt iclog ring", __func__); 3565 spin_unlock(&log->l_icloglock); 3566 3567 /* check log magic numbers */ 3568 if (iclog->ic_header.h_magicno != cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) 3569 xfs_emerg(log->l_mp, "%s: invalid magic num", __func__); 3570 3571 base_ptr = ptr = &iclog->ic_header; 3572 p = &iclog->ic_header; 3573 for (ptr += BBSIZE; ptr < base_ptr + count; ptr += BBSIZE) { 3574 if (*(__be32 *)ptr == cpu_to_be32(XLOG_HEADER_MAGIC_NUM)) 3575 xfs_emerg(log->l_mp, "%s: unexpected magic num", 3576 __func__); 3577 } 3578 3579 /* check fields */ 3580 len = be32_to_cpu(iclog->ic_header.h_num_logops); 3581 base_ptr = ptr = iclog->ic_datap; 3582 ophead = ptr; 3583 xhdr = iclog->ic_data; 3584 for (i = 0; i < len; i++) { 3585 ophead = ptr; 3586 3587 /* clientid is only 1 byte */ 3588 p = &ophead->oh_clientid; 3589 field_offset = p - base_ptr; 3590 if (field_offset & 0x1ff) { 3591 clientid = ophead->oh_clientid; 3592 } else { 3593 idx = BTOBBT((char *)&ophead->oh_clientid - iclog->ic_datap); 3594 if (idx >= (XLOG_HEADER_CYCLE_SIZE / BBSIZE)) { 3595 j = idx / (XLOG_HEADER_CYCLE_SIZE / BBSIZE); 3596 k = idx % (XLOG_HEADER_CYCLE_SIZE / BBSIZE); 3597 clientid = xlog_get_client_id( 3598 xhdr[j].hic_xheader.xh_cycle_data[k]); 3599 } else { 3600 clientid = xlog_get_client_id( 3601 iclog->ic_header.h_cycle_data[idx]); 3602 } 3603 } 3604 if (clientid != XFS_TRANSACTION && clientid != XFS_LOG) 3605 xfs_warn(log->l_mp, 3606 "%s: invalid clientid %d op "PTR_FMT" offset 0x%lx", 3607 __func__, clientid, ophead, 3608 (unsigned long)field_offset); 3609 3610 /* check length */ 3611 p = &ophead->oh_len; 3612 field_offset = p - base_ptr; 3613 if (field_offset & 0x1ff) { 3614 op_len = be32_to_cpu(ophead->oh_len); 3615 } else { 3616 idx = BTOBBT((uintptr_t)&ophead->oh_len - 3617 (uintptr_t)iclog->ic_datap); 3618 if (idx >= (XLOG_HEADER_CYCLE_SIZE / BBSIZE)) { 3619 j = idx / (XLOG_HEADER_CYCLE_SIZE / BBSIZE); 3620 k = idx % (XLOG_HEADER_CYCLE_SIZE / BBSIZE); 3621 op_len = be32_to_cpu(xhdr[j].hic_xheader.xh_cycle_data[k]); 3622 } else { 3623 op_len = be32_to_cpu(iclog->ic_header.h_cycle_data[idx]); 3624 } 3625 } 3626 ptr += sizeof(xlog_op_header_t) + op_len; 3627 } 3628 } 3629 #endif 3630 3631 /* 3632 * Mark all iclogs IOERROR. l_icloglock is held by the caller. 3633 */ 3634 STATIC int 3635 xlog_state_ioerror( 3636 struct xlog *log) 3637 { 3638 xlog_in_core_t *iclog, *ic; 3639 3640 iclog = log->l_iclog; 3641 if (iclog->ic_state != XLOG_STATE_IOERROR) { 3642 /* 3643 * Mark all the incore logs IOERROR. 3644 * From now on, no log flushes will result. 3645 */ 3646 ic = iclog; 3647 do { 3648 ic->ic_state = XLOG_STATE_IOERROR; 3649 ic = ic->ic_next; 3650 } while (ic != iclog); 3651 return 0; 3652 } 3653 /* 3654 * Return non-zero, if state transition has already happened. 3655 */ 3656 return 1; 3657 } 3658 3659 /* 3660 * This is called from xfs_force_shutdown, when we're forcibly 3661 * shutting down the filesystem, typically because of an IO error. 3662 * Our main objectives here are to make sure that: 3663 * a. if !logerror, flush the logs to disk. Anything modified 3664 * after this is ignored. 3665 * b. the filesystem gets marked 'SHUTDOWN' for all interested 3666 * parties to find out, 'atomically'. 3667 * c. those who're sleeping on log reservations, pinned objects and 3668 * other resources get woken up, and be told the bad news. 3669 * d. nothing new gets queued up after (b) and (c) are done. 3670 * 3671 * Note: for the !logerror case we need to flush the regions held in memory out 3672 * to disk first. This needs to be done before the log is marked as shutdown, 3673 * otherwise the iclog writes will fail. 3674 */ 3675 int 3676 xfs_log_force_umount( 3677 struct xfs_mount *mp, 3678 int logerror) 3679 { 3680 struct xlog *log; 3681 int retval; 3682 3683 log = mp->m_log; 3684 3685 /* 3686 * If this happens during log recovery, don't worry about 3687 * locking; the log isn't open for business yet. 3688 */ 3689 if (!log || 3690 log->l_flags & XLOG_ACTIVE_RECOVERY) { 3691 mp->m_flags |= XFS_MOUNT_FS_SHUTDOWN; 3692 if (mp->m_sb_bp) 3693 mp->m_sb_bp->b_flags |= XBF_DONE; 3694 return 0; 3695 } 3696 3697 /* 3698 * Somebody could've already done the hard work for us. 3699 * No need to get locks for this. 3700 */ 3701 if (logerror && log->l_iclog->ic_state == XLOG_STATE_IOERROR) { 3702 ASSERT(XLOG_FORCED_SHUTDOWN(log)); 3703 return 1; 3704 } 3705 3706 /* 3707 * Flush all the completed transactions to disk before marking the log 3708 * being shut down. We need to do it in this order to ensure that 3709 * completed operations are safely on disk before we shut down, and that 3710 * we don't have to issue any buffer IO after the shutdown flags are set 3711 * to guarantee this. 3712 */ 3713 if (!logerror) 3714 xfs_log_force(mp, XFS_LOG_SYNC); 3715 3716 /* 3717 * mark the filesystem and the as in a shutdown state and wake 3718 * everybody up to tell them the bad news. 3719 */ 3720 spin_lock(&log->l_icloglock); 3721 mp->m_flags |= XFS_MOUNT_FS_SHUTDOWN; 3722 if (mp->m_sb_bp) 3723 mp->m_sb_bp->b_flags |= XBF_DONE; 3724 3725 /* 3726 * Mark the log and the iclogs with IO error flags to prevent any 3727 * further log IO from being issued or completed. 3728 */ 3729 log->l_flags |= XLOG_IO_ERROR; 3730 retval = xlog_state_ioerror(log); 3731 spin_unlock(&log->l_icloglock); 3732 3733 /* 3734 * We don't want anybody waiting for log reservations after this. That 3735 * means we have to wake up everybody queued up on reserveq as well as 3736 * writeq. In addition, we make sure in xlog_{re}grant_log_space that 3737 * we don't enqueue anything once the SHUTDOWN flag is set, and this 3738 * action is protected by the grant locks. 3739 */ 3740 xlog_grant_head_wake_all(&log->l_reserve_head); 3741 xlog_grant_head_wake_all(&log->l_write_head); 3742 3743 /* 3744 * Wake up everybody waiting on xfs_log_force. Wake the CIL push first 3745 * as if the log writes were completed. The abort handling in the log 3746 * item committed callback functions will do this again under lock to 3747 * avoid races. 3748 */ 3749 spin_lock(&log->l_cilp->xc_push_lock); 3750 wake_up_all(&log->l_cilp->xc_commit_wait); 3751 spin_unlock(&log->l_cilp->xc_push_lock); 3752 xlog_state_do_callback(log); 3753 3754 /* return non-zero if log IOERROR transition had already happened */ 3755 return retval; 3756 } 3757 3758 STATIC int 3759 xlog_iclogs_empty( 3760 struct xlog *log) 3761 { 3762 xlog_in_core_t *iclog; 3763 3764 iclog = log->l_iclog; 3765 do { 3766 /* endianness does not matter here, zero is zero in 3767 * any language. 3768 */ 3769 if (iclog->ic_header.h_num_logops) 3770 return 0; 3771 iclog = iclog->ic_next; 3772 } while (iclog != log->l_iclog); 3773 return 1; 3774 } 3775 3776 /* 3777 * Verify that an LSN stamped into a piece of metadata is valid. This is 3778 * intended for use in read verifiers on v5 superblocks. 3779 */ 3780 bool 3781 xfs_log_check_lsn( 3782 struct xfs_mount *mp, 3783 xfs_lsn_t lsn) 3784 { 3785 struct xlog *log = mp->m_log; 3786 bool valid; 3787 3788 /* 3789 * norecovery mode skips mount-time log processing and unconditionally 3790 * resets the in-core LSN. We can't validate in this mode, but 3791 * modifications are not allowed anyways so just return true. 3792 */ 3793 if (mp->m_flags & XFS_MOUNT_NORECOVERY) 3794 return true; 3795 3796 /* 3797 * Some metadata LSNs are initialized to NULL (e.g., the agfl). This is 3798 * handled by recovery and thus safe to ignore here. 3799 */ 3800 if (lsn == NULLCOMMITLSN) 3801 return true; 3802 3803 valid = xlog_valid_lsn(mp->m_log, lsn); 3804 3805 /* warn the user about what's gone wrong before verifier failure */ 3806 if (!valid) { 3807 spin_lock(&log->l_icloglock); 3808 xfs_warn(mp, 3809 "Corruption warning: Metadata has LSN (%d:%d) ahead of current LSN (%d:%d). " 3810 "Please unmount and run xfs_repair (>= v4.3) to resolve.", 3811 CYCLE_LSN(lsn), BLOCK_LSN(lsn), 3812 log->l_curr_cycle, log->l_curr_block); 3813 spin_unlock(&log->l_icloglock); 3814 } 3815 3816 return valid; 3817 } 3818 3819 bool 3820 xfs_log_in_recovery( 3821 struct xfs_mount *mp) 3822 { 3823 struct xlog *log = mp->m_log; 3824 3825 return log->l_flags & XLOG_ACTIVE_RECOVERY; 3826 } 3827