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