11da177e4SLinus Torvalds /* 27b718769SNathan Scott * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc. 3c7e8f268SDavid Chinner * Copyright (c) 2008 Dave Chinner 47b718769SNathan Scott * All Rights Reserved. 51da177e4SLinus Torvalds * 67b718769SNathan Scott * This program is free software; you can redistribute it and/or 77b718769SNathan Scott * modify it under the terms of the GNU General Public License as 81da177e4SLinus Torvalds * published by the Free Software Foundation. 91da177e4SLinus Torvalds * 107b718769SNathan Scott * This program is distributed in the hope that it would be useful, 117b718769SNathan Scott * but WITHOUT ANY WARRANTY; without even the implied warranty of 127b718769SNathan Scott * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 137b718769SNathan Scott * GNU General Public License for more details. 141da177e4SLinus Torvalds * 157b718769SNathan Scott * You should have received a copy of the GNU General Public License 167b718769SNathan Scott * along with this program; if not, write the Free Software Foundation, 177b718769SNathan Scott * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 181da177e4SLinus Torvalds */ 191da177e4SLinus Torvalds #include "xfs.h" 20a844f451SNathan Scott #include "xfs_fs.h" 211da177e4SLinus Torvalds #include "xfs_types.h" 221da177e4SLinus Torvalds #include "xfs_log.h" 23a844f451SNathan Scott #include "xfs_inum.h" 241da177e4SLinus Torvalds #include "xfs_trans.h" 251da177e4SLinus Torvalds #include "xfs_sb.h" 26da353b0dSDavid Chinner #include "xfs_ag.h" 271da177e4SLinus Torvalds #include "xfs_mount.h" 281da177e4SLinus Torvalds #include "xfs_trans_priv.h" 291da177e4SLinus Torvalds #include "xfs_error.h" 301da177e4SLinus Torvalds 311da177e4SLinus Torvalds #ifdef DEBUG 32cd4a3c50SDave Chinner /* 33cd4a3c50SDave Chinner * Check that the list is sorted as it should be. 34cd4a3c50SDave Chinner */ 35cd4a3c50SDave Chinner STATIC void 36cd4a3c50SDave Chinner xfs_ail_check( 37cd4a3c50SDave Chinner struct xfs_ail *ailp, 38cd4a3c50SDave Chinner xfs_log_item_t *lip) 39cd4a3c50SDave Chinner { 40cd4a3c50SDave Chinner xfs_log_item_t *prev_lip; 41cd4a3c50SDave Chinner 42cd4a3c50SDave Chinner if (list_empty(&ailp->xa_ail)) 43cd4a3c50SDave Chinner return; 44cd4a3c50SDave Chinner 45cd4a3c50SDave Chinner /* 46cd4a3c50SDave Chinner * Check the next and previous entries are valid. 47cd4a3c50SDave Chinner */ 48cd4a3c50SDave Chinner ASSERT((lip->li_flags & XFS_LI_IN_AIL) != 0); 49cd4a3c50SDave Chinner prev_lip = list_entry(lip->li_ail.prev, xfs_log_item_t, li_ail); 50cd4a3c50SDave Chinner if (&prev_lip->li_ail != &ailp->xa_ail) 51cd4a3c50SDave Chinner ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) <= 0); 52cd4a3c50SDave Chinner 53cd4a3c50SDave Chinner prev_lip = list_entry(lip->li_ail.next, xfs_log_item_t, li_ail); 54cd4a3c50SDave Chinner if (&prev_lip->li_ail != &ailp->xa_ail) 55cd4a3c50SDave Chinner ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) >= 0); 56cd4a3c50SDave Chinner 57cd4a3c50SDave Chinner 58cd4a3c50SDave Chinner #ifdef XFS_TRANS_DEBUG 59cd4a3c50SDave Chinner /* 60cd4a3c50SDave Chinner * Walk the list checking lsn ordering, and that every entry has the 61cd4a3c50SDave Chinner * XFS_LI_IN_AIL flag set. This is really expensive, so only do it 62cd4a3c50SDave Chinner * when specifically debugging the transaction subsystem. 63cd4a3c50SDave Chinner */ 64cd4a3c50SDave Chinner prev_lip = list_entry(&ailp->xa_ail, xfs_log_item_t, li_ail); 65cd4a3c50SDave Chinner list_for_each_entry(lip, &ailp->xa_ail, li_ail) { 66cd4a3c50SDave Chinner if (&prev_lip->li_ail != &ailp->xa_ail) 67cd4a3c50SDave Chinner ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) <= 0); 68cd4a3c50SDave Chinner ASSERT((lip->li_flags & XFS_LI_IN_AIL) != 0); 69cd4a3c50SDave Chinner prev_lip = lip; 70cd4a3c50SDave Chinner } 71cd4a3c50SDave Chinner #endif /* XFS_TRANS_DEBUG */ 72cd4a3c50SDave Chinner } 73cd4a3c50SDave Chinner #else /* !DEBUG */ 74de08dbc1SDavid Chinner #define xfs_ail_check(a,l) 751da177e4SLinus Torvalds #endif /* DEBUG */ 761da177e4SLinus Torvalds 77cd4a3c50SDave Chinner /* 78cd4a3c50SDave Chinner * Return a pointer to the first item in the AIL. If the AIL is empty, then 79cd4a3c50SDave Chinner * return NULL. 80cd4a3c50SDave Chinner */ 81cd4a3c50SDave Chinner static xfs_log_item_t * 82cd4a3c50SDave Chinner xfs_ail_min( 83cd4a3c50SDave Chinner struct xfs_ail *ailp) 84cd4a3c50SDave Chinner { 85cd4a3c50SDave Chinner if (list_empty(&ailp->xa_ail)) 86cd4a3c50SDave Chinner return NULL; 87cd4a3c50SDave Chinner 88cd4a3c50SDave Chinner return list_first_entry(&ailp->xa_ail, xfs_log_item_t, li_ail); 89cd4a3c50SDave Chinner } 901da177e4SLinus Torvalds 911da177e4SLinus Torvalds /* 92fd074841SDave Chinner * Return a pointer to the last item in the AIL. If the AIL is empty, then 93fd074841SDave Chinner * return NULL. 94fd074841SDave Chinner */ 95fd074841SDave Chinner static xfs_log_item_t * 96fd074841SDave Chinner xfs_ail_max( 97fd074841SDave Chinner struct xfs_ail *ailp) 98fd074841SDave Chinner { 99fd074841SDave Chinner if (list_empty(&ailp->xa_ail)) 100fd074841SDave Chinner return NULL; 101fd074841SDave Chinner 102fd074841SDave Chinner return list_entry(ailp->xa_ail.prev, xfs_log_item_t, li_ail); 103fd074841SDave Chinner } 104fd074841SDave Chinner 105fd074841SDave Chinner /* 106cd4a3c50SDave Chinner * Return a pointer to the item which follows the given item in the AIL. If 107cd4a3c50SDave Chinner * the given item is the last item in the list, then return NULL. 108cd4a3c50SDave Chinner */ 109cd4a3c50SDave Chinner static xfs_log_item_t * 110cd4a3c50SDave Chinner xfs_ail_next( 111cd4a3c50SDave Chinner struct xfs_ail *ailp, 112cd4a3c50SDave Chinner xfs_log_item_t *lip) 113cd4a3c50SDave Chinner { 114cd4a3c50SDave Chinner if (lip->li_ail.next == &ailp->xa_ail) 115cd4a3c50SDave Chinner return NULL; 116cd4a3c50SDave Chinner 117cd4a3c50SDave Chinner return list_first_entry(&lip->li_ail, xfs_log_item_t, li_ail); 118cd4a3c50SDave Chinner } 119cd4a3c50SDave Chinner 120cd4a3c50SDave Chinner /* 121cd4a3c50SDave Chinner * This is called by the log manager code to determine the LSN of the tail of 122cd4a3c50SDave Chinner * the log. This is exactly the LSN of the first item in the AIL. If the AIL 123cd4a3c50SDave Chinner * is empty, then this function returns 0. 1241da177e4SLinus Torvalds * 125cd4a3c50SDave Chinner * We need the AIL lock in order to get a coherent read of the lsn of the last 126cd4a3c50SDave Chinner * item in the AIL. 1271da177e4SLinus Torvalds */ 1281da177e4SLinus Torvalds xfs_lsn_t 129fd074841SDave Chinner xfs_ail_min_lsn( 1305b00f14fSDavid Chinner struct xfs_ail *ailp) 1311da177e4SLinus Torvalds { 132cd4a3c50SDave Chinner xfs_lsn_t lsn = 0; 1331da177e4SLinus Torvalds xfs_log_item_t *lip; 1341da177e4SLinus Torvalds 135c7e8f268SDavid Chinner spin_lock(&ailp->xa_lock); 1365b00f14fSDavid Chinner lip = xfs_ail_min(ailp); 137cd4a3c50SDave Chinner if (lip) 1381da177e4SLinus Torvalds lsn = lip->li_lsn; 139c7e8f268SDavid Chinner spin_unlock(&ailp->xa_lock); 1401da177e4SLinus Torvalds 1411da177e4SLinus Torvalds return lsn; 1421da177e4SLinus Torvalds } 1431da177e4SLinus Torvalds 1441da177e4SLinus Torvalds /* 145fd074841SDave Chinner * Return the maximum lsn held in the AIL, or zero if the AIL is empty. 146fd074841SDave Chinner */ 147fd074841SDave Chinner static xfs_lsn_t 148fd074841SDave Chinner xfs_ail_max_lsn( 149fd074841SDave Chinner struct xfs_ail *ailp) 150fd074841SDave Chinner { 151fd074841SDave Chinner xfs_lsn_t lsn = 0; 152fd074841SDave Chinner xfs_log_item_t *lip; 153fd074841SDave Chinner 154fd074841SDave Chinner spin_lock(&ailp->xa_lock); 155fd074841SDave Chinner lip = xfs_ail_max(ailp); 156fd074841SDave Chinner if (lip) 157fd074841SDave Chinner lsn = lip->li_lsn; 158fd074841SDave Chinner spin_unlock(&ailp->xa_lock); 159fd074841SDave Chinner 160fd074841SDave Chinner return lsn; 161fd074841SDave Chinner } 162fd074841SDave Chinner 163fd074841SDave Chinner /* 164af3e4022SDave Chinner * The cursor keeps track of where our current traversal is up to by tracking 165af3e4022SDave Chinner * the next item in the list for us. However, for this to be safe, removing an 166af3e4022SDave Chinner * object from the AIL needs to invalidate any cursor that points to it. hence 167af3e4022SDave Chinner * the traversal cursor needs to be linked to the struct xfs_ail so that 168af3e4022SDave Chinner * deletion can search all the active cursors for invalidation. 16927d8d5feSDavid Chinner */ 1705b00f14fSDavid Chinner STATIC void 17127d8d5feSDavid Chinner xfs_trans_ail_cursor_init( 17227d8d5feSDavid Chinner struct xfs_ail *ailp, 17327d8d5feSDavid Chinner struct xfs_ail_cursor *cur) 17427d8d5feSDavid Chinner { 17527d8d5feSDavid Chinner cur->item = NULL; 176af3e4022SDave Chinner list_add_tail(&cur->list, &ailp->xa_cursors); 17727d8d5feSDavid Chinner } 17827d8d5feSDavid Chinner 17927d8d5feSDavid Chinner /* 180af3e4022SDave Chinner * Get the next item in the traversal and advance the cursor. If the cursor 181af3e4022SDave Chinner * was invalidated (indicated by a lip of 1), restart the traversal. 18227d8d5feSDavid Chinner */ 1835b00f14fSDavid Chinner struct xfs_log_item * 18427d8d5feSDavid Chinner xfs_trans_ail_cursor_next( 18527d8d5feSDavid Chinner struct xfs_ail *ailp, 18627d8d5feSDavid Chinner struct xfs_ail_cursor *cur) 18727d8d5feSDavid Chinner { 18827d8d5feSDavid Chinner struct xfs_log_item *lip = cur->item; 18927d8d5feSDavid Chinner 19027d8d5feSDavid Chinner if ((__psint_t)lip & 1) 19127d8d5feSDavid Chinner lip = xfs_ail_min(ailp); 19216b59029SDave Chinner if (lip) 19316b59029SDave Chinner cur->item = xfs_ail_next(ailp, lip); 19427d8d5feSDavid Chinner return lip; 19527d8d5feSDavid Chinner } 19627d8d5feSDavid Chinner 19727d8d5feSDavid Chinner /* 198af3e4022SDave Chinner * When the traversal is complete, we need to remove the cursor from the list 199af3e4022SDave Chinner * of traversing cursors. 20027d8d5feSDavid Chinner */ 20127d8d5feSDavid Chinner void 20227d8d5feSDavid Chinner xfs_trans_ail_cursor_done( 20327d8d5feSDavid Chinner struct xfs_ail *ailp, 204af3e4022SDave Chinner struct xfs_ail_cursor *cur) 20527d8d5feSDavid Chinner { 206af3e4022SDave Chinner cur->item = NULL; 207af3e4022SDave Chinner list_del_init(&cur->list); 20827d8d5feSDavid Chinner } 20927d8d5feSDavid Chinner 21027d8d5feSDavid Chinner /* 211af3e4022SDave Chinner * Invalidate any cursor that is pointing to this item. This is called when an 212af3e4022SDave Chinner * item is removed from the AIL. Any cursor pointing to this object is now 213af3e4022SDave Chinner * invalid and the traversal needs to be terminated so it doesn't reference a 214af3e4022SDave Chinner * freed object. We set the low bit of the cursor item pointer so we can 215af3e4022SDave Chinner * distinguish between an invalidation and the end of the list when getting the 216af3e4022SDave Chinner * next item from the cursor. 2175b00f14fSDavid Chinner */ 2185b00f14fSDavid Chinner STATIC void 2195b00f14fSDavid Chinner xfs_trans_ail_cursor_clear( 2205b00f14fSDavid Chinner struct xfs_ail *ailp, 2215b00f14fSDavid Chinner struct xfs_log_item *lip) 2225b00f14fSDavid Chinner { 2235b00f14fSDavid Chinner struct xfs_ail_cursor *cur; 2245b00f14fSDavid Chinner 225af3e4022SDave Chinner list_for_each_entry(cur, &ailp->xa_cursors, list) { 2265b00f14fSDavid Chinner if (cur->item == lip) 2275b00f14fSDavid Chinner cur->item = (struct xfs_log_item *) 2285b00f14fSDavid Chinner ((__psint_t)cur->item | 1); 2295b00f14fSDavid Chinner } 2305b00f14fSDavid Chinner } 2315b00f14fSDavid Chinner 2325b00f14fSDavid Chinner /* 23316b59029SDave Chinner * Find the first item in the AIL with the given @lsn by searching in ascending 23416b59029SDave Chinner * LSN order and initialise the cursor to point to the next item for a 23516b59029SDave Chinner * ascending traversal. Pass a @lsn of zero to initialise the cursor to the 23616b59029SDave Chinner * first item in the AIL. Returns NULL if the list is empty. 237249a8c11SDavid Chinner */ 2385b00f14fSDavid Chinner xfs_log_item_t * 2395b00f14fSDavid Chinner xfs_trans_ail_cursor_first( 24027d8d5feSDavid Chinner struct xfs_ail *ailp, 24127d8d5feSDavid Chinner struct xfs_ail_cursor *cur, 242249a8c11SDavid Chinner xfs_lsn_t lsn) 243249a8c11SDavid Chinner { 244249a8c11SDavid Chinner xfs_log_item_t *lip; 245249a8c11SDavid Chinner 2465b00f14fSDavid Chinner xfs_trans_ail_cursor_init(ailp, cur); 24716b59029SDave Chinner 24816b59029SDave Chinner if (lsn == 0) { 24927d8d5feSDavid Chinner lip = xfs_ail_min(ailp); 2505b00f14fSDavid Chinner goto out; 25116b59029SDave Chinner } 252249a8c11SDavid Chinner 25327d8d5feSDavid Chinner list_for_each_entry(lip, &ailp->xa_ail, li_ail) { 2545b00f14fSDavid Chinner if (XFS_LSN_CMP(lip->li_lsn, lsn) >= 0) 2557ee49acfSDavid Chinner goto out; 2565b00f14fSDavid Chinner } 25716b59029SDave Chinner return NULL; 25816b59029SDave Chinner 2595b00f14fSDavid Chinner out: 26016b59029SDave Chinner if (lip) 26116b59029SDave Chinner cur->item = xfs_ail_next(ailp, lip); 262249a8c11SDavid Chinner return lip; 263249a8c11SDavid Chinner } 264535f6b37SJosef 'Jeff' Sipek 2651d8c95a3SDave Chinner static struct xfs_log_item * 2661d8c95a3SDave Chinner __xfs_trans_ail_cursor_last( 2671d8c95a3SDave Chinner struct xfs_ail *ailp, 2681d8c95a3SDave Chinner xfs_lsn_t lsn) 2691d8c95a3SDave Chinner { 2701d8c95a3SDave Chinner xfs_log_item_t *lip; 2711d8c95a3SDave Chinner 2721d8c95a3SDave Chinner list_for_each_entry_reverse(lip, &ailp->xa_ail, li_ail) { 2731d8c95a3SDave Chinner if (XFS_LSN_CMP(lip->li_lsn, lsn) <= 0) 2741d8c95a3SDave Chinner return lip; 2751d8c95a3SDave Chinner } 2761d8c95a3SDave Chinner return NULL; 2771d8c95a3SDave Chinner } 2781d8c95a3SDave Chinner 2791d8c95a3SDave Chinner /* 28016b59029SDave Chinner * Find the last item in the AIL with the given @lsn by searching in descending 28116b59029SDave Chinner * LSN order and initialise the cursor to point to that item. If there is no 28216b59029SDave Chinner * item with the value of @lsn, then it sets the cursor to the last item with an 28316b59029SDave Chinner * LSN lower than @lsn. Returns NULL if the list is empty. 2841d8c95a3SDave Chinner */ 2851d8c95a3SDave Chinner struct xfs_log_item * 2861d8c95a3SDave Chinner xfs_trans_ail_cursor_last( 2871d8c95a3SDave Chinner struct xfs_ail *ailp, 2881d8c95a3SDave Chinner struct xfs_ail_cursor *cur, 2891d8c95a3SDave Chinner xfs_lsn_t lsn) 2901d8c95a3SDave Chinner { 2911d8c95a3SDave Chinner xfs_trans_ail_cursor_init(ailp, cur); 2921d8c95a3SDave Chinner cur->item = __xfs_trans_ail_cursor_last(ailp, lsn); 2931d8c95a3SDave Chinner return cur->item; 2941d8c95a3SDave Chinner } 2951d8c95a3SDave Chinner 2961d8c95a3SDave Chinner /* 29716b59029SDave Chinner * Splice the log item list into the AIL at the given LSN. We splice to the 2981d8c95a3SDave Chinner * tail of the given LSN to maintain insert order for push traversals. The 2991d8c95a3SDave Chinner * cursor is optional, allowing repeated updates to the same LSN to avoid 300e44f4112SAlex Elder * repeated traversals. This should not be called with an empty list. 301cd4a3c50SDave Chinner */ 302cd4a3c50SDave Chinner static void 303cd4a3c50SDave Chinner xfs_ail_splice( 304cd4a3c50SDave Chinner struct xfs_ail *ailp, 3051d8c95a3SDave Chinner struct xfs_ail_cursor *cur, 306cd4a3c50SDave Chinner struct list_head *list, 307cd4a3c50SDave Chinner xfs_lsn_t lsn) 308cd4a3c50SDave Chinner { 309e44f4112SAlex Elder struct xfs_log_item *lip; 310e44f4112SAlex Elder 311e44f4112SAlex Elder ASSERT(!list_empty(list)); 312cd4a3c50SDave Chinner 3131d8c95a3SDave Chinner /* 314e44f4112SAlex Elder * Use the cursor to determine the insertion point if one is 315e44f4112SAlex Elder * provided. If not, or if the one we got is not valid, 316e44f4112SAlex Elder * find the place in the AIL where the items belong. 3171d8c95a3SDave Chinner */ 318e44f4112SAlex Elder lip = cur ? cur->item : NULL; 319e44f4112SAlex Elder if (!lip || (__psint_t) lip & 1) 3201d8c95a3SDave Chinner lip = __xfs_trans_ail_cursor_last(ailp, lsn); 3211d8c95a3SDave Chinner 322e44f4112SAlex Elder /* 323e44f4112SAlex Elder * If a cursor is provided, we know we're processing the AIL 324e44f4112SAlex Elder * in lsn order, and future items to be spliced in will 325e44f4112SAlex Elder * follow the last one being inserted now. Update the 326e44f4112SAlex Elder * cursor to point to that last item, now while we have a 327e44f4112SAlex Elder * reliable pointer to it. 328e44f4112SAlex Elder */ 3291d8c95a3SDave Chinner if (cur) 330e44f4112SAlex Elder cur->item = list_entry(list->prev, struct xfs_log_item, li_ail); 331cd4a3c50SDave Chinner 3321d8c95a3SDave Chinner /* 333e44f4112SAlex Elder * Finally perform the splice. Unless the AIL was empty, 334e44f4112SAlex Elder * lip points to the item in the AIL _after_ which the new 335e44f4112SAlex Elder * items should go. If lip is null the AIL was empty, so 336e44f4112SAlex Elder * the new items go at the head of the AIL. 3371d8c95a3SDave Chinner */ 338e44f4112SAlex Elder if (lip) 3391d8c95a3SDave Chinner list_splice(list, &lip->li_ail); 340e44f4112SAlex Elder else 341e44f4112SAlex Elder list_splice(list, &ailp->xa_ail); 342cd4a3c50SDave Chinner } 343cd4a3c50SDave Chinner 344cd4a3c50SDave Chinner /* 345cd4a3c50SDave Chinner * Delete the given item from the AIL. Return a pointer to the item. 346cd4a3c50SDave Chinner */ 347cd4a3c50SDave Chinner static void 348cd4a3c50SDave Chinner xfs_ail_delete( 349cd4a3c50SDave Chinner struct xfs_ail *ailp, 350cd4a3c50SDave Chinner xfs_log_item_t *lip) 351cd4a3c50SDave Chinner { 352cd4a3c50SDave Chinner xfs_ail_check(ailp, lip); 353cd4a3c50SDave Chinner list_del(&lip->li_ail); 354cd4a3c50SDave Chinner xfs_trans_ail_cursor_clear(ailp, lip); 355cd4a3c50SDave Chinner } 356cd4a3c50SDave Chinner 3570030807cSChristoph Hellwig static long 3580030807cSChristoph Hellwig xfsaild_push( 3590030807cSChristoph Hellwig struct xfs_ail *ailp) 360249a8c11SDavid Chinner { 36182fa9012SDavid Chinner xfs_mount_t *mp = ailp->xa_mount; 362af3e4022SDave Chinner struct xfs_ail_cursor cur; 3639e7004e7SDave Chinner xfs_log_item_t *lip; 3649e7004e7SDave Chinner xfs_lsn_t lsn; 365fe0da767SDave Chinner xfs_lsn_t target; 3669e7004e7SDave Chinner long tout = 10; 3679e7004e7SDave Chinner int flush_log = 0; 3689e7004e7SDave Chinner int stuck = 0; 3699e7004e7SDave Chinner int count = 0; 370d808f617SDave Chinner int push_xfsbufd = 0; 3711da177e4SLinus Torvalds 372c7e8f268SDavid Chinner spin_lock(&ailp->xa_lock); 373fe0da767SDave Chinner target = ailp->xa_target; 374af3e4022SDave Chinner lip = xfs_trans_ail_cursor_first(ailp, &cur, ailp->xa_last_pushed_lsn); 375249a8c11SDavid Chinner if (!lip || XFS_FORCED_SHUTDOWN(mp)) { 3761da177e4SLinus Torvalds /* 377249a8c11SDavid Chinner * AIL is empty or our push has reached the end. 3781da177e4SLinus Torvalds */ 379af3e4022SDave Chinner xfs_trans_ail_cursor_done(ailp, &cur); 380c7e8f268SDavid Chinner spin_unlock(&ailp->xa_lock); 3819e7004e7SDave Chinner goto out_done; 3821da177e4SLinus Torvalds } 3831da177e4SLinus Torvalds 3841da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail); 3851da177e4SLinus Torvalds 3861da177e4SLinus Torvalds /* 3871da177e4SLinus Torvalds * While the item we are looking at is below the given threshold 388249a8c11SDavid Chinner * try to flush it out. We'd like not to stop until we've at least 3891da177e4SLinus Torvalds * tried to push on everything in the AIL with an LSN less than 390249a8c11SDavid Chinner * the given threshold. 3911da177e4SLinus Torvalds * 392249a8c11SDavid Chinner * However, we will stop after a certain number of pushes and wait 393249a8c11SDavid Chinner * for a reduced timeout to fire before pushing further. This 394249a8c11SDavid Chinner * prevents use from spinning when we can't do anything or there is 395249a8c11SDavid Chinner * lots of contention on the AIL lists. 396249a8c11SDavid Chinner */ 397249a8c11SDavid Chinner lsn = lip->li_lsn; 39850e86686SDave Chinner while ((XFS_LSN_CMP(lip->li_lsn, target) <= 0)) { 399249a8c11SDavid Chinner int lock_result; 400249a8c11SDavid Chinner /* 401249a8c11SDavid Chinner * If we can lock the item without sleeping, unlock the AIL 402249a8c11SDavid Chinner * lock and flush the item. Then re-grab the AIL lock so we 403249a8c11SDavid Chinner * can look for the next item on the AIL. List changes are 404249a8c11SDavid Chinner * handled by the AIL lookup functions internally 405249a8c11SDavid Chinner * 406249a8c11SDavid Chinner * If we can't lock the item, either its holder will flush it 407249a8c11SDavid Chinner * or it is already being flushed or it is being relogged. In 408249a8c11SDavid Chinner * any of these case it is being taken care of and we can just 409249a8c11SDavid Chinner * skip to the next item in the list. 4101da177e4SLinus Torvalds */ 4111da177e4SLinus Torvalds lock_result = IOP_TRYLOCK(lip); 412c7e8f268SDavid Chinner spin_unlock(&ailp->xa_lock); 4131da177e4SLinus Torvalds switch (lock_result) { 4141da177e4SLinus Torvalds case XFS_ITEM_SUCCESS: 4151da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_success); 4161da177e4SLinus Torvalds IOP_PUSH(lip); 4170bf6a5bdSDave Chinner ailp->xa_last_pushed_lsn = lsn; 4181da177e4SLinus Torvalds break; 4191da177e4SLinus Torvalds 4201da177e4SLinus Torvalds case XFS_ITEM_PUSHBUF: 4211da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_pushbuf); 42217b38471SChristoph Hellwig 42317b38471SChristoph Hellwig if (!IOP_PUSHBUF(lip)) { 42417b38471SChristoph Hellwig stuck++; 42517b38471SChristoph Hellwig flush_log = 1; 42617b38471SChristoph Hellwig } else { 4270bf6a5bdSDave Chinner ailp->xa_last_pushed_lsn = lsn; 42817b38471SChristoph Hellwig } 429d808f617SDave Chinner push_xfsbufd = 1; 4301da177e4SLinus Torvalds break; 4311da177e4SLinus Torvalds 4321da177e4SLinus Torvalds case XFS_ITEM_PINNED: 4331da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_pinned); 434249a8c11SDavid Chinner stuck++; 4351da177e4SLinus Torvalds flush_log = 1; 4361da177e4SLinus Torvalds break; 4371da177e4SLinus Torvalds 4381da177e4SLinus Torvalds case XFS_ITEM_LOCKED: 4391da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_locked); 440249a8c11SDavid Chinner stuck++; 4411da177e4SLinus Torvalds break; 4421da177e4SLinus Torvalds 4431da177e4SLinus Torvalds default: 4441da177e4SLinus Torvalds ASSERT(0); 4451da177e4SLinus Torvalds break; 4461da177e4SLinus Torvalds } 4471da177e4SLinus Torvalds 448c7e8f268SDavid Chinner spin_lock(&ailp->xa_lock); 449249a8c11SDavid Chinner /* should we bother continuing? */ 450249a8c11SDavid Chinner if (XFS_FORCED_SHUTDOWN(mp)) 4511da177e4SLinus Torvalds break; 452249a8c11SDavid Chinner ASSERT(mp->m_log); 4531da177e4SLinus Torvalds 454249a8c11SDavid Chinner count++; 455249a8c11SDavid Chinner 456249a8c11SDavid Chinner /* 457249a8c11SDavid Chinner * Are there too many items we can't do anything with? 458249a8c11SDavid Chinner * If we we are skipping too many items because we can't flush 459249a8c11SDavid Chinner * them or they are already being flushed, we back off and 460249a8c11SDavid Chinner * given them time to complete whatever operation is being 461249a8c11SDavid Chinner * done. i.e. remove pressure from the AIL while we can't make 462249a8c11SDavid Chinner * progress so traversals don't slow down further inserts and 463249a8c11SDavid Chinner * removals to/from the AIL. 464249a8c11SDavid Chinner * 465249a8c11SDavid Chinner * The value of 100 is an arbitrary magic number based on 466249a8c11SDavid Chinner * observation. 467249a8c11SDavid Chinner */ 468249a8c11SDavid Chinner if (stuck > 100) 469249a8c11SDavid Chinner break; 470249a8c11SDavid Chinner 471af3e4022SDave Chinner lip = xfs_trans_ail_cursor_next(ailp, &cur); 472249a8c11SDavid Chinner if (lip == NULL) 473249a8c11SDavid Chinner break; 474249a8c11SDavid Chinner lsn = lip->li_lsn; 4751da177e4SLinus Torvalds } 476af3e4022SDave Chinner xfs_trans_ail_cursor_done(ailp, &cur); 477c7e8f268SDavid Chinner spin_unlock(&ailp->xa_lock); 4781da177e4SLinus Torvalds 4791da177e4SLinus Torvalds if (flush_log) { 4801da177e4SLinus Torvalds /* 4811da177e4SLinus Torvalds * If something we need to push out was pinned, then 4821da177e4SLinus Torvalds * push out the log so it will become unpinned and 4831da177e4SLinus Torvalds * move forward in the AIL. 4841da177e4SLinus Torvalds */ 4851da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_flush); 486a14a348bSChristoph Hellwig xfs_log_force(mp, 0); 4871da177e4SLinus Torvalds } 4881da177e4SLinus Torvalds 489d808f617SDave Chinner if (push_xfsbufd) { 490d808f617SDave Chinner /* we've got delayed write buffers to flush */ 491d808f617SDave Chinner wake_up_process(mp->m_ddev_targp->bt_task); 492d808f617SDave Chinner } 493d808f617SDave Chinner 4940bf6a5bdSDave Chinner /* assume we have more work to do in a short while */ 4959e7004e7SDave Chinner out_done: 49692d9cd10SDavid Chinner if (!count) { 49792d9cd10SDavid Chinner /* We're past our target or empty, so idle */ 4980bf6a5bdSDave Chinner ailp->xa_last_pushed_lsn = 0; 4990bf6a5bdSDave Chinner 5000bf6a5bdSDave Chinner tout = 50; 50192d9cd10SDavid Chinner } else if (XFS_LSN_CMP(lsn, target) >= 0) { 502249a8c11SDavid Chinner /* 50392d9cd10SDavid Chinner * We reached the target so wait a bit longer for I/O to 50492d9cd10SDavid Chinner * complete and remove pushed items from the AIL before we 50592d9cd10SDavid Chinner * start the next scan from the start of the AIL. 506249a8c11SDavid Chinner */ 507453eac8aSDave Chinner tout = 50; 5080bf6a5bdSDave Chinner ailp->xa_last_pushed_lsn = 0; 50927d8d5feSDavid Chinner } else if ((stuck * 100) / count > 90) { 510249a8c11SDavid Chinner /* 511249a8c11SDavid Chinner * Either there is a lot of contention on the AIL or we 512249a8c11SDavid Chinner * are stuck due to operations in progress. "Stuck" in this 513249a8c11SDavid Chinner * case is defined as >90% of the items we tried to push 514249a8c11SDavid Chinner * were stuck. 515249a8c11SDavid Chinner * 516249a8c11SDavid Chinner * Backoff a bit more to allow some I/O to complete before 517249a8c11SDavid Chinner * continuing from where we were. 518249a8c11SDavid Chinner */ 519453eac8aSDave Chinner tout = 20; 520453eac8aSDave Chinner } 5211da177e4SLinus Torvalds 5220030807cSChristoph Hellwig return tout; 5230030807cSChristoph Hellwig } 5240030807cSChristoph Hellwig 5250030807cSChristoph Hellwig static int 5260030807cSChristoph Hellwig xfsaild( 5270030807cSChristoph Hellwig void *data) 5280030807cSChristoph Hellwig { 5290030807cSChristoph Hellwig struct xfs_ail *ailp = data; 5300030807cSChristoph Hellwig long tout = 0; /* milliseconds */ 5310030807cSChristoph Hellwig 5320030807cSChristoph Hellwig while (!kthread_should_stop()) { 5330030807cSChristoph Hellwig if (tout && tout <= 20) 5340030807cSChristoph Hellwig __set_current_state(TASK_KILLABLE); 5350030807cSChristoph Hellwig else 5360030807cSChristoph Hellwig __set_current_state(TASK_INTERRUPTIBLE); 5370030807cSChristoph Hellwig schedule_timeout(tout ? 5380030807cSChristoph Hellwig msecs_to_jiffies(tout) : MAX_SCHEDULE_TIMEOUT); 5390030807cSChristoph Hellwig 5400030807cSChristoph Hellwig try_to_freeze(); 5410030807cSChristoph Hellwig 5420030807cSChristoph Hellwig tout = xfsaild_push(ailp); 5430030807cSChristoph Hellwig } 5440030807cSChristoph Hellwig 5450030807cSChristoph Hellwig return 0; 5460bf6a5bdSDave Chinner } 5470bf6a5bdSDave Chinner 5480bf6a5bdSDave Chinner /* 5490bf6a5bdSDave Chinner * This routine is called to move the tail of the AIL forward. It does this by 5500bf6a5bdSDave Chinner * trying to flush items in the AIL whose lsns are below the given 5510bf6a5bdSDave Chinner * threshold_lsn. 5520bf6a5bdSDave Chinner * 5530bf6a5bdSDave Chinner * The push is run asynchronously in a workqueue, which means the caller needs 5540bf6a5bdSDave Chinner * to handle waiting on the async flush for space to become available. 5550bf6a5bdSDave Chinner * We don't want to interrupt any push that is in progress, hence we only queue 5560bf6a5bdSDave Chinner * work if we set the pushing bit approriately. 5570bf6a5bdSDave Chinner * 5580bf6a5bdSDave Chinner * We do this unlocked - we only need to know whether there is anything in the 5590bf6a5bdSDave Chinner * AIL at the time we are called. We don't need to access the contents of 5600bf6a5bdSDave Chinner * any of the objects, so the lock is not needed. 5610bf6a5bdSDave Chinner */ 5620bf6a5bdSDave Chinner void 563fd074841SDave Chinner xfs_ail_push( 5640bf6a5bdSDave Chinner struct xfs_ail *ailp, 5650bf6a5bdSDave Chinner xfs_lsn_t threshold_lsn) 5660bf6a5bdSDave Chinner { 5670bf6a5bdSDave Chinner xfs_log_item_t *lip; 5680bf6a5bdSDave Chinner 5690bf6a5bdSDave Chinner lip = xfs_ail_min(ailp); 5700bf6a5bdSDave Chinner if (!lip || XFS_FORCED_SHUTDOWN(ailp->xa_mount) || 5710bf6a5bdSDave Chinner XFS_LSN_CMP(threshold_lsn, ailp->xa_target) <= 0) 5720bf6a5bdSDave Chinner return; 5730bf6a5bdSDave Chinner 5740bf6a5bdSDave Chinner /* 5750bf6a5bdSDave Chinner * Ensure that the new target is noticed in push code before it clears 5760bf6a5bdSDave Chinner * the XFS_AIL_PUSHING_BIT. 5770bf6a5bdSDave Chinner */ 5780bf6a5bdSDave Chinner smp_wmb(); 579fe0da767SDave Chinner xfs_trans_ail_copy_lsn(ailp, &ailp->xa_target, &threshold_lsn); 5800030807cSChristoph Hellwig smp_wmb(); 5810030807cSChristoph Hellwig 5820030807cSChristoph Hellwig wake_up_process(ailp->xa_task); 5830bf6a5bdSDave Chinner } 5841da177e4SLinus Torvalds 5851da177e4SLinus Torvalds /* 586fd074841SDave Chinner * Push out all items in the AIL immediately 587fd074841SDave Chinner */ 588fd074841SDave Chinner void 589fd074841SDave Chinner xfs_ail_push_all( 590fd074841SDave Chinner struct xfs_ail *ailp) 591fd074841SDave Chinner { 592fd074841SDave Chinner xfs_lsn_t threshold_lsn = xfs_ail_max_lsn(ailp); 593fd074841SDave Chinner 594fd074841SDave Chinner if (threshold_lsn) 595fd074841SDave Chinner xfs_ail_push(ailp, threshold_lsn); 596fd074841SDave Chinner } 597fd074841SDave Chinner 598fd074841SDave Chinner /* 5991da177e4SLinus Torvalds * This is to be called when an item is unlocked that may have 6001da177e4SLinus Torvalds * been in the AIL. It will wake up the first member of the AIL 6011da177e4SLinus Torvalds * wait list if this item's unlocking might allow it to progress. 6021da177e4SLinus Torvalds * If the item is in the AIL, then we need to get the AIL lock 6031da177e4SLinus Torvalds * while doing our checking so we don't race with someone going 6041da177e4SLinus Torvalds * to sleep waiting for this event in xfs_trans_push_ail(). 6051da177e4SLinus Torvalds */ 6061da177e4SLinus Torvalds void 6071da177e4SLinus Torvalds xfs_trans_unlocked_item( 608783a2f65SDavid Chinner struct xfs_ail *ailp, 6091da177e4SLinus Torvalds xfs_log_item_t *lip) 6101da177e4SLinus Torvalds { 6111da177e4SLinus Torvalds xfs_log_item_t *min_lip; 6121da177e4SLinus Torvalds 6131da177e4SLinus Torvalds /* 6141da177e4SLinus Torvalds * If we're forcibly shutting down, we may have 6151da177e4SLinus Torvalds * unlocked log items arbitrarily. The last thing 6161da177e4SLinus Torvalds * we want to do is to move the tail of the log 6171da177e4SLinus Torvalds * over some potentially valid data. 6181da177e4SLinus Torvalds */ 6191da177e4SLinus Torvalds if (!(lip->li_flags & XFS_LI_IN_AIL) || 620783a2f65SDavid Chinner XFS_FORCED_SHUTDOWN(ailp->xa_mount)) { 6211da177e4SLinus Torvalds return; 6221da177e4SLinus Torvalds } 6231da177e4SLinus Torvalds 6241da177e4SLinus Torvalds /* 6251da177e4SLinus Torvalds * This is the one case where we can call into xfs_ail_min() 6261da177e4SLinus Torvalds * without holding the AIL lock because we only care about the 6271da177e4SLinus Torvalds * case where we are at the tail of the AIL. If the object isn't 6281da177e4SLinus Torvalds * at the tail, it doesn't matter what result we get back. This 6291da177e4SLinus Torvalds * is slightly racy because since we were just unlocked, we could 6301da177e4SLinus Torvalds * go to sleep between the call to xfs_ail_min and the call to 6311da177e4SLinus Torvalds * xfs_log_move_tail, have someone else lock us, commit to us disk, 6321da177e4SLinus Torvalds * move us out of the tail of the AIL, and then we wake up. However, 6331da177e4SLinus Torvalds * the call to xfs_log_move_tail() doesn't do anything if there's 6341da177e4SLinus Torvalds * not enough free space to wake people up so we're safe calling it. 6351da177e4SLinus Torvalds */ 636783a2f65SDavid Chinner min_lip = xfs_ail_min(ailp); 6371da177e4SLinus Torvalds 6381da177e4SLinus Torvalds if (min_lip == lip) 639783a2f65SDavid Chinner xfs_log_move_tail(ailp->xa_mount, 1); 6401da177e4SLinus Torvalds } /* xfs_trans_unlocked_item */ 6411da177e4SLinus Torvalds 6421da177e4SLinus Torvalds /* 6430e57f6a3SDave Chinner * xfs_trans_ail_update - bulk AIL insertion operation. 6440e57f6a3SDave Chinner * 6450e57f6a3SDave Chinner * @xfs_trans_ail_update takes an array of log items that all need to be 6460e57f6a3SDave Chinner * positioned at the same LSN in the AIL. If an item is not in the AIL, it will 6470e57f6a3SDave Chinner * be added. Otherwise, it will be repositioned by removing it and re-adding 6480e57f6a3SDave Chinner * it to the AIL. If we move the first item in the AIL, update the log tail to 6490e57f6a3SDave Chinner * match the new minimum LSN in the AIL. 6500e57f6a3SDave Chinner * 6510e57f6a3SDave Chinner * This function takes the AIL lock once to execute the update operations on 6520e57f6a3SDave Chinner * all the items in the array, and as such should not be called with the AIL 6530e57f6a3SDave Chinner * lock held. As a result, once we have the AIL lock, we need to check each log 6540e57f6a3SDave Chinner * item LSN to confirm it needs to be moved forward in the AIL. 6550e57f6a3SDave Chinner * 6560e57f6a3SDave Chinner * To optimise the insert operation, we delete all the items from the AIL in 6570e57f6a3SDave Chinner * the first pass, moving them into a temporary list, then splice the temporary 6580e57f6a3SDave Chinner * list into the correct position in the AIL. This avoids needing to do an 6590e57f6a3SDave Chinner * insert operation on every item. 6600e57f6a3SDave Chinner * 6610e57f6a3SDave Chinner * This function must be called with the AIL lock held. The lock is dropped 6620e57f6a3SDave Chinner * before returning. 6630e57f6a3SDave Chinner */ 6640e57f6a3SDave Chinner void 6650e57f6a3SDave Chinner xfs_trans_ail_update_bulk( 6660e57f6a3SDave Chinner struct xfs_ail *ailp, 6671d8c95a3SDave Chinner struct xfs_ail_cursor *cur, 6680e57f6a3SDave Chinner struct xfs_log_item **log_items, 6690e57f6a3SDave Chinner int nr_items, 6700e57f6a3SDave Chinner xfs_lsn_t lsn) __releases(ailp->xa_lock) 6710e57f6a3SDave Chinner { 6720e57f6a3SDave Chinner xfs_log_item_t *mlip; 6730e57f6a3SDave Chinner xfs_lsn_t tail_lsn; 6740e57f6a3SDave Chinner int mlip_changed = 0; 6750e57f6a3SDave Chinner int i; 6760e57f6a3SDave Chinner LIST_HEAD(tmp); 6770e57f6a3SDave Chinner 678e44f4112SAlex Elder ASSERT(nr_items > 0); /* Not required, but true. */ 6790e57f6a3SDave Chinner mlip = xfs_ail_min(ailp); 6800e57f6a3SDave Chinner 6810e57f6a3SDave Chinner for (i = 0; i < nr_items; i++) { 6820e57f6a3SDave Chinner struct xfs_log_item *lip = log_items[i]; 6830e57f6a3SDave Chinner if (lip->li_flags & XFS_LI_IN_AIL) { 6840e57f6a3SDave Chinner /* check if we really need to move the item */ 6850e57f6a3SDave Chinner if (XFS_LSN_CMP(lsn, lip->li_lsn) <= 0) 6860e57f6a3SDave Chinner continue; 6870e57f6a3SDave Chinner 6880e57f6a3SDave Chinner xfs_ail_delete(ailp, lip); 6890e57f6a3SDave Chinner if (mlip == lip) 6900e57f6a3SDave Chinner mlip_changed = 1; 6910e57f6a3SDave Chinner } else { 6920e57f6a3SDave Chinner lip->li_flags |= XFS_LI_IN_AIL; 6930e57f6a3SDave Chinner } 6940e57f6a3SDave Chinner lip->li_lsn = lsn; 6950e57f6a3SDave Chinner list_add(&lip->li_ail, &tmp); 6960e57f6a3SDave Chinner } 6970e57f6a3SDave Chinner 698e44f4112SAlex Elder if (!list_empty(&tmp)) 6991d8c95a3SDave Chinner xfs_ail_splice(ailp, cur, &tmp, lsn); 7000e57f6a3SDave Chinner 7010e57f6a3SDave Chinner if (!mlip_changed) { 7020e57f6a3SDave Chinner spin_unlock(&ailp->xa_lock); 7030e57f6a3SDave Chinner return; 7040e57f6a3SDave Chinner } 7050e57f6a3SDave Chinner 7060e57f6a3SDave Chinner /* 7070e57f6a3SDave Chinner * It is not safe to access mlip after the AIL lock is dropped, so we 7080e57f6a3SDave Chinner * must get a copy of li_lsn before we do so. This is especially 7090e57f6a3SDave Chinner * important on 32-bit platforms where accessing and updating 64-bit 7100e57f6a3SDave Chinner * values like li_lsn is not atomic. 7110e57f6a3SDave Chinner */ 7120e57f6a3SDave Chinner mlip = xfs_ail_min(ailp); 7130e57f6a3SDave Chinner tail_lsn = mlip->li_lsn; 7140e57f6a3SDave Chinner spin_unlock(&ailp->xa_lock); 7150e57f6a3SDave Chinner xfs_log_move_tail(ailp->xa_mount, tail_lsn); 7160e57f6a3SDave Chinner } 7170e57f6a3SDave Chinner 7180e57f6a3SDave Chinner /* 71930136832SDave Chinner * xfs_trans_ail_delete_bulk - remove multiple log items from the AIL 72030136832SDave Chinner * 72130136832SDave Chinner * @xfs_trans_ail_delete_bulk takes an array of log items that all need to 72230136832SDave Chinner * removed from the AIL. The caller is already holding the AIL lock, and done 72330136832SDave Chinner * all the checks necessary to ensure the items passed in via @log_items are 72430136832SDave Chinner * ready for deletion. This includes checking that the items are in the AIL. 72530136832SDave Chinner * 72630136832SDave Chinner * For each log item to be removed, unlink it from the AIL, clear the IN_AIL 72730136832SDave Chinner * flag from the item and reset the item's lsn to 0. If we remove the first 72830136832SDave Chinner * item in the AIL, update the log tail to match the new minimum LSN in the 72930136832SDave Chinner * AIL. 73030136832SDave Chinner * 73130136832SDave Chinner * This function will not drop the AIL lock until all items are removed from 73230136832SDave Chinner * the AIL to minimise the amount of lock traffic on the AIL. This does not 73330136832SDave Chinner * greatly increase the AIL hold time, but does significantly reduce the amount 73430136832SDave Chinner * of traffic on the lock, especially during IO completion. 73530136832SDave Chinner * 73630136832SDave Chinner * This function must be called with the AIL lock held. The lock is dropped 73730136832SDave Chinner * before returning. 73830136832SDave Chinner */ 73930136832SDave Chinner void 74030136832SDave Chinner xfs_trans_ail_delete_bulk( 74130136832SDave Chinner struct xfs_ail *ailp, 74230136832SDave Chinner struct xfs_log_item **log_items, 74330136832SDave Chinner int nr_items) __releases(ailp->xa_lock) 74430136832SDave Chinner { 74530136832SDave Chinner xfs_log_item_t *mlip; 74630136832SDave Chinner xfs_lsn_t tail_lsn; 74730136832SDave Chinner int mlip_changed = 0; 74830136832SDave Chinner int i; 74930136832SDave Chinner 75030136832SDave Chinner mlip = xfs_ail_min(ailp); 75130136832SDave Chinner 75230136832SDave Chinner for (i = 0; i < nr_items; i++) { 75330136832SDave Chinner struct xfs_log_item *lip = log_items[i]; 75430136832SDave Chinner if (!(lip->li_flags & XFS_LI_IN_AIL)) { 75530136832SDave Chinner struct xfs_mount *mp = ailp->xa_mount; 75630136832SDave Chinner 75730136832SDave Chinner spin_unlock(&ailp->xa_lock); 75830136832SDave Chinner if (!XFS_FORCED_SHUTDOWN(mp)) { 7596a19d939SDave Chinner xfs_alert_tag(mp, XFS_PTAG_AILDELETE, 76030136832SDave Chinner "%s: attempting to delete a log item that is not in the AIL", 76130136832SDave Chinner __func__); 76230136832SDave Chinner xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); 76330136832SDave Chinner } 76430136832SDave Chinner return; 76530136832SDave Chinner } 76630136832SDave Chinner 76730136832SDave Chinner xfs_ail_delete(ailp, lip); 76830136832SDave Chinner lip->li_flags &= ~XFS_LI_IN_AIL; 76930136832SDave Chinner lip->li_lsn = 0; 77030136832SDave Chinner if (mlip == lip) 77130136832SDave Chinner mlip_changed = 1; 77230136832SDave Chinner } 77330136832SDave Chinner 77430136832SDave Chinner if (!mlip_changed) { 77530136832SDave Chinner spin_unlock(&ailp->xa_lock); 77630136832SDave Chinner return; 77730136832SDave Chinner } 77830136832SDave Chinner 77930136832SDave Chinner /* 78030136832SDave Chinner * It is not safe to access mlip after the AIL lock is dropped, so we 78130136832SDave Chinner * must get a copy of li_lsn before we do so. This is especially 78230136832SDave Chinner * important on 32-bit platforms where accessing and updating 64-bit 78330136832SDave Chinner * values like li_lsn is not atomic. It is possible we've emptied the 78430136832SDave Chinner * AIL here, so if that is the case, pass an LSN of 0 to the tail move. 78530136832SDave Chinner */ 78630136832SDave Chinner mlip = xfs_ail_min(ailp); 78730136832SDave Chinner tail_lsn = mlip ? mlip->li_lsn : 0; 78830136832SDave Chinner spin_unlock(&ailp->xa_lock); 78930136832SDave Chinner xfs_log_move_tail(ailp->xa_mount, tail_lsn); 79030136832SDave Chinner } 7911da177e4SLinus Torvalds 7921da177e4SLinus Torvalds /* 7931da177e4SLinus Torvalds * The active item list (AIL) is a doubly linked list of log 7941da177e4SLinus Torvalds * items sorted by ascending lsn. The base of the list is 7951da177e4SLinus Torvalds * a forw/back pointer pair embedded in the xfs mount structure. 7961da177e4SLinus Torvalds * The base is initialized with both pointers pointing to the 7971da177e4SLinus Torvalds * base. This case always needs to be distinguished, because 7981da177e4SLinus Torvalds * the base has no lsn to look at. We almost always insert 7991da177e4SLinus Torvalds * at the end of the list, so on inserts we search from the 8001da177e4SLinus Torvalds * end of the list to find where the new item belongs. 8011da177e4SLinus Torvalds */ 8021da177e4SLinus Torvalds 8031da177e4SLinus Torvalds /* 8041da177e4SLinus Torvalds * Initialize the doubly linked list to point only to itself. 8051da177e4SLinus Torvalds */ 806249a8c11SDavid Chinner int 8071da177e4SLinus Torvalds xfs_trans_ail_init( 8081da177e4SLinus Torvalds xfs_mount_t *mp) 8091da177e4SLinus Torvalds { 81082fa9012SDavid Chinner struct xfs_ail *ailp; 81182fa9012SDavid Chinner 81282fa9012SDavid Chinner ailp = kmem_zalloc(sizeof(struct xfs_ail), KM_MAYFAIL); 81382fa9012SDavid Chinner if (!ailp) 81482fa9012SDavid Chinner return ENOMEM; 81582fa9012SDavid Chinner 81682fa9012SDavid Chinner ailp->xa_mount = mp; 81782fa9012SDavid Chinner INIT_LIST_HEAD(&ailp->xa_ail); 818af3e4022SDave Chinner INIT_LIST_HEAD(&ailp->xa_cursors); 819c7e8f268SDavid Chinner spin_lock_init(&ailp->xa_lock); 8200030807cSChristoph Hellwig 8210030807cSChristoph Hellwig ailp->xa_task = kthread_run(xfsaild, ailp, "xfsaild/%s", 8220030807cSChristoph Hellwig ailp->xa_mount->m_fsname); 8230030807cSChristoph Hellwig if (IS_ERR(ailp->xa_task)) 8240030807cSChristoph Hellwig goto out_free_ailp; 8250030807cSChristoph Hellwig 82627d8d5feSDavid Chinner mp->m_ail = ailp; 82727d8d5feSDavid Chinner return 0; 8280030807cSChristoph Hellwig 8290030807cSChristoph Hellwig out_free_ailp: 8300030807cSChristoph Hellwig kmem_free(ailp); 8310030807cSChristoph Hellwig return ENOMEM; 832249a8c11SDavid Chinner } 833249a8c11SDavid Chinner 834249a8c11SDavid Chinner void 835249a8c11SDavid Chinner xfs_trans_ail_destroy( 836249a8c11SDavid Chinner xfs_mount_t *mp) 837249a8c11SDavid Chinner { 83882fa9012SDavid Chinner struct xfs_ail *ailp = mp->m_ail; 83982fa9012SDavid Chinner 8400030807cSChristoph Hellwig kthread_stop(ailp->xa_task); 84182fa9012SDavid Chinner kmem_free(ailp); 8421da177e4SLinus Torvalds } 843