/fs/xfs/xfs_log.c
C | 3753 lines | 2261 code | 440 blank | 1052 comment | 420 complexity | 0d6ab3726121eb7735de7103e0722919 MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0
Large files files are truncated, but you can click here to view the full file
1/* 2 * Copyright (c) 2000-2005 Silicon Graphics, Inc. 3 * All Rights Reserved. 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it would be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write the Free Software Foundation, 16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 17 */ 18#include "xfs.h" 19#include "xfs_fs.h" 20#include "xfs_types.h" 21#include "xfs_bit.h" 22#include "xfs_log.h" 23#include "xfs_inum.h" 24#include "xfs_trans.h" 25#include "xfs_sb.h" 26#include "xfs_ag.h" 27#include "xfs_mount.h" 28#include "xfs_error.h" 29#include "xfs_log_priv.h" 30#include "xfs_buf_item.h" 31#include "xfs_bmap_btree.h" 32#include "xfs_alloc_btree.h" 33#include "xfs_ialloc_btree.h" 34#include "xfs_log_recover.h" 35#include "xfs_trans_priv.h" 36#include "xfs_dinode.h" 37#include "xfs_inode.h" 38#include "xfs_rw.h" 39#include "xfs_trace.h" 40 41kmem_zone_t *xfs_log_ticket_zone; 42 43/* Local miscellaneous function prototypes */ 44STATIC int xlog_commit_record(struct log *log, struct xlog_ticket *ticket, 45 xlog_in_core_t **, xfs_lsn_t *); 46STATIC xlog_t * xlog_alloc_log(xfs_mount_t *mp, 47 xfs_buftarg_t *log_target, 48 xfs_daddr_t blk_offset, 49 int num_bblks); 50STATIC int xlog_space_left(struct log *log, atomic64_t *head); 51STATIC int xlog_sync(xlog_t *log, xlog_in_core_t *iclog); 52STATIC void xlog_dealloc_log(xlog_t *log); 53 54/* local state machine functions */ 55STATIC void xlog_state_done_syncing(xlog_in_core_t *iclog, int); 56STATIC void xlog_state_do_callback(xlog_t *log,int aborted, xlog_in_core_t *iclog); 57STATIC int xlog_state_get_iclog_space(xlog_t *log, 58 int len, 59 xlog_in_core_t **iclog, 60 xlog_ticket_t *ticket, 61 int *continued_write, 62 int *logoffsetp); 63STATIC int xlog_state_release_iclog(xlog_t *log, 64 xlog_in_core_t *iclog); 65STATIC void xlog_state_switch_iclogs(xlog_t *log, 66 xlog_in_core_t *iclog, 67 int eventual_size); 68STATIC void xlog_state_want_sync(xlog_t *log, xlog_in_core_t *iclog); 69 70/* local functions to manipulate grant head */ 71STATIC int xlog_grant_log_space(xlog_t *log, 72 xlog_ticket_t *xtic); 73STATIC void xlog_grant_push_ail(struct log *log, 74 int need_bytes); 75STATIC void xlog_regrant_reserve_log_space(xlog_t *log, 76 xlog_ticket_t *ticket); 77STATIC int xlog_regrant_write_log_space(xlog_t *log, 78 xlog_ticket_t *ticket); 79STATIC void xlog_ungrant_log_space(xlog_t *log, 80 xlog_ticket_t *ticket); 81 82#if defined(DEBUG) 83STATIC void xlog_verify_dest_ptr(xlog_t *log, char *ptr); 84STATIC void xlog_verify_grant_tail(struct log *log); 85STATIC void xlog_verify_iclog(xlog_t *log, xlog_in_core_t *iclog, 86 int count, boolean_t syncing); 87STATIC void xlog_verify_tail_lsn(xlog_t *log, xlog_in_core_t *iclog, 88 xfs_lsn_t tail_lsn); 89#else 90#define xlog_verify_dest_ptr(a,b) 91#define xlog_verify_grant_tail(a) 92#define xlog_verify_iclog(a,b,c,d) 93#define xlog_verify_tail_lsn(a,b,c) 94#endif 95 96STATIC int xlog_iclogs_empty(xlog_t *log); 97 98static void 99xlog_grant_sub_space( 100 struct log *log, 101 atomic64_t *head, 102 int bytes) 103{ 104 int64_t head_val = atomic64_read(head); 105 int64_t new, old; 106 107 do { 108 int cycle, space; 109 110 xlog_crack_grant_head_val(head_val, &cycle, &space); 111 112 space -= bytes; 113 if (space < 0) { 114 space += log->l_logsize; 115 cycle--; 116 } 117 118 old = head_val; 119 new = xlog_assign_grant_head_val(cycle, space); 120 head_val = atomic64_cmpxchg(head, old, new); 121 } while (head_val != old); 122} 123 124static void 125xlog_grant_add_space( 126 struct log *log, 127 atomic64_t *head, 128 int bytes) 129{ 130 int64_t head_val = atomic64_read(head); 131 int64_t new, old; 132 133 do { 134 int tmp; 135 int cycle, space; 136 137 xlog_crack_grant_head_val(head_val, &cycle, &space); 138 139 tmp = log->l_logsize - space; 140 if (tmp > bytes) 141 space += bytes; 142 else { 143 space = bytes - tmp; 144 cycle++; 145 } 146 147 old = head_val; 148 new = xlog_assign_grant_head_val(cycle, space); 149 head_val = atomic64_cmpxchg(head, old, new); 150 } while (head_val != old); 151} 152 153static void 154xlog_tic_reset_res(xlog_ticket_t *tic) 155{ 156 tic->t_res_num = 0; 157 tic->t_res_arr_sum = 0; 158 tic->t_res_num_ophdrs = 0; 159} 160 161static void 162xlog_tic_add_region(xlog_ticket_t *tic, uint len, uint type) 163{ 164 if (tic->t_res_num == XLOG_TIC_LEN_MAX) { 165 /* add to overflow and start again */ 166 tic->t_res_o_flow += tic->t_res_arr_sum; 167 tic->t_res_num = 0; 168 tic->t_res_arr_sum = 0; 169 } 170 171 tic->t_res_arr[tic->t_res_num].r_len = len; 172 tic->t_res_arr[tic->t_res_num].r_type = type; 173 tic->t_res_arr_sum += len; 174 tic->t_res_num++; 175} 176 177/* 178 * NOTES: 179 * 180 * 1. currblock field gets updated at startup and after in-core logs 181 * marked as with WANT_SYNC. 182 */ 183 184/* 185 * This routine is called when a user of a log manager ticket is done with 186 * the reservation. If the ticket was ever used, then a commit record for 187 * the associated transaction is written out as a log operation header with 188 * no data. The flag XLOG_TIC_INITED is set when the first write occurs with 189 * a given ticket. If the ticket was one with a permanent reservation, then 190 * a few operations are done differently. Permanent reservation tickets by 191 * default don't release the reservation. They just commit the current 192 * transaction with the belief that the reservation is still needed. A flag 193 * must be passed in before permanent reservations are actually released. 194 * When these type of tickets are not released, they need to be set into 195 * the inited state again. By doing this, a start record will be written 196 * out when the next write occurs. 197 */ 198xfs_lsn_t 199xfs_log_done( 200 struct xfs_mount *mp, 201 struct xlog_ticket *ticket, 202 struct xlog_in_core **iclog, 203 uint flags) 204{ 205 struct log *log = mp->m_log; 206 xfs_lsn_t lsn = 0; 207 208 if (XLOG_FORCED_SHUTDOWN(log) || 209 /* 210 * If nothing was ever written, don't write out commit record. 211 * If we get an error, just continue and give back the log ticket. 212 */ 213 (((ticket->t_flags & XLOG_TIC_INITED) == 0) && 214 (xlog_commit_record(log, ticket, iclog, &lsn)))) { 215 lsn = (xfs_lsn_t) -1; 216 if (ticket->t_flags & XLOG_TIC_PERM_RESERV) { 217 flags |= XFS_LOG_REL_PERM_RESERV; 218 } 219 } 220 221 222 if ((ticket->t_flags & XLOG_TIC_PERM_RESERV) == 0 || 223 (flags & XFS_LOG_REL_PERM_RESERV)) { 224 trace_xfs_log_done_nonperm(log, ticket); 225 226 /* 227 * Release ticket if not permanent reservation or a specific 228 * request has been made to release a permanent reservation. 229 */ 230 xlog_ungrant_log_space(log, ticket); 231 xfs_log_ticket_put(ticket); 232 } else { 233 trace_xfs_log_done_perm(log, ticket); 234 235 xlog_regrant_reserve_log_space(log, ticket); 236 /* If this ticket was a permanent reservation and we aren't 237 * trying to release it, reset the inited flags; so next time 238 * we write, a start record will be written out. 239 */ 240 ticket->t_flags |= XLOG_TIC_INITED; 241 } 242 243 return lsn; 244} 245 246/* 247 * Attaches a new iclog I/O completion callback routine during 248 * transaction commit. If the log is in error state, a non-zero 249 * return code is handed back and the caller is responsible for 250 * executing the callback at an appropriate time. 251 */ 252int 253xfs_log_notify( 254 struct xfs_mount *mp, 255 struct xlog_in_core *iclog, 256 xfs_log_callback_t *cb) 257{ 258 int abortflg; 259 260 spin_lock(&iclog->ic_callback_lock); 261 abortflg = (iclog->ic_state & XLOG_STATE_IOERROR); 262 if (!abortflg) { 263 ASSERT_ALWAYS((iclog->ic_state == XLOG_STATE_ACTIVE) || 264 (iclog->ic_state == XLOG_STATE_WANT_SYNC)); 265 cb->cb_next = NULL; 266 *(iclog->ic_callback_tail) = cb; 267 iclog->ic_callback_tail = &(cb->cb_next); 268 } 269 spin_unlock(&iclog->ic_callback_lock); 270 return abortflg; 271} 272 273int 274xfs_log_release_iclog( 275 struct xfs_mount *mp, 276 struct xlog_in_core *iclog) 277{ 278 if (xlog_state_release_iclog(mp->m_log, iclog)) { 279 xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR); 280 return EIO; 281 } 282 283 return 0; 284} 285 286/* 287 * 1. Reserve an amount of on-disk log space and return a ticket corresponding 288 * to the reservation. 289 * 2. Potentially, push buffers at tail of log to disk. 290 * 291 * Each reservation is going to reserve extra space for a log record header. 292 * When writes happen to the on-disk log, we don't subtract the length of the 293 * log record header from any reservation. By wasting space in each 294 * reservation, we prevent over allocation problems. 295 */ 296int 297xfs_log_reserve( 298 struct xfs_mount *mp, 299 int unit_bytes, 300 int cnt, 301 struct xlog_ticket **ticket, 302 __uint8_t client, 303 uint flags, 304 uint t_type) 305{ 306 struct log *log = mp->m_log; 307 struct xlog_ticket *internal_ticket; 308 int retval = 0; 309 310 ASSERT(client == XFS_TRANSACTION || client == XFS_LOG); 311 312 if (XLOG_FORCED_SHUTDOWN(log)) 313 return XFS_ERROR(EIO); 314 315 XFS_STATS_INC(xs_try_logspace); 316 317 318 if (*ticket != NULL) { 319 ASSERT(flags & XFS_LOG_PERM_RESERV); 320 internal_ticket = *ticket; 321 322 /* 323 * this is a new transaction on the ticket, so we need to 324 * change the transaction ID so that the next transaction has a 325 * different TID in the log. Just add one to the existing tid 326 * so that we can see chains of rolling transactions in the log 327 * easily. 328 */ 329 internal_ticket->t_tid++; 330 331 trace_xfs_log_reserve(log, internal_ticket); 332 333 xlog_grant_push_ail(log, internal_ticket->t_unit_res); 334 retval = xlog_regrant_write_log_space(log, internal_ticket); 335 } else { 336 /* may sleep if need to allocate more tickets */ 337 internal_ticket = xlog_ticket_alloc(log, unit_bytes, cnt, 338 client, flags, 339 KM_SLEEP|KM_MAYFAIL); 340 if (!internal_ticket) 341 return XFS_ERROR(ENOMEM); 342 internal_ticket->t_trans_type = t_type; 343 *ticket = internal_ticket; 344 345 trace_xfs_log_reserve(log, internal_ticket); 346 347 xlog_grant_push_ail(log, 348 (internal_ticket->t_unit_res * 349 internal_ticket->t_cnt)); 350 retval = xlog_grant_log_space(log, internal_ticket); 351 } 352 353 return retval; 354} /* xfs_log_reserve */ 355 356 357/* 358 * Mount a log filesystem 359 * 360 * mp - ubiquitous xfs mount point structure 361 * log_target - buftarg of on-disk log device 362 * blk_offset - Start block # where block size is 512 bytes (BBSIZE) 363 * num_bblocks - Number of BBSIZE blocks in on-disk log 364 * 365 * Return error or zero. 366 */ 367int 368xfs_log_mount( 369 xfs_mount_t *mp, 370 xfs_buftarg_t *log_target, 371 xfs_daddr_t blk_offset, 372 int num_bblks) 373{ 374 int error; 375 376 if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) 377 xfs_notice(mp, "Mounting Filesystem"); 378 else { 379 xfs_notice(mp, 380"Mounting filesystem in no-recovery mode. Filesystem will be inconsistent."); 381 ASSERT(mp->m_flags & XFS_MOUNT_RDONLY); 382 } 383 384 mp->m_log = xlog_alloc_log(mp, log_target, blk_offset, num_bblks); 385 if (IS_ERR(mp->m_log)) { 386 error = -PTR_ERR(mp->m_log); 387 goto out; 388 } 389 390 /* 391 * Initialize the AIL now we have a log. 392 */ 393 error = xfs_trans_ail_init(mp); 394 if (error) { 395 xfs_warn(mp, "AIL initialisation failed: error %d", error); 396 goto out_free_log; 397 } 398 mp->m_log->l_ailp = mp->m_ail; 399 400 /* 401 * skip log recovery on a norecovery mount. pretend it all 402 * just worked. 403 */ 404 if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) { 405 int readonly = (mp->m_flags & XFS_MOUNT_RDONLY); 406 407 if (readonly) 408 mp->m_flags &= ~XFS_MOUNT_RDONLY; 409 410 error = xlog_recover(mp->m_log); 411 412 if (readonly) 413 mp->m_flags |= XFS_MOUNT_RDONLY; 414 if (error) { 415 xfs_warn(mp, "log mount/recovery failed: error %d", 416 error); 417 goto out_destroy_ail; 418 } 419 } 420 421 /* Normal transactions can now occur */ 422 mp->m_log->l_flags &= ~XLOG_ACTIVE_RECOVERY; 423 424 /* 425 * Now the log has been fully initialised and we know were our 426 * space grant counters are, we can initialise the permanent ticket 427 * needed for delayed logging to work. 428 */ 429 xlog_cil_init_post_recovery(mp->m_log); 430 431 return 0; 432 433out_destroy_ail: 434 xfs_trans_ail_destroy(mp); 435out_free_log: 436 xlog_dealloc_log(mp->m_log); 437out: 438 return error; 439} 440 441/* 442 * Finish the recovery of the file system. This is separate from 443 * the xfs_log_mount() call, because it depends on the code in 444 * xfs_mountfs() to read in the root and real-time bitmap inodes 445 * between calling xfs_log_mount() and here. 446 * 447 * mp - ubiquitous xfs mount point structure 448 */ 449int 450xfs_log_mount_finish(xfs_mount_t *mp) 451{ 452 int error; 453 454 if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) 455 error = xlog_recover_finish(mp->m_log); 456 else { 457 error = 0; 458 ASSERT(mp->m_flags & XFS_MOUNT_RDONLY); 459 } 460 461 return error; 462} 463 464/* 465 * Final log writes as part of unmount. 466 * 467 * Mark the filesystem clean as unmount happens. Note that during relocation 468 * this routine needs to be executed as part of source-bag while the 469 * deallocation must not be done until source-end. 470 */ 471 472/* 473 * Unmount record used to have a string "Unmount filesystem--" in the 474 * data section where the "Un" was really a magic number (XLOG_UNMOUNT_TYPE). 475 * We just write the magic number now since that particular field isn't 476 * currently architecture converted and "nUmount" is a bit foo. 477 * As far as I know, there weren't any dependencies on the old behaviour. 478 */ 479 480int 481xfs_log_unmount_write(xfs_mount_t *mp) 482{ 483 xlog_t *log = mp->m_log; 484 xlog_in_core_t *iclog; 485#ifdef DEBUG 486 xlog_in_core_t *first_iclog; 487#endif 488 xlog_ticket_t *tic = NULL; 489 xfs_lsn_t lsn; 490 int error; 491 492 /* 493 * Don't write out unmount record on read-only mounts. 494 * Or, if we are doing a forced umount (typically because of IO errors). 495 */ 496 if (mp->m_flags & XFS_MOUNT_RDONLY) 497 return 0; 498 499 error = _xfs_log_force(mp, XFS_LOG_SYNC, NULL); 500 ASSERT(error || !(XLOG_FORCED_SHUTDOWN(log))); 501 502#ifdef DEBUG 503 first_iclog = iclog = log->l_iclog; 504 do { 505 if (!(iclog->ic_state & XLOG_STATE_IOERROR)) { 506 ASSERT(iclog->ic_state & XLOG_STATE_ACTIVE); 507 ASSERT(iclog->ic_offset == 0); 508 } 509 iclog = iclog->ic_next; 510 } while (iclog != first_iclog); 511#endif 512 if (! (XLOG_FORCED_SHUTDOWN(log))) { 513 error = xfs_log_reserve(mp, 600, 1, &tic, 514 XFS_LOG, 0, XLOG_UNMOUNT_REC_TYPE); 515 if (!error) { 516 /* the data section must be 32 bit size aligned */ 517 struct { 518 __uint16_t magic; 519 __uint16_t pad1; 520 __uint32_t pad2; /* may as well make it 64 bits */ 521 } magic = { 522 .magic = XLOG_UNMOUNT_TYPE, 523 }; 524 struct xfs_log_iovec reg = { 525 .i_addr = &magic, 526 .i_len = sizeof(magic), 527 .i_type = XLOG_REG_TYPE_UNMOUNT, 528 }; 529 struct xfs_log_vec vec = { 530 .lv_niovecs = 1, 531 .lv_iovecp = ®, 532 }; 533 534 /* remove inited flag */ 535 tic->t_flags = 0; 536 error = xlog_write(log, &vec, tic, &lsn, 537 NULL, XLOG_UNMOUNT_TRANS); 538 /* 539 * At this point, we're umounting anyway, 540 * so there's no point in transitioning log state 541 * to IOERROR. Just continue... 542 */ 543 } 544 545 if (error) 546 xfs_alert(mp, "%s: unmount record failed", __func__); 547 548 549 spin_lock(&log->l_icloglock); 550 iclog = log->l_iclog; 551 atomic_inc(&iclog->ic_refcnt); 552 xlog_state_want_sync(log, iclog); 553 spin_unlock(&log->l_icloglock); 554 error = xlog_state_release_iclog(log, iclog); 555 556 spin_lock(&log->l_icloglock); 557 if (!(iclog->ic_state == XLOG_STATE_ACTIVE || 558 iclog->ic_state == XLOG_STATE_DIRTY)) { 559 if (!XLOG_FORCED_SHUTDOWN(log)) { 560 xlog_wait(&iclog->ic_force_wait, 561 &log->l_icloglock); 562 } else { 563 spin_unlock(&log->l_icloglock); 564 } 565 } else { 566 spin_unlock(&log->l_icloglock); 567 } 568 if (tic) { 569 trace_xfs_log_umount_write(log, tic); 570 xlog_ungrant_log_space(log, tic); 571 xfs_log_ticket_put(tic); 572 } 573 } else { 574 /* 575 * We're already in forced_shutdown mode, couldn't 576 * even attempt to write out the unmount transaction. 577 * 578 * Go through the motions of sync'ing and releasing 579 * the iclog, even though no I/O will actually happen, 580 * we need to wait for other log I/Os that may already 581 * be in progress. Do this as a separate section of 582 * code so we'll know if we ever get stuck here that 583 * we're in this odd situation of trying to unmount 584 * a file system that went into forced_shutdown as 585 * the result of an unmount.. 586 */ 587 spin_lock(&log->l_icloglock); 588 iclog = log->l_iclog; 589 atomic_inc(&iclog->ic_refcnt); 590 591 xlog_state_want_sync(log, iclog); 592 spin_unlock(&log->l_icloglock); 593 error = xlog_state_release_iclog(log, iclog); 594 595 spin_lock(&log->l_icloglock); 596 597 if ( ! ( iclog->ic_state == XLOG_STATE_ACTIVE 598 || iclog->ic_state == XLOG_STATE_DIRTY 599 || iclog->ic_state == XLOG_STATE_IOERROR) ) { 600 601 xlog_wait(&iclog->ic_force_wait, 602 &log->l_icloglock); 603 } else { 604 spin_unlock(&log->l_icloglock); 605 } 606 } 607 608 return error; 609} /* xfs_log_unmount_write */ 610 611/* 612 * Deallocate log structures for unmount/relocation. 613 * 614 * We need to stop the aild from running before we destroy 615 * and deallocate the log as the aild references the log. 616 */ 617void 618xfs_log_unmount(xfs_mount_t *mp) 619{ 620 xfs_trans_ail_destroy(mp); 621 xlog_dealloc_log(mp->m_log); 622} 623 624void 625xfs_log_item_init( 626 struct xfs_mount *mp, 627 struct xfs_log_item *item, 628 int type, 629 struct xfs_item_ops *ops) 630{ 631 item->li_mountp = mp; 632 item->li_ailp = mp->m_ail; 633 item->li_type = type; 634 item->li_ops = ops; 635 item->li_lv = NULL; 636 637 INIT_LIST_HEAD(&item->li_ail); 638 INIT_LIST_HEAD(&item->li_cil); 639} 640 641/* 642 * Write region vectors to log. The write happens using the space reservation 643 * of the ticket (tic). It is not a requirement that all writes for a given 644 * transaction occur with one call to xfs_log_write(). However, it is important 645 * to note that the transaction reservation code makes an assumption about the 646 * number of log headers a transaction requires that may be violated if you 647 * don't pass all the transaction vectors in one call.... 648 */ 649int 650xfs_log_write( 651 struct xfs_mount *mp, 652 struct xfs_log_iovec reg[], 653 int nentries, 654 struct xlog_ticket *tic, 655 xfs_lsn_t *start_lsn) 656{ 657 struct log *log = mp->m_log; 658 int error; 659 struct xfs_log_vec vec = { 660 .lv_niovecs = nentries, 661 .lv_iovecp = reg, 662 }; 663 664 if (XLOG_FORCED_SHUTDOWN(log)) 665 return XFS_ERROR(EIO); 666 667 error = xlog_write(log, &vec, tic, start_lsn, NULL, 0); 668 if (error) 669 xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR); 670 return error; 671} 672 673void 674xfs_log_move_tail(xfs_mount_t *mp, 675 xfs_lsn_t tail_lsn) 676{ 677 xlog_ticket_t *tic; 678 xlog_t *log = mp->m_log; 679 int need_bytes, free_bytes; 680 681 if (XLOG_FORCED_SHUTDOWN(log)) 682 return; 683 684 if (tail_lsn == 0) 685 tail_lsn = atomic64_read(&log->l_last_sync_lsn); 686 687 /* tail_lsn == 1 implies that we weren't passed a valid value. */ 688 if (tail_lsn != 1) 689 atomic64_set(&log->l_tail_lsn, tail_lsn); 690 691 if (!list_empty_careful(&log->l_writeq)) { 692#ifdef DEBUG 693 if (log->l_flags & XLOG_ACTIVE_RECOVERY) 694 panic("Recovery problem"); 695#endif 696 spin_lock(&log->l_grant_write_lock); 697 free_bytes = xlog_space_left(log, &log->l_grant_write_head); 698 list_for_each_entry(tic, &log->l_writeq, t_queue) { 699 ASSERT(tic->t_flags & XLOG_TIC_PERM_RESERV); 700 701 if (free_bytes < tic->t_unit_res && tail_lsn != 1) 702 break; 703 tail_lsn = 0; 704 free_bytes -= tic->t_unit_res; 705 trace_xfs_log_regrant_write_wake_up(log, tic); 706 wake_up(&tic->t_wait); 707 } 708 spin_unlock(&log->l_grant_write_lock); 709 } 710 711 if (!list_empty_careful(&log->l_reserveq)) { 712#ifdef DEBUG 713 if (log->l_flags & XLOG_ACTIVE_RECOVERY) 714 panic("Recovery problem"); 715#endif 716 spin_lock(&log->l_grant_reserve_lock); 717 free_bytes = xlog_space_left(log, &log->l_grant_reserve_head); 718 list_for_each_entry(tic, &log->l_reserveq, t_queue) { 719 if (tic->t_flags & XLOG_TIC_PERM_RESERV) 720 need_bytes = tic->t_unit_res*tic->t_cnt; 721 else 722 need_bytes = tic->t_unit_res; 723 if (free_bytes < need_bytes && tail_lsn != 1) 724 break; 725 tail_lsn = 0; 726 free_bytes -= need_bytes; 727 trace_xfs_log_grant_wake_up(log, tic); 728 wake_up(&tic->t_wait); 729 } 730 spin_unlock(&log->l_grant_reserve_lock); 731 } 732} 733 734/* 735 * Determine if we have a transaction that has gone to disk 736 * that needs to be covered. To begin the transition to the idle state 737 * firstly the log needs to be idle (no AIL and nothing in the iclogs). 738 * If we are then in a state where covering is needed, the caller is informed 739 * that dummy transactions are required to move the log into the idle state. 740 * 741 * Because this is called as part of the sync process, we should also indicate 742 * that dummy transactions should be issued in anything but the covered or 743 * idle states. This ensures that the log tail is accurately reflected in 744 * the log at the end of the sync, hence if a crash occurrs avoids replay 745 * of transactions where the metadata is already on disk. 746 */ 747int 748xfs_log_need_covered(xfs_mount_t *mp) 749{ 750 int needed = 0; 751 xlog_t *log = mp->m_log; 752 753 if (!xfs_fs_writable(mp)) 754 return 0; 755 756 spin_lock(&log->l_icloglock); 757 switch (log->l_covered_state) { 758 case XLOG_STATE_COVER_DONE: 759 case XLOG_STATE_COVER_DONE2: 760 case XLOG_STATE_COVER_IDLE: 761 break; 762 case XLOG_STATE_COVER_NEED: 763 case XLOG_STATE_COVER_NEED2: 764 if (!xfs_ail_min_lsn(log->l_ailp) && 765 xlog_iclogs_empty(log)) { 766 if (log->l_covered_state == XLOG_STATE_COVER_NEED) 767 log->l_covered_state = XLOG_STATE_COVER_DONE; 768 else 769 log->l_covered_state = XLOG_STATE_COVER_DONE2; 770 } 771 /* FALLTHRU */ 772 default: 773 needed = 1; 774 break; 775 } 776 spin_unlock(&log->l_icloglock); 777 return needed; 778} 779 780/****************************************************************************** 781 * 782 * local routines 783 * 784 ****************************************************************************** 785 */ 786 787/* xfs_trans_tail_ail returns 0 when there is nothing in the list. 788 * The log manager must keep track of the last LR which was committed 789 * to disk. The lsn of this LR will become the new tail_lsn whenever 790 * xfs_trans_tail_ail returns 0. If we don't do this, we run into 791 * the situation where stuff could be written into the log but nothing 792 * was ever in the AIL when asked. Eventually, we panic since the 793 * tail hits the head. 794 * 795 * We may be holding the log iclog lock upon entering this routine. 796 */ 797xfs_lsn_t 798xlog_assign_tail_lsn( 799 struct xfs_mount *mp) 800{ 801 xfs_lsn_t tail_lsn; 802 struct log *log = mp->m_log; 803 804 tail_lsn = xfs_ail_min_lsn(mp->m_ail); 805 if (!tail_lsn) 806 tail_lsn = atomic64_read(&log->l_last_sync_lsn); 807 808 atomic64_set(&log->l_tail_lsn, tail_lsn); 809 return tail_lsn; 810} 811 812/* 813 * Return the space in the log between the tail and the head. The head 814 * is passed in the cycle/bytes formal parms. In the special case where 815 * the reserve head has wrapped passed the tail, this calculation is no 816 * longer valid. In this case, just return 0 which means there is no space 817 * in the log. This works for all places where this function is called 818 * with the reserve head. Of course, if the write head were to ever 819 * wrap the tail, we should blow up. Rather than catch this case here, 820 * we depend on other ASSERTions in other parts of the code. XXXmiken 821 * 822 * This code also handles the case where the reservation head is behind 823 * the tail. The details of this case are described below, but the end 824 * result is that we return the size of the log as the amount of space left. 825 */ 826STATIC int 827xlog_space_left( 828 struct log *log, 829 atomic64_t *head) 830{ 831 int free_bytes; 832 int tail_bytes; 833 int tail_cycle; 834 int head_cycle; 835 int head_bytes; 836 837 xlog_crack_grant_head(head, &head_cycle, &head_bytes); 838 xlog_crack_atomic_lsn(&log->l_tail_lsn, &tail_cycle, &tail_bytes); 839 tail_bytes = BBTOB(tail_bytes); 840 if (tail_cycle == head_cycle && head_bytes >= tail_bytes) 841 free_bytes = log->l_logsize - (head_bytes - tail_bytes); 842 else if (tail_cycle + 1 < head_cycle) 843 return 0; 844 else if (tail_cycle < head_cycle) { 845 ASSERT(tail_cycle == (head_cycle - 1)); 846 free_bytes = tail_bytes - head_bytes; 847 } else { 848 /* 849 * The reservation head is behind the tail. 850 * In this case we just want to return the size of the 851 * log as the amount of space left. 852 */ 853 xfs_alert(log->l_mp, 854 "xlog_space_left: head behind tail\n" 855 " tail_cycle = %d, tail_bytes = %d\n" 856 " GH cycle = %d, GH bytes = %d", 857 tail_cycle, tail_bytes, head_cycle, head_bytes); 858 ASSERT(0); 859 free_bytes = log->l_logsize; 860 } 861 return free_bytes; 862} 863 864 865/* 866 * Log function which is called when an io completes. 867 * 868 * The log manager needs its own routine, in order to control what 869 * happens with the buffer after the write completes. 870 */ 871void 872xlog_iodone(xfs_buf_t *bp) 873{ 874 xlog_in_core_t *iclog = bp->b_fspriv; 875 xlog_t *l = iclog->ic_log; 876 int aborted = 0; 877 878 /* 879 * Race to shutdown the filesystem if we see an error. 880 */ 881 if (XFS_TEST_ERROR((xfs_buf_geterror(bp)), l->l_mp, 882 XFS_ERRTAG_IODONE_IOERR, XFS_RANDOM_IODONE_IOERR)) { 883 xfs_ioerror_alert("xlog_iodone", l->l_mp, bp, XFS_BUF_ADDR(bp)); 884 XFS_BUF_STALE(bp); 885 xfs_force_shutdown(l->l_mp, SHUTDOWN_LOG_IO_ERROR); 886 /* 887 * This flag will be propagated to the trans-committed 888 * callback routines to let them know that the log-commit 889 * didn't succeed. 890 */ 891 aborted = XFS_LI_ABORTED; 892 } else if (iclog->ic_state & XLOG_STATE_IOERROR) { 893 aborted = XFS_LI_ABORTED; 894 } 895 896 /* log I/O is always issued ASYNC */ 897 ASSERT(XFS_BUF_ISASYNC(bp)); 898 xlog_state_done_syncing(iclog, aborted); 899 /* 900 * do not reference the buffer (bp) here as we could race 901 * with it being freed after writing the unmount record to the 902 * log. 903 */ 904 905} /* xlog_iodone */ 906 907/* 908 * Return size of each in-core log record buffer. 909 * 910 * All machines get 8 x 32kB buffers by default, unless tuned otherwise. 911 * 912 * If the filesystem blocksize is too large, we may need to choose a 913 * larger size since the directory code currently logs entire blocks. 914 */ 915 916STATIC void 917xlog_get_iclog_buffer_size(xfs_mount_t *mp, 918 xlog_t *log) 919{ 920 int size; 921 int xhdrs; 922 923 if (mp->m_logbufs <= 0) 924 log->l_iclog_bufs = XLOG_MAX_ICLOGS; 925 else 926 log->l_iclog_bufs = mp->m_logbufs; 927 928 /* 929 * Buffer size passed in from mount system call. 930 */ 931 if (mp->m_logbsize > 0) { 932 size = log->l_iclog_size = mp->m_logbsize; 933 log->l_iclog_size_log = 0; 934 while (size != 1) { 935 log->l_iclog_size_log++; 936 size >>= 1; 937 } 938 939 if (xfs_sb_version_haslogv2(&mp->m_sb)) { 940 /* # headers = size / 32k 941 * one header holds cycles from 32k of data 942 */ 943 944 xhdrs = mp->m_logbsize / XLOG_HEADER_CYCLE_SIZE; 945 if (mp->m_logbsize % XLOG_HEADER_CYCLE_SIZE) 946 xhdrs++; 947 log->l_iclog_hsize = xhdrs << BBSHIFT; 948 log->l_iclog_heads = xhdrs; 949 } else { 950 ASSERT(mp->m_logbsize <= XLOG_BIG_RECORD_BSIZE); 951 log->l_iclog_hsize = BBSIZE; 952 log->l_iclog_heads = 1; 953 } 954 goto done; 955 } 956 957 /* All machines use 32kB buffers by default. */ 958 log->l_iclog_size = XLOG_BIG_RECORD_BSIZE; 959 log->l_iclog_size_log = XLOG_BIG_RECORD_BSHIFT; 960 961 /* the default log size is 16k or 32k which is one header sector */ 962 log->l_iclog_hsize = BBSIZE; 963 log->l_iclog_heads = 1; 964 965done: 966 /* are we being asked to make the sizes selected above visible? */ 967 if (mp->m_logbufs == 0) 968 mp->m_logbufs = log->l_iclog_bufs; 969 if (mp->m_logbsize == 0) 970 mp->m_logbsize = log->l_iclog_size; 971} /* xlog_get_iclog_buffer_size */ 972 973 974/* 975 * This routine initializes some of the log structure for a given mount point. 976 * Its primary purpose is to fill in enough, so recovery can occur. However, 977 * some other stuff may be filled in too. 978 */ 979STATIC xlog_t * 980xlog_alloc_log(xfs_mount_t *mp, 981 xfs_buftarg_t *log_target, 982 xfs_daddr_t blk_offset, 983 int num_bblks) 984{ 985 xlog_t *log; 986 xlog_rec_header_t *head; 987 xlog_in_core_t **iclogp; 988 xlog_in_core_t *iclog, *prev_iclog=NULL; 989 xfs_buf_t *bp; 990 int i; 991 int error = ENOMEM; 992 uint log2_size = 0; 993 994 log = kmem_zalloc(sizeof(xlog_t), KM_MAYFAIL); 995 if (!log) { 996 xfs_warn(mp, "Log allocation failed: No memory!"); 997 goto out; 998 } 999 1000 log->l_mp = mp; 1001 log->l_targ = log_target; 1002 log->l_logsize = BBTOB(num_bblks); 1003 log->l_logBBstart = blk_offset; 1004 log->l_logBBsize = num_bblks; 1005 log->l_covered_state = XLOG_STATE_COVER_IDLE; 1006 log->l_flags |= XLOG_ACTIVE_RECOVERY; 1007 1008 log->l_prev_block = -1; 1009 /* log->l_tail_lsn = 0x100000000LL; cycle = 1; current block = 0 */ 1010 xlog_assign_atomic_lsn(&log->l_tail_lsn, 1, 0); 1011 xlog_assign_atomic_lsn(&log->l_last_sync_lsn, 1, 0); 1012 log->l_curr_cycle = 1; /* 0 is bad since this is initial value */ 1013 xlog_assign_grant_head(&log->l_grant_reserve_head, 1, 0); 1014 xlog_assign_grant_head(&log->l_grant_write_head, 1, 0); 1015 INIT_LIST_HEAD(&log->l_reserveq); 1016 INIT_LIST_HEAD(&log->l_writeq); 1017 spin_lock_init(&log->l_grant_reserve_lock); 1018 spin_lock_init(&log->l_grant_write_lock); 1019 1020 error = EFSCORRUPTED; 1021 if (xfs_sb_version_hassector(&mp->m_sb)) { 1022 log2_size = mp->m_sb.sb_logsectlog; 1023 if (log2_size < BBSHIFT) { 1024 xfs_warn(mp, "Log sector size too small (0x%x < 0x%x)", 1025 log2_size, BBSHIFT); 1026 goto out_free_log; 1027 } 1028 1029 log2_size -= BBSHIFT; 1030 if (log2_size > mp->m_sectbb_log) { 1031 xfs_warn(mp, "Log sector size too large (0x%x > 0x%x)", 1032 log2_size, mp->m_sectbb_log); 1033 goto out_free_log; 1034 } 1035 1036 /* for larger sector sizes, must have v2 or external log */ 1037 if (log2_size && log->l_logBBstart > 0 && 1038 !xfs_sb_version_haslogv2(&mp->m_sb)) { 1039 xfs_warn(mp, 1040 "log sector size (0x%x) invalid for configuration.", 1041 log2_size); 1042 goto out_free_log; 1043 } 1044 } 1045 log->l_sectBBsize = 1 << log2_size; 1046 1047 xlog_get_iclog_buffer_size(mp, log); 1048 1049 error = ENOMEM; 1050 bp = xfs_buf_get_empty(log->l_iclog_size, mp->m_logdev_targp); 1051 if (!bp) 1052 goto out_free_log; 1053 bp->b_iodone = xlog_iodone; 1054 ASSERT(xfs_buf_islocked(bp)); 1055 log->l_xbuf = bp; 1056 1057 spin_lock_init(&log->l_icloglock); 1058 init_waitqueue_head(&log->l_flush_wait); 1059 1060 /* log record size must be multiple of BBSIZE; see xlog_rec_header_t */ 1061 ASSERT((XFS_BUF_SIZE(bp) & BBMASK) == 0); 1062 1063 iclogp = &log->l_iclog; 1064 /* 1065 * The amount of memory to allocate for the iclog structure is 1066 * rather funky due to the way the structure is defined. It is 1067 * done this way so that we can use different sizes for machines 1068 * with different amounts of memory. See the definition of 1069 * xlog_in_core_t in xfs_log_priv.h for details. 1070 */ 1071 ASSERT(log->l_iclog_size >= 4096); 1072 for (i=0; i < log->l_iclog_bufs; i++) { 1073 *iclogp = kmem_zalloc(sizeof(xlog_in_core_t), KM_MAYFAIL); 1074 if (!*iclogp) 1075 goto out_free_iclog; 1076 1077 iclog = *iclogp; 1078 iclog->ic_prev = prev_iclog; 1079 prev_iclog = iclog; 1080 1081 bp = xfs_buf_get_uncached(mp->m_logdev_targp, 1082 log->l_iclog_size, 0); 1083 if (!bp) 1084 goto out_free_iclog; 1085 1086 bp->b_iodone = xlog_iodone; 1087 iclog->ic_bp = bp; 1088 iclog->ic_data = bp->b_addr; 1089#ifdef DEBUG 1090 log->l_iclog_bak[i] = (xfs_caddr_t)&(iclog->ic_header); 1091#endif 1092 head = &iclog->ic_header; 1093 memset(head, 0, sizeof(xlog_rec_header_t)); 1094 head->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM); 1095 head->h_version = cpu_to_be32( 1096 xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1); 1097 head->h_size = cpu_to_be32(log->l_iclog_size); 1098 /* new fields */ 1099 head->h_fmt = cpu_to_be32(XLOG_FMT); 1100 memcpy(&head->h_fs_uuid, &mp->m_sb.sb_uuid, sizeof(uuid_t)); 1101 1102 iclog->ic_size = XFS_BUF_SIZE(bp) - log->l_iclog_hsize; 1103 iclog->ic_state = XLOG_STATE_ACTIVE; 1104 iclog->ic_log = log; 1105 atomic_set(&iclog->ic_refcnt, 0); 1106 spin_lock_init(&iclog->ic_callback_lock); 1107 iclog->ic_callback_tail = &(iclog->ic_callback); 1108 iclog->ic_datap = (char *)iclog->ic_data + log->l_iclog_hsize; 1109 1110 ASSERT(xfs_buf_islocked(iclog->ic_bp)); 1111 init_waitqueue_head(&iclog->ic_force_wait); 1112 init_waitqueue_head(&iclog->ic_write_wait); 1113 1114 iclogp = &iclog->ic_next; 1115 } 1116 *iclogp = log->l_iclog; /* complete ring */ 1117 log->l_iclog->ic_prev = prev_iclog; /* re-write 1st prev ptr */ 1118 1119 error = xlog_cil_init(log); 1120 if (error) 1121 goto out_free_iclog; 1122 return log; 1123 1124out_free_iclog: 1125 for (iclog = log->l_iclog; iclog; iclog = prev_iclog) { 1126 prev_iclog = iclog->ic_next; 1127 if (iclog->ic_bp) 1128 xfs_buf_free(iclog->ic_bp); 1129 kmem_free(iclog); 1130 } 1131 spinlock_destroy(&log->l_icloglock); 1132 xfs_buf_free(log->l_xbuf); 1133out_free_log: 1134 kmem_free(log); 1135out: 1136 return ERR_PTR(-error); 1137} /* xlog_alloc_log */ 1138 1139 1140/* 1141 * Write out the commit record of a transaction associated with the given 1142 * ticket. Return the lsn of the commit record. 1143 */ 1144STATIC int 1145xlog_commit_record( 1146 struct log *log, 1147 struct xlog_ticket *ticket, 1148 struct xlog_in_core **iclog, 1149 xfs_lsn_t *commitlsnp) 1150{ 1151 struct xfs_mount *mp = log->l_mp; 1152 int error; 1153 struct xfs_log_iovec reg = { 1154 .i_addr = NULL, 1155 .i_len = 0, 1156 .i_type = XLOG_REG_TYPE_COMMIT, 1157 }; 1158 struct xfs_log_vec vec = { 1159 .lv_niovecs = 1, 1160 .lv_iovecp = ®, 1161 }; 1162 1163 ASSERT_ALWAYS(iclog); 1164 error = xlog_write(log, &vec, ticket, commitlsnp, iclog, 1165 XLOG_COMMIT_TRANS); 1166 if (error) 1167 xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR); 1168 return error; 1169} 1170 1171/* 1172 * Push on the buffer cache code if we ever use more than 75% of the on-disk 1173 * log space. This code pushes on the lsn which would supposedly free up 1174 * the 25% which we want to leave free. We may need to adopt a policy which 1175 * pushes on an lsn which is further along in the log once we reach the high 1176 * water mark. In this manner, we would be creating a low water mark. 1177 */ 1178STATIC void 1179xlog_grant_push_ail( 1180 struct log *log, 1181 int need_bytes) 1182{ 1183 xfs_lsn_t threshold_lsn = 0; 1184 xfs_lsn_t last_sync_lsn; 1185 int free_blocks; 1186 int free_bytes; 1187 int threshold_block; 1188 int threshold_cycle; 1189 int free_threshold; 1190 1191 ASSERT(BTOBB(need_bytes) < log->l_logBBsize); 1192 1193 free_bytes = xlog_space_left(log, &log->l_grant_reserve_head); 1194 free_blocks = BTOBBT(free_bytes); 1195 1196 /* 1197 * Set the threshold for the minimum number of free blocks in the 1198 * log to the maximum of what the caller needs, one quarter of the 1199 * log, and 256 blocks. 1200 */ 1201 free_threshold = BTOBB(need_bytes); 1202 free_threshold = MAX(free_threshold, (log->l_logBBsize >> 2)); 1203 free_threshold = MAX(free_threshold, 256); 1204 if (free_blocks >= free_threshold) 1205 return; 1206 1207 xlog_crack_atomic_lsn(&log->l_tail_lsn, &threshold_cycle, 1208 &threshold_block); 1209 threshold_block += free_threshold; 1210 if (threshold_block >= log->l_logBBsize) { 1211 threshold_block -= log->l_logBBsize; 1212 threshold_cycle += 1; 1213 } 1214 threshold_lsn = xlog_assign_lsn(threshold_cycle, 1215 threshold_block); 1216 /* 1217 * Don't pass in an lsn greater than the lsn of the last 1218 * log record known to be on disk. Use a snapshot of the last sync lsn 1219 * so that it doesn't change between the compare and the set. 1220 */ 1221 last_sync_lsn = atomic64_read(&log->l_last_sync_lsn); 1222 if (XFS_LSN_CMP(threshold_lsn, last_sync_lsn) > 0) 1223 threshold_lsn = last_sync_lsn; 1224 1225 /* 1226 * Get the transaction layer to kick the dirty buffers out to 1227 * disk asynchronously. No point in trying to do this if 1228 * the filesystem is shutting down. 1229 */ 1230 if (!XLOG_FORCED_SHUTDOWN(log)) 1231 xfs_ail_push(log->l_ailp, threshold_lsn); 1232} 1233 1234/* 1235 * The bdstrat callback function for log bufs. This gives us a central 1236 * place to trap bufs in case we get hit by a log I/O error and need to 1237 * shutdown. Actually, in practice, even when we didn't get a log error, 1238 * we transition the iclogs to IOERROR state *after* flushing all existing 1239 * iclogs to disk. This is because we don't want anymore new transactions to be 1240 * started or completed afterwards. 1241 */ 1242STATIC int 1243xlog_bdstrat( 1244 struct xfs_buf *bp) 1245{ 1246 struct xlog_in_core *iclog = bp->b_fspriv; 1247 1248 if (iclog->ic_state & XLOG_STATE_IOERROR) { 1249 xfs_buf_ioerror(bp, EIO); 1250 XFS_BUF_STALE(bp); 1251 xfs_buf_ioend(bp, 0); 1252 /* 1253 * It would seem logical to return EIO here, but we rely on 1254 * the log state machine to propagate I/O errors instead of 1255 * doing it here. 1256 */ 1257 return 0; 1258 } 1259 1260 xfs_buf_iorequest(bp); 1261 return 0; 1262} 1263 1264/* 1265 * Flush out the in-core log (iclog) to the on-disk log in an asynchronous 1266 * fashion. Previously, we should have moved the current iclog 1267 * ptr in the log to point to the next available iclog. This allows further 1268 * write to continue while this code syncs out an iclog ready to go. 1269 * Before an in-core log can be written out, the data section must be scanned 1270 * to save away the 1st word of each BBSIZE block into the header. We replace 1271 * it with the current cycle count. Each BBSIZE block is tagged with the 1272 * cycle count because there in an implicit assumption that drives will 1273 * guarantee that entire 512 byte blocks get written at once. In other words, 1274 * we can't have part of a 512 byte block written and part not written. By 1275 * tagging each block, we will know which blocks are valid when recovering 1276 * after an unclean shutdown. 1277 * 1278 * This routine is single threaded on the iclog. No other thread can be in 1279 * this routine with the same iclog. Changing contents of iclog can there- 1280 * fore be done without grabbing the state machine lock. Updating the global 1281 * log will require grabbing the lock though. 1282 * 1283 * The entire log manager uses a logical block numbering scheme. Only 1284 * log_sync (and then only bwrite()) know about the fact that the log may 1285 * not start with block zero on a given device. The log block start offset 1286 * is added immediately before calling bwrite(). 1287 */ 1288 1289STATIC int 1290xlog_sync(xlog_t *log, 1291 xlog_in_core_t *iclog) 1292{ 1293 xfs_caddr_t dptr; /* pointer to byte sized element */ 1294 xfs_buf_t *bp; 1295 int i; 1296 uint count; /* byte count of bwrite */ 1297 uint count_init; /* initial count before roundup */ 1298 int roundoff; /* roundoff to BB or stripe */ 1299 int split = 0; /* split write into two regions */ 1300 int error; 1301 int v2 = xfs_sb_version_haslogv2(&log->l_mp->m_sb); 1302 1303 XFS_STATS_INC(xs_log_writes); 1304 ASSERT(atomic_read(&iclog->ic_refcnt) == 0); 1305 1306 /* Add for LR header */ 1307 count_init = log->l_iclog_hsize + iclog->ic_offset; 1308 1309 /* Round out the log write size */ 1310 if (v2 && log->l_mp->m_sb.sb_logsunit > 1) { 1311 /* we have a v2 stripe unit to use */ 1312 count = XLOG_LSUNITTOB(log, XLOG_BTOLSUNIT(log, count_init)); 1313 } else { 1314 count = BBTOB(BTOBB(count_init)); 1315 } 1316 roundoff = count - count_init; 1317 ASSERT(roundoff >= 0); 1318 ASSERT((v2 && log->l_mp->m_sb.sb_logsunit > 1 && 1319 roundoff < log->l_mp->m_sb.sb_logsunit) 1320 || 1321 (log->l_mp->m_sb.sb_logsunit <= 1 && 1322 roundoff < BBTOB(1))); 1323 1324 /* move grant heads by roundoff in sync */ 1325 xlog_grant_add_space(log, &log->l_grant_reserve_head, roundoff); 1326 xlog_grant_add_space(log, &log->l_grant_write_head, roundoff); 1327 1328 /* put cycle number in every block */ 1329 xlog_pack_data(log, iclog, roundoff); 1330 1331 /* real byte length */ 1332 if (v2) { 1333 iclog->ic_header.h_len = 1334 cpu_to_be32(iclog->ic_offset + roundoff); 1335 } else { 1336 iclog->ic_header.h_len = 1337 cpu_to_be32(iclog->ic_offset); 1338 } 1339 1340 bp = iclog->ic_bp; 1341 XFS_BUF_SET_ADDR(bp, BLOCK_LSN(be64_to_cpu(iclog->ic_header.h_lsn))); 1342 1343 XFS_STATS_ADD(xs_log_blocks, BTOBB(count)); 1344 1345 /* Do we need to split this write into 2 parts? */ 1346 if (XFS_BUF_ADDR(bp) + BTOBB(count) > log->l_logBBsize) { 1347 split = count - (BBTOB(log->l_logBBsize - XFS_BUF_ADDR(bp))); 1348 count = BBTOB(log->l_logBBsize - XFS_BUF_ADDR(bp)); 1349 iclog->ic_bwritecnt = 2; /* split into 2 writes */ 1350 } else { 1351 iclog->ic_bwritecnt = 1; 1352 } 1353 XFS_BUF_SET_COUNT(bp, count); 1354 bp->b_fspriv = iclog; 1355 XFS_BUF_ZEROFLAGS(bp); 1356 XFS_BUF_ASYNC(bp); 1357 bp->b_flags |= XBF_SYNCIO; 1358 1359 if (log->l_mp->m_flags & XFS_MOUNT_BARRIER) { 1360 bp->b_flags |= XBF_FUA; 1361 1362 /* 1363 * Flush the data device before flushing the log to make 1364 * sure all meta data written back from the AIL actually made 1365 * it to disk before stamping the new log tail LSN into the 1366 * log buffer. For an external log we need to issue the 1367 * flush explicitly, and unfortunately synchronously here; 1368 * for an internal log we can simply use the block layer 1369 * state machine for preflushes. 1370 */ 1371 if (log->l_mp->m_logdev_targp != log->l_mp->m_ddev_targp) 1372 xfs_blkdev_issue_flush(log->l_mp->m_ddev_targp); 1373 else 1374 bp->b_flags |= XBF_FLUSH; 1375 } 1376 1377 ASSERT(XFS_BUF_ADDR(bp) <= log->l_logBBsize-1); 1378 ASSERT(XFS_BUF_ADDR(bp) + BTOBB(count) <= log->l_logBBsize); 1379 1380 xlog_verify_iclog(log, iclog, count, B_TRUE); 1381 1382 /* account for log which doesn't start at block #0 */ 1383 XFS_BUF_SET_ADDR(bp, XFS_BUF_ADDR(bp) + log->l_logBBstart); 1384 /* 1385 * Don't call xfs_bwrite here. We do log-syncs even when the filesystem 1386 * is shutting down. 1387 */ 1388 XFS_BUF_WRITE(bp); 1389 1390 if ((error = xlog_bdstrat(bp))) { 1391 xfs_ioerror_alert("xlog_sync", log->l_mp, bp, 1392 XFS_BUF_ADDR(bp)); 1393 return error; 1394 } 1395 if (split) { 1396 bp = iclog->ic_log->l_xbuf; 1397 XFS_BUF_SET_ADDR(bp, 0); /* logical 0 */ 1398 xfs_buf_associate_memory(bp, 1399 (char *)&iclog->ic_header + count, split); 1400 bp->b_fspriv = iclog; 1401 XFS_BUF_ZEROFLAGS(bp); 1402 XFS_BUF_ASYNC(bp); 1403 bp->b_flags |= XBF_SYNCIO; 1404 if (log->l_mp->m_flags & XFS_MOUNT_BARRIER) 1405 bp->b_flags |= XBF_FUA; 1406 dptr = bp->b_addr; 1407 /* 1408 * Bump the cycle numbers at the start of each block 1409 * since this part of the buffer is at the start of 1410 * a new cycle. Watch out for the header magic number 1411 * case, though. 1412 */ 1413 for (i = 0; i < split; i += BBSIZE) { 1414 be32_add_cpu((__be32 *)dptr, 1); 1415 if (be32_to_cpu(*(__be32 *)dptr) == XLOG_HEADER_MAGIC_NUM) 1416 be32_add_cpu((__be32 *)dptr, 1); 1417 dptr += BBSIZE; 1418 } 1419 1420 ASSERT(XFS_BUF_ADDR(bp) <= log->l_logBBsize-1); 1421 ASSERT(XFS_BUF_ADDR(bp) + BTOBB(count) <= log->l_logBBsize); 1422 1423 /* account for internal log which doesn't start at block #0 */ 1424 XFS_BUF_SET_ADDR(bp, XFS_BUF_ADDR(bp) + log->l_logBBstart); 1425 XFS_BUF_WRITE(bp); 1426 if ((error = xlog_bdstrat(bp))) { 1427 xfs_ioerror_alert("xlog_sync (split)", log->l_mp, 1428 bp, XFS_BUF_ADDR(bp)); 1429 return error; 1430 } 1431 } 1432 return 0; 1433} /* xlog_sync */ 1434 1435 1436/* 1437 * Deallocate a log structure 1438 */ 1439STATIC void 1440xlog_dealloc_log(xlog_t *log) 1441{ 1442 xlog_in_core_t *iclog, *next_iclog; 1443 int i; 1444 1445 xlog_cil_destroy(log); 1446 1447 /* 1448 * always need to ensure that the extra buffer does not point to memory 1449 * owned by another log buffer before we free it. 1450 */ 1451 xfs_buf_set_empty(log->l_xbuf, log->l_iclog_size); 1452 xfs_buf_free(log->l_xbuf); 1453 1454 iclog = log->l_iclog; 1455 for (i=0; i<log->l_iclog_bufs; i++) { 1456 xfs_buf_free(iclog->ic_bp); 1457 next_iclog = iclog->ic_next; 1458 kmem_free(iclog); 1459 iclog = next_iclog; 1460 } 1461 spinlock_destroy(&log->l_icloglock); 1462 1463 log->l_mp->m_log = NULL; 1464 kmem_free(log); 1465} /* xlog_dealloc_log */ 1466 1467/* 1468 * Update counters atomically now that memcpy is done. 1469 */ 1470/* ARGSUSED */ 1471static inline void 1472xlog_state_finish_copy(xlog_t *log, 1473 xlog_in_core_t *iclog, 1474 int record_cnt, 1475 int copy_bytes) 1476{ 1477 spin_lock(&log->l_icloglock); 1478 1479 be32_add_cpu(&iclog->ic_header.h_num_logops, record_cnt); 1480 iclog->ic_offset += copy_bytes; 1481 1482 spin_unlock(&log->l_icloglock); 1483} /* xlog_state_finish_copy */ 1484 1485 1486 1487 1488/* 1489 * print out info relating to regions written which consume 1490 * the reservation 1491 */ 1492void 1493xlog_print_tic_res( 1494 struct xfs_mount *mp, 1495 struct xlog_ticket *ticket) 1496{ 1497 uint i; 1498 uint ophdr_spc = ticket->t_res_num_ophdrs * (uint)sizeof(xlog_op_header_t); 1499 1500 /* match with XLOG_REG_TYPE_* in xfs_log.h */ 1501 static char *res_type_str[XLOG_REG_TYPE_MAX] = { 1502 "bformat", 1503 "bchunk", 1504 "efi_format", 1505 "efd_format", 1506 "iformat", 1507 "icore", 1508 "iext", 1509 "ibroot", 1510 "ilocal", 1511 "iattr_ext", 1512 "iattr_broot", 1513 "iattr_local", 1514 "qformat", 1515 "dquot", 1516 "quotaoff", 1517 "LR header", 1518 "unmount", 1519 "commit", 1520 "trans header" 1521 }; 1522 static char *trans_type_str[XFS_TRANS_TYPE_MAX] = { 1523 "SETATTR_NOT_SIZE", 1524 "SETATTR_SIZE", 1525 "INACTIVE", 1526 "CREATE", 1527 "CREATE_TRUNC", 1528 "TRUNCATE_FILE", 1529 "REMOVE", 1530 "LINK", 1531 "RENAME", 1532 "MKDIR", 1533 "RMDIR", 1534 "SYMLINK", 1535 "SET_DMATTRS", 1536 "GROWFS", 1537 "STRAT_WRITE", 1538 "DIOSTRAT", 1539 "WRITE_SYNC", 1540 "WRITEID", 1541 "ADDAFORK", 1542 "ATTRINVAL", 1543 "ATRUNCATE", 1544 "ATTR_SET", 1545 "ATTR_RM", 1546 "ATTR_FLAG", 1547 "CLEAR_AGI_BUCKET", 1548 "QM_SBCHANGE", 1549 "DUMMY1", 1550 "DUMMY2", 1551 "QM_QUOTAOFF", 1552 "QM_DQALLOC", 1553 "QM_SETQLIM", 1554 "QM_DQCLUSTER", 1555 "QM_QINOCREATE", 1556 "QM_QUOTAOFF_END", 1557 "SB_UNIT", 1558 "FSYNC_TS", 1559 "GROWFSRT_ALLOC", 1560 "GROWFSRT_ZERO", 1561 "GROWFSRT_FREE", 1562 "SWAPEXT" 1563 }; 1564 1565 xfs_warn(mp, 1566 "xfs_log_write: reservation summary:\n" 1567 " trans type = %s (%u)\n" 1568 " unit res = %d bytes\n" 1569 " current res = %d bytes\n" 1570 " total reg = %u bytes (o/flow = %u bytes)\n" 1571 " ophdrs = %u (ophdr space = %u bytes)\n" 1572 " ophdr + reg = %u bytes\n" 1573 " num regions = %u\n", 1574 ((ticket->t_trans_type <= 0 || 1575 ticket->t_trans_type > XFS_TRANS_TYPE_MAX) ? 1576 "bad-trans-type" : trans_type_str[ticket->t_trans_type-1]), 1577 ticket->t_trans_type, 1578 ticket->t_unit_res, 1579 ticket->t_curr_res, 1580 ticket->t_res_arr_sum, ticket->t_res_o_flow, 1581 ticket->t_res_num_ophdrs, ophdr_spc, 1582 ticket->t_res_arr_sum + 1583 ticket->t_res_o_flow + ophdr_spc, 1584 ticket->t_res_num); 1585 1586 for (i = 0; i < ticket->t_res_num; i++) { 1587 uint r_type = ticket->t_res_arr[i].r_type; 1588 xfs_warn(mp, "region[%u]: %s - %u bytes\n", i, 1589 ((r_type <= 0 || r_type > XLOG_REG_TYPE_MAX) ? 1590 "bad-rtype" : res_type_str[r_type-1]), 1591 ticket->t_res_arr[i].r_len); 1592 } 1593 1594 xfs_alert_tag(mp, XFS_PTAG_LOGRES, 1595 "xfs_log_write: reservation ran out. Need to up reservation"); 1596 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); 1597} 1598 1599/* 1600 * Calculate the potential space needed by the log vector. Each region gets 1601 * its own xlog_op_header_t and may need to be double word aligned. 1602 */ 1603static int 1604xlog_write_calc_vec_length( 1605 struct xlog_ticket *ticket, 1606 struct xfs_log_vec *log_vector) 1607{ 1608 struct xfs_log_vec *lv; 1609 int headers = 0; 1610 int len = 0; 1611 int i; 1612 1613 /* acct for start rec of xact */ 1614 if (ticket->t_flags & XLOG_TIC_INITED) 1615 headers++; 1616 1617 for (lv = log_vector; lv; lv = lv->lv_next) { 1618 headers += lv->lv_niovecs; 1619 1620 for (i = 0; i < lv->lv_niovecs; i++) { 1621 struct xfs_log_iovec *vecp = &lv->lv_iovecp[i]; 1622 1623 len += vecp->i_len; 1624 xlog_tic_add_region(ticket, vecp->i_len, vecp->i_type); 1625 } 1626 } 1627 1628 ticket->t_res_num_ophdrs += headers; 1629 len += headers * sizeof(struct xlog_op_header); 1630 1631 return len; 1632} 1633 1634/* 1635 * If first write for transaction, insert start record We can't be trying to 1636 * commit if we are inited. We can't have any "partial_copy" if we are inited. 1637 */ 1638static int 1639xlog_write_start_rec( 1640 struct xlog_op_header *ophdr, 1641 struct xlog_ticket *ticket) 1642{ 1643 if (!(ticket->t_flags & XLOG_TIC_INITED)) 1644 return 0; 1645 1646 ophdr->oh_tid = cpu_to_be32(ticket->t_tid); 1647 ophdr->oh_clientid = ticket->t_clientid; 1648 ophdr->oh_len = 0; 1649 ophdr->oh_flags = XLOG_START_TRANS; 1650 ophdr->oh_res2 = 0; 1651 1652 ticket->t_flags &= ~XLOG_TIC_INITED; 1653 1654 return sizeof(struct xlog_op_header); 1655} 1656 1657static xlog_op_header_t * 1658xlog_write_setup_ophdr( 1659 struct log *log, 1660 struct xlog_op_header *ophdr, 1661 struct xlog_ticket *ticket, 1662 uint flags) 1663{ 1664 ophdr->oh_tid = cpu_to_be32(ticket->t_tid); 1665 ophdr->oh_clientid = ticket->t_clientid; 1666 ophdr->oh_res2 = 0; 1667 1668 /* are we copying a commit or unmount record? */ 1669 ophdr->oh_flags = flags; 1670 1671 /* 1672 * We've seen logs corrupted with bad transaction client ids. This 1673 * makes sure that XFS doesn't generate them on. Turn this into an EIO 1674 * and shut down the filesystem. 1675 */ 1676 switch (ophdr->oh_clientid) { 1677 case XFS_TRANSACTION: 1678 case XFS_VOLUME: 1679 case XFS_LOG: 1680 break; 1681 default: 1682 xfs_warn(log->l_mp, 1683 "Bad XFS transaction clientid 0x%x in ticket 0x%p", 1684 ophdr->oh_clientid, ticket); 1685 return NULL; 1686 } 1687 1688 return ophdr; 1689} 1690 1691/* 1692 * Set up the parameters of the region copy into the log. This has 1693 * to handle region write split across multiple log buffers - this 1694 * state is kept external to this function so that this code can 1695 * can be written in an obvious, self documenting manner. 1696 */ 1697static int 1698xlog_write_setup_copy( 1699 struct xlog_ticket *ticket, 1700 struct xlog_op_header *ophdr, 1701 int space_available, 1702 int space_required, 1703 int *copy_off, 1704 int *copy_len, 1705 int *last_was_partial_copy, 1706 int *bytes_consumed) 1707{ 1708 int still_to_copy; 1709 1710 still_to_copy = space_required - *bytes_consumed; 1711 *copy_off = *bytes_consumed; 1712 1713 if (still_to_copy <= space_available) { 1714 /* write of region completes here */ 1715 *copy_len = still_to_copy; 1716 ophdr->oh_len = cpu_to_be32(*copy_len); 1717 if (*last_was_partial_copy) 1718 ophdr->oh_flags |= (XLOG_END_TRANS|XLOG_WAS_CONT_TRANS); 1719 *last_was_partial_copy = 0; 1720 *bytes_consumed = 0; 1721 return 0; 1722 } 1723 1724 /* partial write of region, needs extra log op header reservation */ 1725 *copy_len = space_available; 1726 ophdr->oh_len = cpu_to_be32(*copy_len); 1727 ophdr->oh_flags |= XLOG_CONTINUE_TRANS; 1728 if (*last_was_partial_copy) 1729 ophdr->oh_flags |= XLOG_WAS_CONT_TRANS; 1730 *bytes_consumed += *copy_len; 1731 (*last_was_partial_copy)++; 1732 1733 /* account for new log op header */ 1734 ticket->t_curr_res -= sizeof(struct xlog_op_header); 1735 ticket->t_res_num_ophdrs++; 1736 1737 return sizeof(struct xlog_op_header); 1738} 1739 1740static int 1741xlog_write_copy_finish( 1742 struct log *log, 1743 struct xlog_in_core *iclog, 1744 uint flags, 1745 int *record_cnt, 1746 int *data_cnt, 1747 int *partial_copy, 1748 int *partial_copy_len, 1749 int log_offset, 1750 struct xlog_in_core **commit_iclog) 1751{ 1752 if (*partial_copy) { 1753 /* 1754 * This iclog has already been marked WANT_SYNC by 1755 * xlog_state_get_iclog_space. 1756 */ 1757 xlog_state_finish_copy(log, iclog, *record_cnt, *data_cnt); 1758 *record_cnt = 0; 1759 *data_cnt = 0; 1760 return xlog_state_release_iclog(log, iclog); 1761 } 1762 1763 *partial_copy = 0; 1764 *partial_copy_len = 0; 1765 1766 if (iclog->ic_size - log_offset <= sizeof(xlog_op_header_t)) { 1767 /* no more space in this iclog - push it. */ 1768 xlog_state_finish_copy(log, iclog, *record_cnt, *data_cnt); 1769 *record_cnt = 0; 1770 *data_cnt = 0; 1771 1772 spin_lock(&log->l_icloglock); 1773 xlog_state_want_sync(log, iclog); 1774 spin_unlock(&log->l_icloglock); 1775 1776 if (!commit_iclog) 1777 return xlog_state_release_iclog(log, iclog); 1778 ASSERT(flags & XLOG_COMMIT_TRANS); 1779 *commit_iclog = iclog; 1780 } 1781 1782 return 0; 1783} 1784 1785/* 1786 * Write some region out to in-core log 1787 * 1788 * This will be called when writing externally provided regions or when 1789 * writing out a commit record for a given transaction. 1790 * 1791 * General algorithm: 1792 * 1. Find total length of this write. This may include adding to the 1793 * lengths passed in. 1794 * 2. Check whether we violate the tickets reservation. 1795 * 3. While writing to this iclog 1796 * A. Reserve as much space in this iclog as can get 1797 * B. If this is first write, save away start lsn 1798 * C. While writing this region: 1799 * 1. If first write of transaction, write start record 1800 * 2. Write log operation header (header per region) 1801 * 3. Find out if we can fit entire region into this iclog 1802 * 4. Potentially, verify destination memcpy ptr 1803 * 5. Memcpy (partial) region 1804 * 6. If partial copy, release iclog; otherwise, continue 1805 * copying more regions into cu…
Large files files are truncated, but you can click here to view the full file