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