1 /* 2 * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc. 3 * Copyright (c) 2008 Dave Chinner 4 * All Rights Reserved. 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License as 8 * published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it would be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 18 */ 19 #include "xfs.h" 20 #include "xfs_fs.h" 21 #include "xfs_format.h" 22 #include "xfs_log_format.h" 23 #include "xfs_trans_resv.h" 24 #include "xfs_mount.h" 25 #include "xfs_trans.h" 26 #include "xfs_trans_priv.h" 27 #include "xfs_trace.h" 28 #include "xfs_error.h" 29 #include "xfs_log.h" 30 31 #ifdef DEBUG 32 /* 33 * Check that the list is sorted as it should be. 34 */ 35 STATIC void 36 xfs_ail_check( 37 struct xfs_ail *ailp, 38 xfs_log_item_t *lip) 39 { 40 xfs_log_item_t *prev_lip; 41 42 if (list_empty(&ailp->xa_ail)) 43 return; 44 45 /* 46 * Check the next and previous entries are valid. 47 */ 48 ASSERT((lip->li_flags & XFS_LI_IN_AIL) != 0); 49 prev_lip = list_entry(lip->li_ail.prev, xfs_log_item_t, li_ail); 50 if (&prev_lip->li_ail != &ailp->xa_ail) 51 ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) <= 0); 52 53 prev_lip = list_entry(lip->li_ail.next, xfs_log_item_t, li_ail); 54 if (&prev_lip->li_ail != &ailp->xa_ail) 55 ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) >= 0); 56 57 58 } 59 #else /* !DEBUG */ 60 #define xfs_ail_check(a,l) 61 #endif /* DEBUG */ 62 63 /* 64 * Return a pointer to the last item in the AIL. If the AIL is empty, then 65 * return NULL. 66 */ 67 static xfs_log_item_t * 68 xfs_ail_max( 69 struct xfs_ail *ailp) 70 { 71 if (list_empty(&ailp->xa_ail)) 72 return NULL; 73 74 return list_entry(ailp->xa_ail.prev, xfs_log_item_t, li_ail); 75 } 76 77 /* 78 * Return a pointer to the item which follows the given item in the AIL. If 79 * the given item is the last item in the list, then return NULL. 80 */ 81 static xfs_log_item_t * 82 xfs_ail_next( 83 struct xfs_ail *ailp, 84 xfs_log_item_t *lip) 85 { 86 if (lip->li_ail.next == &ailp->xa_ail) 87 return NULL; 88 89 return list_first_entry(&lip->li_ail, xfs_log_item_t, li_ail); 90 } 91 92 /* 93 * This is called by the log manager code to determine the LSN of the tail of 94 * the log. This is exactly the LSN of the first item in the AIL. If the AIL 95 * is empty, then this function returns 0. 96 * 97 * We need the AIL lock in order to get a coherent read of the lsn of the last 98 * item in the AIL. 99 */ 100 xfs_lsn_t 101 xfs_ail_min_lsn( 102 struct xfs_ail *ailp) 103 { 104 xfs_lsn_t lsn = 0; 105 xfs_log_item_t *lip; 106 107 spin_lock(&ailp->xa_lock); 108 lip = xfs_ail_min(ailp); 109 if (lip) 110 lsn = lip->li_lsn; 111 spin_unlock(&ailp->xa_lock); 112 113 return lsn; 114 } 115 116 /* 117 * Return the maximum lsn held in the AIL, or zero if the AIL is empty. 118 */ 119 static xfs_lsn_t 120 xfs_ail_max_lsn( 121 struct xfs_ail *ailp) 122 { 123 xfs_lsn_t lsn = 0; 124 xfs_log_item_t *lip; 125 126 spin_lock(&ailp->xa_lock); 127 lip = xfs_ail_max(ailp); 128 if (lip) 129 lsn = lip->li_lsn; 130 spin_unlock(&ailp->xa_lock); 131 132 return lsn; 133 } 134 135 /* 136 * The cursor keeps track of where our current traversal is up to by tracking 137 * the next item in the list for us. However, for this to be safe, removing an 138 * object from the AIL needs to invalidate any cursor that points to it. hence 139 * the traversal cursor needs to be linked to the struct xfs_ail so that 140 * deletion can search all the active cursors for invalidation. 141 */ 142 STATIC void 143 xfs_trans_ail_cursor_init( 144 struct xfs_ail *ailp, 145 struct xfs_ail_cursor *cur) 146 { 147 cur->item = NULL; 148 list_add_tail(&cur->list, &ailp->xa_cursors); 149 } 150 151 /* 152 * Get the next item in the traversal and advance the cursor. If the cursor 153 * was invalidated (indicated by a lip of 1), restart the traversal. 154 */ 155 struct xfs_log_item * 156 xfs_trans_ail_cursor_next( 157 struct xfs_ail *ailp, 158 struct xfs_ail_cursor *cur) 159 { 160 struct xfs_log_item *lip = cur->item; 161 162 if ((uintptr_t)lip & 1) 163 lip = xfs_ail_min(ailp); 164 if (lip) 165 cur->item = xfs_ail_next(ailp, lip); 166 return lip; 167 } 168 169 /* 170 * When the traversal is complete, we need to remove the cursor from the list 171 * of traversing cursors. 172 */ 173 void 174 xfs_trans_ail_cursor_done( 175 struct xfs_ail_cursor *cur) 176 { 177 cur->item = NULL; 178 list_del_init(&cur->list); 179 } 180 181 /* 182 * Invalidate any cursor that is pointing to this item. This is called when an 183 * item is removed from the AIL. Any cursor pointing to this object is now 184 * invalid and the traversal needs to be terminated so it doesn't reference a 185 * freed object. We set the low bit of the cursor item pointer so we can 186 * distinguish between an invalidation and the end of the list when getting the 187 * next item from the cursor. 188 */ 189 STATIC void 190 xfs_trans_ail_cursor_clear( 191 struct xfs_ail *ailp, 192 struct xfs_log_item *lip) 193 { 194 struct xfs_ail_cursor *cur; 195 196 list_for_each_entry(cur, &ailp->xa_cursors, list) { 197 if (cur->item == lip) 198 cur->item = (struct xfs_log_item *) 199 ((uintptr_t)cur->item | 1); 200 } 201 } 202 203 /* 204 * Find the first item in the AIL with the given @lsn by searching in ascending 205 * LSN order and initialise the cursor to point to the next item for a 206 * ascending traversal. Pass a @lsn of zero to initialise the cursor to the 207 * first item in the AIL. Returns NULL if the list is empty. 208 */ 209 xfs_log_item_t * 210 xfs_trans_ail_cursor_first( 211 struct xfs_ail *ailp, 212 struct xfs_ail_cursor *cur, 213 xfs_lsn_t lsn) 214 { 215 xfs_log_item_t *lip; 216 217 xfs_trans_ail_cursor_init(ailp, cur); 218 219 if (lsn == 0) { 220 lip = xfs_ail_min(ailp); 221 goto out; 222 } 223 224 list_for_each_entry(lip, &ailp->xa_ail, li_ail) { 225 if (XFS_LSN_CMP(lip->li_lsn, lsn) >= 0) 226 goto out; 227 } 228 return NULL; 229 230 out: 231 if (lip) 232 cur->item = xfs_ail_next(ailp, lip); 233 return lip; 234 } 235 236 static struct xfs_log_item * 237 __xfs_trans_ail_cursor_last( 238 struct xfs_ail *ailp, 239 xfs_lsn_t lsn) 240 { 241 xfs_log_item_t *lip; 242 243 list_for_each_entry_reverse(lip, &ailp->xa_ail, li_ail) { 244 if (XFS_LSN_CMP(lip->li_lsn, lsn) <= 0) 245 return lip; 246 } 247 return NULL; 248 } 249 250 /* 251 * Find the last item in the AIL with the given @lsn by searching in descending 252 * LSN order and initialise the cursor to point to that item. If there is no 253 * item with the value of @lsn, then it sets the cursor to the last item with an 254 * LSN lower than @lsn. Returns NULL if the list is empty. 255 */ 256 struct xfs_log_item * 257 xfs_trans_ail_cursor_last( 258 struct xfs_ail *ailp, 259 struct xfs_ail_cursor *cur, 260 xfs_lsn_t lsn) 261 { 262 xfs_trans_ail_cursor_init(ailp, cur); 263 cur->item = __xfs_trans_ail_cursor_last(ailp, lsn); 264 return cur->item; 265 } 266 267 /* 268 * Splice the log item list into the AIL at the given LSN. We splice to the 269 * tail of the given LSN to maintain insert order for push traversals. The 270 * cursor is optional, allowing repeated updates to the same LSN to avoid 271 * repeated traversals. This should not be called with an empty list. 272 */ 273 static void 274 xfs_ail_splice( 275 struct xfs_ail *ailp, 276 struct xfs_ail_cursor *cur, 277 struct list_head *list, 278 xfs_lsn_t lsn) 279 { 280 struct xfs_log_item *lip; 281 282 ASSERT(!list_empty(list)); 283 284 /* 285 * Use the cursor to determine the insertion point if one is 286 * provided. If not, or if the one we got is not valid, 287 * find the place in the AIL where the items belong. 288 */ 289 lip = cur ? cur->item : NULL; 290 if (!lip || (uintptr_t)lip & 1) 291 lip = __xfs_trans_ail_cursor_last(ailp, lsn); 292 293 /* 294 * If a cursor is provided, we know we're processing the AIL 295 * in lsn order, and future items to be spliced in will 296 * follow the last one being inserted now. Update the 297 * cursor to point to that last item, now while we have a 298 * reliable pointer to it. 299 */ 300 if (cur) 301 cur->item = list_entry(list->prev, struct xfs_log_item, li_ail); 302 303 /* 304 * Finally perform the splice. Unless the AIL was empty, 305 * lip points to the item in the AIL _after_ which the new 306 * items should go. If lip is null the AIL was empty, so 307 * the new items go at the head of the AIL. 308 */ 309 if (lip) 310 list_splice(list, &lip->li_ail); 311 else 312 list_splice(list, &ailp->xa_ail); 313 } 314 315 /* 316 * Delete the given item from the AIL. Return a pointer to the item. 317 */ 318 static void 319 xfs_ail_delete( 320 struct xfs_ail *ailp, 321 xfs_log_item_t *lip) 322 { 323 xfs_ail_check(ailp, lip); 324 list_del(&lip->li_ail); 325 xfs_trans_ail_cursor_clear(ailp, lip); 326 } 327 328 static inline uint 329 xfsaild_push_item( 330 struct xfs_ail *ailp, 331 struct xfs_log_item *lip) 332 { 333 /* 334 * If log item pinning is enabled, skip the push and track the item as 335 * pinned. This can help induce head-behind-tail conditions. 336 */ 337 if (XFS_TEST_ERROR(false, ailp->xa_mount, XFS_ERRTAG_LOG_ITEM_PIN)) 338 return XFS_ITEM_PINNED; 339 340 return lip->li_ops->iop_push(lip, &ailp->xa_buf_list); 341 } 342 343 static long 344 xfsaild_push( 345 struct xfs_ail *ailp) 346 { 347 xfs_mount_t *mp = ailp->xa_mount; 348 struct xfs_ail_cursor cur; 349 xfs_log_item_t *lip; 350 xfs_lsn_t lsn; 351 xfs_lsn_t target; 352 long tout; 353 int stuck = 0; 354 int flushing = 0; 355 int count = 0; 356 357 /* 358 * If we encountered pinned items or did not finish writing out all 359 * buffers the last time we ran, force the log first and wait for it 360 * before pushing again. 361 */ 362 if (ailp->xa_log_flush && ailp->xa_last_pushed_lsn == 0 && 363 (!list_empty_careful(&ailp->xa_buf_list) || 364 xfs_ail_min_lsn(ailp))) { 365 ailp->xa_log_flush = 0; 366 367 XFS_STATS_INC(mp, xs_push_ail_flush); 368 xfs_log_force(mp, XFS_LOG_SYNC); 369 } 370 371 spin_lock(&ailp->xa_lock); 372 373 /* barrier matches the xa_target update in xfs_ail_push() */ 374 smp_rmb(); 375 target = ailp->xa_target; 376 ailp->xa_target_prev = target; 377 378 lip = xfs_trans_ail_cursor_first(ailp, &cur, ailp->xa_last_pushed_lsn); 379 if (!lip) { 380 /* 381 * If the AIL is empty or our push has reached the end we are 382 * done now. 383 */ 384 xfs_trans_ail_cursor_done(&cur); 385 spin_unlock(&ailp->xa_lock); 386 goto out_done; 387 } 388 389 XFS_STATS_INC(mp, xs_push_ail); 390 391 lsn = lip->li_lsn; 392 while ((XFS_LSN_CMP(lip->li_lsn, target) <= 0)) { 393 int lock_result; 394 395 /* 396 * Note that iop_push may unlock and reacquire the AIL lock. We 397 * rely on the AIL cursor implementation to be able to deal with 398 * the dropped lock. 399 */ 400 lock_result = xfsaild_push_item(ailp, lip); 401 switch (lock_result) { 402 case XFS_ITEM_SUCCESS: 403 XFS_STATS_INC(mp, xs_push_ail_success); 404 trace_xfs_ail_push(lip); 405 406 ailp->xa_last_pushed_lsn = lsn; 407 break; 408 409 case XFS_ITEM_FLUSHING: 410 /* 411 * The item or its backing buffer is already beeing 412 * flushed. The typical reason for that is that an 413 * inode buffer is locked because we already pushed the 414 * updates to it as part of inode clustering. 415 * 416 * We do not want to to stop flushing just because lots 417 * of items are already beeing flushed, but we need to 418 * re-try the flushing relatively soon if most of the 419 * AIL is beeing flushed. 420 */ 421 XFS_STATS_INC(mp, xs_push_ail_flushing); 422 trace_xfs_ail_flushing(lip); 423 424 flushing++; 425 ailp->xa_last_pushed_lsn = lsn; 426 break; 427 428 case XFS_ITEM_PINNED: 429 XFS_STATS_INC(mp, xs_push_ail_pinned); 430 trace_xfs_ail_pinned(lip); 431 432 stuck++; 433 ailp->xa_log_flush++; 434 break; 435 case XFS_ITEM_LOCKED: 436 XFS_STATS_INC(mp, xs_push_ail_locked); 437 trace_xfs_ail_locked(lip); 438 439 stuck++; 440 break; 441 default: 442 ASSERT(0); 443 break; 444 } 445 446 count++; 447 448 /* 449 * Are there too many items we can't do anything with? 450 * 451 * If we we are skipping too many items because we can't flush 452 * them or they are already being flushed, we back off and 453 * given them time to complete whatever operation is being 454 * done. i.e. remove pressure from the AIL while we can't make 455 * progress so traversals don't slow down further inserts and 456 * removals to/from the AIL. 457 * 458 * The value of 100 is an arbitrary magic number based on 459 * observation. 460 */ 461 if (stuck > 100) 462 break; 463 464 lip = xfs_trans_ail_cursor_next(ailp, &cur); 465 if (lip == NULL) 466 break; 467 lsn = lip->li_lsn; 468 } 469 xfs_trans_ail_cursor_done(&cur); 470 spin_unlock(&ailp->xa_lock); 471 472 if (xfs_buf_delwri_submit_nowait(&ailp->xa_buf_list)) 473 ailp->xa_log_flush++; 474 475 if (!count || XFS_LSN_CMP(lsn, target) >= 0) { 476 out_done: 477 /* 478 * We reached the target or the AIL is empty, so wait a bit 479 * longer for I/O to complete and remove pushed items from the 480 * AIL before we start the next scan from the start of the AIL. 481 */ 482 tout = 50; 483 ailp->xa_last_pushed_lsn = 0; 484 } else if (((stuck + flushing) * 100) / count > 90) { 485 /* 486 * Either there is a lot of contention on the AIL or we are 487 * stuck due to operations in progress. "Stuck" in this case 488 * is defined as >90% of the items we tried to push were stuck. 489 * 490 * Backoff a bit more to allow some I/O to complete before 491 * restarting from the start of the AIL. This prevents us from 492 * spinning on the same items, and if they are pinned will all 493 * the restart to issue a log force to unpin the stuck items. 494 */ 495 tout = 20; 496 ailp->xa_last_pushed_lsn = 0; 497 } else { 498 /* 499 * Assume we have more work to do in a short while. 500 */ 501 tout = 10; 502 } 503 504 return tout; 505 } 506 507 static int 508 xfsaild( 509 void *data) 510 { 511 struct xfs_ail *ailp = data; 512 long tout = 0; /* milliseconds */ 513 514 current->flags |= PF_MEMALLOC; 515 set_freezable(); 516 517 while (!kthread_should_stop()) { 518 if (tout && tout <= 20) 519 __set_current_state(TASK_KILLABLE); 520 else 521 __set_current_state(TASK_INTERRUPTIBLE); 522 523 spin_lock(&ailp->xa_lock); 524 525 /* 526 * Idle if the AIL is empty and we are not racing with a target 527 * update. We check the AIL after we set the task to a sleep 528 * state to guarantee that we either catch an xa_target update 529 * or that a wake_up resets the state to TASK_RUNNING. 530 * Otherwise, we run the risk of sleeping indefinitely. 531 * 532 * The barrier matches the xa_target update in xfs_ail_push(). 533 */ 534 smp_rmb(); 535 if (!xfs_ail_min(ailp) && 536 ailp->xa_target == ailp->xa_target_prev) { 537 spin_unlock(&ailp->xa_lock); 538 freezable_schedule(); 539 tout = 0; 540 continue; 541 } 542 spin_unlock(&ailp->xa_lock); 543 544 if (tout) 545 freezable_schedule_timeout(msecs_to_jiffies(tout)); 546 547 __set_current_state(TASK_RUNNING); 548 549 try_to_freeze(); 550 551 tout = xfsaild_push(ailp); 552 } 553 554 return 0; 555 } 556 557 /* 558 * This routine is called to move the tail of the AIL forward. It does this by 559 * trying to flush items in the AIL whose lsns are below the given 560 * threshold_lsn. 561 * 562 * The push is run asynchronously in a workqueue, which means the caller needs 563 * to handle waiting on the async flush for space to become available. 564 * We don't want to interrupt any push that is in progress, hence we only queue 565 * work if we set the pushing bit approriately. 566 * 567 * We do this unlocked - we only need to know whether there is anything in the 568 * AIL at the time we are called. We don't need to access the contents of 569 * any of the objects, so the lock is not needed. 570 */ 571 void 572 xfs_ail_push( 573 struct xfs_ail *ailp, 574 xfs_lsn_t threshold_lsn) 575 { 576 xfs_log_item_t *lip; 577 578 lip = xfs_ail_min(ailp); 579 if (!lip || XFS_FORCED_SHUTDOWN(ailp->xa_mount) || 580 XFS_LSN_CMP(threshold_lsn, ailp->xa_target) <= 0) 581 return; 582 583 /* 584 * Ensure that the new target is noticed in push code before it clears 585 * the XFS_AIL_PUSHING_BIT. 586 */ 587 smp_wmb(); 588 xfs_trans_ail_copy_lsn(ailp, &ailp->xa_target, &threshold_lsn); 589 smp_wmb(); 590 591 wake_up_process(ailp->xa_task); 592 } 593 594 /* 595 * Push out all items in the AIL immediately 596 */ 597 void 598 xfs_ail_push_all( 599 struct xfs_ail *ailp) 600 { 601 xfs_lsn_t threshold_lsn = xfs_ail_max_lsn(ailp); 602 603 if (threshold_lsn) 604 xfs_ail_push(ailp, threshold_lsn); 605 } 606 607 /* 608 * Push out all items in the AIL immediately and wait until the AIL is empty. 609 */ 610 void 611 xfs_ail_push_all_sync( 612 struct xfs_ail *ailp) 613 { 614 struct xfs_log_item *lip; 615 DEFINE_WAIT(wait); 616 617 spin_lock(&ailp->xa_lock); 618 while ((lip = xfs_ail_max(ailp)) != NULL) { 619 prepare_to_wait(&ailp->xa_empty, &wait, TASK_UNINTERRUPTIBLE); 620 ailp->xa_target = lip->li_lsn; 621 wake_up_process(ailp->xa_task); 622 spin_unlock(&ailp->xa_lock); 623 schedule(); 624 spin_lock(&ailp->xa_lock); 625 } 626 spin_unlock(&ailp->xa_lock); 627 628 finish_wait(&ailp->xa_empty, &wait); 629 } 630 631 /* 632 * xfs_trans_ail_update - bulk AIL insertion operation. 633 * 634 * @xfs_trans_ail_update takes an array of log items that all need to be 635 * positioned at the same LSN in the AIL. If an item is not in the AIL, it will 636 * be added. Otherwise, it will be repositioned by removing it and re-adding 637 * it to the AIL. If we move the first item in the AIL, update the log tail to 638 * match the new minimum LSN in the AIL. 639 * 640 * This function takes the AIL lock once to execute the update operations on 641 * all the items in the array, and as such should not be called with the AIL 642 * lock held. As a result, once we have the AIL lock, we need to check each log 643 * item LSN to confirm it needs to be moved forward in the AIL. 644 * 645 * To optimise the insert operation, we delete all the items from the AIL in 646 * the first pass, moving them into a temporary list, then splice the temporary 647 * list into the correct position in the AIL. This avoids needing to do an 648 * insert operation on every item. 649 * 650 * This function must be called with the AIL lock held. The lock is dropped 651 * before returning. 652 */ 653 void 654 xfs_trans_ail_update_bulk( 655 struct xfs_ail *ailp, 656 struct xfs_ail_cursor *cur, 657 struct xfs_log_item **log_items, 658 int nr_items, 659 xfs_lsn_t lsn) __releases(ailp->xa_lock) 660 { 661 xfs_log_item_t *mlip; 662 int mlip_changed = 0; 663 int i; 664 LIST_HEAD(tmp); 665 666 ASSERT(nr_items > 0); /* Not required, but true. */ 667 mlip = xfs_ail_min(ailp); 668 669 for (i = 0; i < nr_items; i++) { 670 struct xfs_log_item *lip = log_items[i]; 671 if (lip->li_flags & XFS_LI_IN_AIL) { 672 /* check if we really need to move the item */ 673 if (XFS_LSN_CMP(lsn, lip->li_lsn) <= 0) 674 continue; 675 676 trace_xfs_ail_move(lip, lip->li_lsn, lsn); 677 xfs_ail_delete(ailp, lip); 678 if (mlip == lip) 679 mlip_changed = 1; 680 } else { 681 lip->li_flags |= XFS_LI_IN_AIL; 682 trace_xfs_ail_insert(lip, 0, lsn); 683 } 684 lip->li_lsn = lsn; 685 list_add(&lip->li_ail, &tmp); 686 } 687 688 if (!list_empty(&tmp)) 689 xfs_ail_splice(ailp, cur, &tmp, lsn); 690 691 if (mlip_changed) { 692 if (!XFS_FORCED_SHUTDOWN(ailp->xa_mount)) 693 xlog_assign_tail_lsn_locked(ailp->xa_mount); 694 spin_unlock(&ailp->xa_lock); 695 696 xfs_log_space_wake(ailp->xa_mount); 697 } else { 698 spin_unlock(&ailp->xa_lock); 699 } 700 } 701 702 bool 703 xfs_ail_delete_one( 704 struct xfs_ail *ailp, 705 struct xfs_log_item *lip) 706 { 707 struct xfs_log_item *mlip = xfs_ail_min(ailp); 708 709 trace_xfs_ail_delete(lip, mlip->li_lsn, lip->li_lsn); 710 xfs_ail_delete(ailp, lip); 711 xfs_clear_li_failed(lip); 712 lip->li_flags &= ~XFS_LI_IN_AIL; 713 lip->li_lsn = 0; 714 715 return mlip == lip; 716 } 717 718 /** 719 * Remove a log items from the AIL 720 * 721 * @xfs_trans_ail_delete_bulk takes an array of log items that all need to 722 * removed from the AIL. The caller is already holding the AIL lock, and done 723 * all the checks necessary to ensure the items passed in via @log_items are 724 * ready for deletion. This includes checking that the items are in the AIL. 725 * 726 * For each log item to be removed, unlink it from the AIL, clear the IN_AIL 727 * flag from the item and reset the item's lsn to 0. If we remove the first 728 * item in the AIL, update the log tail to match the new minimum LSN in the 729 * AIL. 730 * 731 * This function will not drop the AIL lock until all items are removed from 732 * the AIL to minimise the amount of lock traffic on the AIL. This does not 733 * greatly increase the AIL hold time, but does significantly reduce the amount 734 * of traffic on the lock, especially during IO completion. 735 * 736 * This function must be called with the AIL lock held. The lock is dropped 737 * before returning. 738 */ 739 void 740 xfs_trans_ail_delete( 741 struct xfs_ail *ailp, 742 struct xfs_log_item *lip, 743 int shutdown_type) __releases(ailp->xa_lock) 744 { 745 struct xfs_mount *mp = ailp->xa_mount; 746 bool mlip_changed; 747 748 if (!(lip->li_flags & XFS_LI_IN_AIL)) { 749 spin_unlock(&ailp->xa_lock); 750 if (!XFS_FORCED_SHUTDOWN(mp)) { 751 xfs_alert_tag(mp, XFS_PTAG_AILDELETE, 752 "%s: attempting to delete a log item that is not in the AIL", 753 __func__); 754 xfs_force_shutdown(mp, shutdown_type); 755 } 756 return; 757 } 758 759 mlip_changed = xfs_ail_delete_one(ailp, lip); 760 if (mlip_changed) { 761 if (!XFS_FORCED_SHUTDOWN(mp)) 762 xlog_assign_tail_lsn_locked(mp); 763 if (list_empty(&ailp->xa_ail)) 764 wake_up_all(&ailp->xa_empty); 765 } 766 767 spin_unlock(&ailp->xa_lock); 768 if (mlip_changed) 769 xfs_log_space_wake(ailp->xa_mount); 770 } 771 772 int 773 xfs_trans_ail_init( 774 xfs_mount_t *mp) 775 { 776 struct xfs_ail *ailp; 777 778 ailp = kmem_zalloc(sizeof(struct xfs_ail), KM_MAYFAIL); 779 if (!ailp) 780 return -ENOMEM; 781 782 ailp->xa_mount = mp; 783 INIT_LIST_HEAD(&ailp->xa_ail); 784 INIT_LIST_HEAD(&ailp->xa_cursors); 785 spin_lock_init(&ailp->xa_lock); 786 INIT_LIST_HEAD(&ailp->xa_buf_list); 787 init_waitqueue_head(&ailp->xa_empty); 788 789 ailp->xa_task = kthread_run(xfsaild, ailp, "xfsaild/%s", 790 ailp->xa_mount->m_fsname); 791 if (IS_ERR(ailp->xa_task)) 792 goto out_free_ailp; 793 794 mp->m_ail = ailp; 795 return 0; 796 797 out_free_ailp: 798 kmem_free(ailp); 799 return -ENOMEM; 800 } 801 802 void 803 xfs_trans_ail_destroy( 804 xfs_mount_t *mp) 805 { 806 struct xfs_ail *ailp = mp->m_ail; 807 808 kthread_stop(ailp->xa_task); 809 kmem_free(ailp); 810 } 811