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