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" 299e4c109aSChristoph Hellwig #include "xfs_trace.h" 301da177e4SLinus Torvalds #include "xfs_error.h" 311da177e4SLinus Torvalds 321da177e4SLinus Torvalds #ifdef DEBUG 33cd4a3c50SDave Chinner /* 34cd4a3c50SDave Chinner * Check that the list is sorted as it should be. 35cd4a3c50SDave Chinner */ 36cd4a3c50SDave Chinner STATIC void 37cd4a3c50SDave Chinner xfs_ail_check( 38cd4a3c50SDave Chinner struct xfs_ail *ailp, 39cd4a3c50SDave Chinner xfs_log_item_t *lip) 40cd4a3c50SDave Chinner { 41cd4a3c50SDave Chinner xfs_log_item_t *prev_lip; 42cd4a3c50SDave Chinner 43cd4a3c50SDave Chinner if (list_empty(&ailp->xa_ail)) 44cd4a3c50SDave Chinner return; 45cd4a3c50SDave Chinner 46cd4a3c50SDave Chinner /* 47cd4a3c50SDave Chinner * Check the next and previous entries are valid. 48cd4a3c50SDave Chinner */ 49cd4a3c50SDave Chinner ASSERT((lip->li_flags & XFS_LI_IN_AIL) != 0); 50cd4a3c50SDave Chinner prev_lip = list_entry(lip->li_ail.prev, xfs_log_item_t, li_ail); 51cd4a3c50SDave Chinner if (&prev_lip->li_ail != &ailp->xa_ail) 52cd4a3c50SDave Chinner ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) <= 0); 53cd4a3c50SDave Chinner 54cd4a3c50SDave Chinner prev_lip = list_entry(lip->li_ail.next, xfs_log_item_t, li_ail); 55cd4a3c50SDave Chinner if (&prev_lip->li_ail != &ailp->xa_ail) 56cd4a3c50SDave Chinner ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) >= 0); 57cd4a3c50SDave Chinner 58cd4a3c50SDave Chinner 59cd4a3c50SDave Chinner #ifdef XFS_TRANS_DEBUG 60cd4a3c50SDave Chinner /* 61cd4a3c50SDave Chinner * Walk the list checking lsn ordering, and that every entry has the 62cd4a3c50SDave Chinner * XFS_LI_IN_AIL flag set. This is really expensive, so only do it 63cd4a3c50SDave Chinner * when specifically debugging the transaction subsystem. 64cd4a3c50SDave Chinner */ 65cd4a3c50SDave Chinner prev_lip = list_entry(&ailp->xa_ail, xfs_log_item_t, li_ail); 66cd4a3c50SDave Chinner list_for_each_entry(lip, &ailp->xa_ail, li_ail) { 67cd4a3c50SDave Chinner if (&prev_lip->li_ail != &ailp->xa_ail) 68cd4a3c50SDave Chinner ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) <= 0); 69cd4a3c50SDave Chinner ASSERT((lip->li_flags & XFS_LI_IN_AIL) != 0); 70cd4a3c50SDave Chinner prev_lip = lip; 71cd4a3c50SDave Chinner } 72cd4a3c50SDave Chinner #endif /* XFS_TRANS_DEBUG */ 73cd4a3c50SDave Chinner } 74cd4a3c50SDave Chinner #else /* !DEBUG */ 75de08dbc1SDavid Chinner #define xfs_ail_check(a,l) 761da177e4SLinus Torvalds #endif /* DEBUG */ 771da177e4SLinus Torvalds 78cd4a3c50SDave Chinner /* 79cd4a3c50SDave Chinner * Return a pointer to the first item in the AIL. If the AIL is empty, then 80cd4a3c50SDave Chinner * return NULL. 81cd4a3c50SDave Chinner */ 821c304625SChristoph Hellwig xfs_log_item_t * 83cd4a3c50SDave Chinner xfs_ail_min( 84cd4a3c50SDave Chinner struct xfs_ail *ailp) 85cd4a3c50SDave Chinner { 86cd4a3c50SDave Chinner if (list_empty(&ailp->xa_ail)) 87cd4a3c50SDave Chinner return NULL; 88cd4a3c50SDave Chinner 89cd4a3c50SDave Chinner return list_first_entry(&ailp->xa_ail, xfs_log_item_t, li_ail); 90cd4a3c50SDave Chinner } 911da177e4SLinus Torvalds 921da177e4SLinus Torvalds /* 93fd074841SDave Chinner * Return a pointer to the last item in the AIL. If the AIL is empty, then 94fd074841SDave Chinner * return NULL. 95fd074841SDave Chinner */ 96fd074841SDave Chinner static xfs_log_item_t * 97fd074841SDave Chinner xfs_ail_max( 98fd074841SDave Chinner struct xfs_ail *ailp) 99fd074841SDave Chinner { 100fd074841SDave Chinner if (list_empty(&ailp->xa_ail)) 101fd074841SDave Chinner return NULL; 102fd074841SDave Chinner 103fd074841SDave Chinner return list_entry(ailp->xa_ail.prev, xfs_log_item_t, li_ail); 104fd074841SDave Chinner } 105fd074841SDave Chinner 106fd074841SDave Chinner /* 107cd4a3c50SDave Chinner * Return a pointer to the item which follows the given item in the AIL. If 108cd4a3c50SDave Chinner * the given item is the last item in the list, then return NULL. 109cd4a3c50SDave Chinner */ 110cd4a3c50SDave Chinner static xfs_log_item_t * 111cd4a3c50SDave Chinner xfs_ail_next( 112cd4a3c50SDave Chinner struct xfs_ail *ailp, 113cd4a3c50SDave Chinner xfs_log_item_t *lip) 114cd4a3c50SDave Chinner { 115cd4a3c50SDave Chinner if (lip->li_ail.next == &ailp->xa_ail) 116cd4a3c50SDave Chinner return NULL; 117cd4a3c50SDave Chinner 118cd4a3c50SDave Chinner return list_first_entry(&lip->li_ail, xfs_log_item_t, li_ail); 119cd4a3c50SDave Chinner } 120cd4a3c50SDave Chinner 121cd4a3c50SDave Chinner /* 122cd4a3c50SDave Chinner * This is called by the log manager code to determine the LSN of the tail of 123cd4a3c50SDave Chinner * the log. This is exactly the LSN of the first item in the AIL. If the AIL 124cd4a3c50SDave Chinner * is empty, then this function returns 0. 1251da177e4SLinus Torvalds * 126cd4a3c50SDave Chinner * We need the AIL lock in order to get a coherent read of the lsn of the last 127cd4a3c50SDave Chinner * item in the AIL. 1281da177e4SLinus Torvalds */ 1291da177e4SLinus Torvalds xfs_lsn_t 130fd074841SDave Chinner xfs_ail_min_lsn( 1315b00f14fSDavid Chinner struct xfs_ail *ailp) 1321da177e4SLinus Torvalds { 133cd4a3c50SDave Chinner xfs_lsn_t lsn = 0; 1341da177e4SLinus Torvalds xfs_log_item_t *lip; 1351da177e4SLinus Torvalds 136c7e8f268SDavid Chinner spin_lock(&ailp->xa_lock); 1375b00f14fSDavid Chinner lip = xfs_ail_min(ailp); 138cd4a3c50SDave Chinner if (lip) 1391da177e4SLinus Torvalds lsn = lip->li_lsn; 140c7e8f268SDavid Chinner spin_unlock(&ailp->xa_lock); 1411da177e4SLinus Torvalds 1421da177e4SLinus Torvalds return lsn; 1431da177e4SLinus Torvalds } 1441da177e4SLinus Torvalds 1451da177e4SLinus Torvalds /* 146fd074841SDave Chinner * Return the maximum lsn held in the AIL, or zero if the AIL is empty. 147fd074841SDave Chinner */ 148fd074841SDave Chinner static xfs_lsn_t 149fd074841SDave Chinner xfs_ail_max_lsn( 150fd074841SDave Chinner struct xfs_ail *ailp) 151fd074841SDave Chinner { 152fd074841SDave Chinner xfs_lsn_t lsn = 0; 153fd074841SDave Chinner xfs_log_item_t *lip; 154fd074841SDave Chinner 155fd074841SDave Chinner spin_lock(&ailp->xa_lock); 156fd074841SDave Chinner lip = xfs_ail_max(ailp); 157fd074841SDave Chinner if (lip) 158fd074841SDave Chinner lsn = lip->li_lsn; 159fd074841SDave Chinner spin_unlock(&ailp->xa_lock); 160fd074841SDave Chinner 161fd074841SDave Chinner return lsn; 162fd074841SDave Chinner } 163fd074841SDave Chinner 164fd074841SDave Chinner /* 165af3e4022SDave Chinner * The cursor keeps track of where our current traversal is up to by tracking 166af3e4022SDave Chinner * the next item in the list for us. However, for this to be safe, removing an 167af3e4022SDave Chinner * object from the AIL needs to invalidate any cursor that points to it. hence 168af3e4022SDave Chinner * the traversal cursor needs to be linked to the struct xfs_ail so that 169af3e4022SDave Chinner * deletion can search all the active cursors for invalidation. 17027d8d5feSDavid Chinner */ 1715b00f14fSDavid Chinner STATIC void 17227d8d5feSDavid Chinner xfs_trans_ail_cursor_init( 17327d8d5feSDavid Chinner struct xfs_ail *ailp, 17427d8d5feSDavid Chinner struct xfs_ail_cursor *cur) 17527d8d5feSDavid Chinner { 17627d8d5feSDavid Chinner cur->item = NULL; 177af3e4022SDave Chinner list_add_tail(&cur->list, &ailp->xa_cursors); 17827d8d5feSDavid Chinner } 17927d8d5feSDavid Chinner 18027d8d5feSDavid Chinner /* 181af3e4022SDave Chinner * Get the next item in the traversal and advance the cursor. If the cursor 182af3e4022SDave Chinner * was invalidated (indicated by a lip of 1), restart the traversal. 18327d8d5feSDavid Chinner */ 1845b00f14fSDavid Chinner struct xfs_log_item * 18527d8d5feSDavid Chinner xfs_trans_ail_cursor_next( 18627d8d5feSDavid Chinner struct xfs_ail *ailp, 18727d8d5feSDavid Chinner struct xfs_ail_cursor *cur) 18827d8d5feSDavid Chinner { 18927d8d5feSDavid Chinner struct xfs_log_item *lip = cur->item; 19027d8d5feSDavid Chinner 19127d8d5feSDavid Chinner if ((__psint_t)lip & 1) 19227d8d5feSDavid Chinner lip = xfs_ail_min(ailp); 19316b59029SDave Chinner if (lip) 19416b59029SDave Chinner cur->item = xfs_ail_next(ailp, lip); 19527d8d5feSDavid Chinner return lip; 19627d8d5feSDavid Chinner } 19727d8d5feSDavid Chinner 19827d8d5feSDavid Chinner /* 199af3e4022SDave Chinner * When the traversal is complete, we need to remove the cursor from the list 200af3e4022SDave Chinner * of traversing cursors. 20127d8d5feSDavid Chinner */ 20227d8d5feSDavid Chinner void 20327d8d5feSDavid Chinner xfs_trans_ail_cursor_done( 20427d8d5feSDavid Chinner struct xfs_ail *ailp, 205af3e4022SDave Chinner struct xfs_ail_cursor *cur) 20627d8d5feSDavid Chinner { 207af3e4022SDave Chinner cur->item = NULL; 208af3e4022SDave Chinner list_del_init(&cur->list); 20927d8d5feSDavid Chinner } 21027d8d5feSDavid Chinner 21127d8d5feSDavid Chinner /* 212af3e4022SDave Chinner * Invalidate any cursor that is pointing to this item. This is called when an 213af3e4022SDave Chinner * item is removed from the AIL. Any cursor pointing to this object is now 214af3e4022SDave Chinner * invalid and the traversal needs to be terminated so it doesn't reference a 215af3e4022SDave Chinner * freed object. We set the low bit of the cursor item pointer so we can 216af3e4022SDave Chinner * distinguish between an invalidation and the end of the list when getting the 217af3e4022SDave Chinner * next item from the cursor. 2185b00f14fSDavid Chinner */ 2195b00f14fSDavid Chinner STATIC void 2205b00f14fSDavid Chinner xfs_trans_ail_cursor_clear( 2215b00f14fSDavid Chinner struct xfs_ail *ailp, 2225b00f14fSDavid Chinner struct xfs_log_item *lip) 2235b00f14fSDavid Chinner { 2245b00f14fSDavid Chinner struct xfs_ail_cursor *cur; 2255b00f14fSDavid Chinner 226af3e4022SDave Chinner list_for_each_entry(cur, &ailp->xa_cursors, list) { 2275b00f14fSDavid Chinner if (cur->item == lip) 2285b00f14fSDavid Chinner cur->item = (struct xfs_log_item *) 2295b00f14fSDavid Chinner ((__psint_t)cur->item | 1); 2305b00f14fSDavid Chinner } 2315b00f14fSDavid Chinner } 2325b00f14fSDavid Chinner 2335b00f14fSDavid Chinner /* 23416b59029SDave Chinner * Find the first item in the AIL with the given @lsn by searching in ascending 23516b59029SDave Chinner * LSN order and initialise the cursor to point to the next item for a 23616b59029SDave Chinner * ascending traversal. Pass a @lsn of zero to initialise the cursor to the 23716b59029SDave Chinner * first item in the AIL. Returns NULL if the list is empty. 238249a8c11SDavid Chinner */ 2395b00f14fSDavid Chinner xfs_log_item_t * 2405b00f14fSDavid Chinner xfs_trans_ail_cursor_first( 24127d8d5feSDavid Chinner struct xfs_ail *ailp, 24227d8d5feSDavid Chinner struct xfs_ail_cursor *cur, 243249a8c11SDavid Chinner xfs_lsn_t lsn) 244249a8c11SDavid Chinner { 245249a8c11SDavid Chinner xfs_log_item_t *lip; 246249a8c11SDavid Chinner 2475b00f14fSDavid Chinner xfs_trans_ail_cursor_init(ailp, cur); 24816b59029SDave Chinner 24916b59029SDave Chinner if (lsn == 0) { 25027d8d5feSDavid Chinner lip = xfs_ail_min(ailp); 2515b00f14fSDavid Chinner goto out; 25216b59029SDave Chinner } 253249a8c11SDavid Chinner 25427d8d5feSDavid Chinner list_for_each_entry(lip, &ailp->xa_ail, li_ail) { 2555b00f14fSDavid Chinner if (XFS_LSN_CMP(lip->li_lsn, lsn) >= 0) 2567ee49acfSDavid Chinner goto out; 2575b00f14fSDavid Chinner } 25816b59029SDave Chinner return NULL; 25916b59029SDave Chinner 2605b00f14fSDavid Chinner out: 26116b59029SDave Chinner if (lip) 26216b59029SDave Chinner cur->item = xfs_ail_next(ailp, lip); 263249a8c11SDavid Chinner return lip; 264249a8c11SDavid Chinner } 265535f6b37SJosef 'Jeff' Sipek 2661d8c95a3SDave Chinner static struct xfs_log_item * 2671d8c95a3SDave Chinner __xfs_trans_ail_cursor_last( 2681d8c95a3SDave Chinner struct xfs_ail *ailp, 2691d8c95a3SDave Chinner xfs_lsn_t lsn) 2701d8c95a3SDave Chinner { 2711d8c95a3SDave Chinner xfs_log_item_t *lip; 2721d8c95a3SDave Chinner 2731d8c95a3SDave Chinner list_for_each_entry_reverse(lip, &ailp->xa_ail, li_ail) { 2741d8c95a3SDave Chinner if (XFS_LSN_CMP(lip->li_lsn, lsn) <= 0) 2751d8c95a3SDave Chinner return lip; 2761d8c95a3SDave Chinner } 2771d8c95a3SDave Chinner return NULL; 2781d8c95a3SDave Chinner } 2791d8c95a3SDave Chinner 2801d8c95a3SDave Chinner /* 28116b59029SDave Chinner * Find the last item in the AIL with the given @lsn by searching in descending 28216b59029SDave Chinner * LSN order and initialise the cursor to point to that item. If there is no 28316b59029SDave Chinner * item with the value of @lsn, then it sets the cursor to the last item with an 28416b59029SDave Chinner * LSN lower than @lsn. Returns NULL if the list is empty. 2851d8c95a3SDave Chinner */ 2861d8c95a3SDave Chinner struct xfs_log_item * 2871d8c95a3SDave Chinner xfs_trans_ail_cursor_last( 2881d8c95a3SDave Chinner struct xfs_ail *ailp, 2891d8c95a3SDave Chinner struct xfs_ail_cursor *cur, 2901d8c95a3SDave Chinner xfs_lsn_t lsn) 2911d8c95a3SDave Chinner { 2921d8c95a3SDave Chinner xfs_trans_ail_cursor_init(ailp, cur); 2931d8c95a3SDave Chinner cur->item = __xfs_trans_ail_cursor_last(ailp, lsn); 2941d8c95a3SDave Chinner return cur->item; 2951d8c95a3SDave Chinner } 2961d8c95a3SDave Chinner 2971d8c95a3SDave Chinner /* 29816b59029SDave Chinner * Splice the log item list into the AIL at the given LSN. We splice to the 2991d8c95a3SDave Chinner * tail of the given LSN to maintain insert order for push traversals. The 3001d8c95a3SDave Chinner * cursor is optional, allowing repeated updates to the same LSN to avoid 301e44f4112SAlex Elder * repeated traversals. This should not be called with an empty list. 302cd4a3c50SDave Chinner */ 303cd4a3c50SDave Chinner static void 304cd4a3c50SDave Chinner xfs_ail_splice( 305cd4a3c50SDave Chinner struct xfs_ail *ailp, 3061d8c95a3SDave Chinner struct xfs_ail_cursor *cur, 307cd4a3c50SDave Chinner struct list_head *list, 308cd4a3c50SDave Chinner xfs_lsn_t lsn) 309cd4a3c50SDave Chinner { 310e44f4112SAlex Elder struct xfs_log_item *lip; 311e44f4112SAlex Elder 312e44f4112SAlex Elder ASSERT(!list_empty(list)); 313cd4a3c50SDave Chinner 3141d8c95a3SDave Chinner /* 315e44f4112SAlex Elder * Use the cursor to determine the insertion point if one is 316e44f4112SAlex Elder * provided. If not, or if the one we got is not valid, 317e44f4112SAlex Elder * find the place in the AIL where the items belong. 3181d8c95a3SDave Chinner */ 319e44f4112SAlex Elder lip = cur ? cur->item : NULL; 320e44f4112SAlex Elder if (!lip || (__psint_t) lip & 1) 3211d8c95a3SDave Chinner lip = __xfs_trans_ail_cursor_last(ailp, lsn); 3221d8c95a3SDave Chinner 323e44f4112SAlex Elder /* 324e44f4112SAlex Elder * If a cursor is provided, we know we're processing the AIL 325e44f4112SAlex Elder * in lsn order, and future items to be spliced in will 326e44f4112SAlex Elder * follow the last one being inserted now. Update the 327e44f4112SAlex Elder * cursor to point to that last item, now while we have a 328e44f4112SAlex Elder * reliable pointer to it. 329e44f4112SAlex Elder */ 3301d8c95a3SDave Chinner if (cur) 331e44f4112SAlex Elder cur->item = list_entry(list->prev, struct xfs_log_item, li_ail); 332cd4a3c50SDave Chinner 3331d8c95a3SDave Chinner /* 334e44f4112SAlex Elder * Finally perform the splice. Unless the AIL was empty, 335e44f4112SAlex Elder * lip points to the item in the AIL _after_ which the new 336e44f4112SAlex Elder * items should go. If lip is null the AIL was empty, so 337e44f4112SAlex Elder * the new items go at the head of the AIL. 3381d8c95a3SDave Chinner */ 339e44f4112SAlex Elder if (lip) 3401d8c95a3SDave Chinner list_splice(list, &lip->li_ail); 341e44f4112SAlex Elder else 342e44f4112SAlex Elder list_splice(list, &ailp->xa_ail); 343cd4a3c50SDave Chinner } 344cd4a3c50SDave Chinner 345cd4a3c50SDave Chinner /* 346cd4a3c50SDave Chinner * Delete the given item from the AIL. Return a pointer to the item. 347cd4a3c50SDave Chinner */ 348cd4a3c50SDave Chinner static void 349cd4a3c50SDave Chinner xfs_ail_delete( 350cd4a3c50SDave Chinner struct xfs_ail *ailp, 351cd4a3c50SDave Chinner xfs_log_item_t *lip) 352cd4a3c50SDave Chinner { 353cd4a3c50SDave Chinner xfs_ail_check(ailp, lip); 354cd4a3c50SDave Chinner list_del(&lip->li_ail); 355cd4a3c50SDave Chinner xfs_trans_ail_cursor_clear(ailp, lip); 356cd4a3c50SDave Chinner } 357cd4a3c50SDave Chinner 3580030807cSChristoph Hellwig static long 3590030807cSChristoph Hellwig xfsaild_push( 3600030807cSChristoph Hellwig struct xfs_ail *ailp) 361249a8c11SDavid Chinner { 36282fa9012SDavid Chinner xfs_mount_t *mp = ailp->xa_mount; 363af3e4022SDave Chinner struct xfs_ail_cursor cur; 3649e7004e7SDave Chinner xfs_log_item_t *lip; 3659e7004e7SDave Chinner xfs_lsn_t lsn; 366fe0da767SDave Chinner xfs_lsn_t target; 36743ff2122SChristoph Hellwig long tout; 3689e7004e7SDave Chinner int stuck = 0; 36943ff2122SChristoph Hellwig int flushing = 0; 3709e7004e7SDave Chinner int count = 0; 3711da177e4SLinus Torvalds 372670ce93fSDave Chinner /* 37343ff2122SChristoph Hellwig * If we encountered pinned items or did not finish writing out all 37443ff2122SChristoph Hellwig * buffers the last time we ran, force the log first and wait for it 37543ff2122SChristoph Hellwig * before pushing again. 376670ce93fSDave Chinner */ 37743ff2122SChristoph Hellwig if (ailp->xa_log_flush && ailp->xa_last_pushed_lsn == 0 && 37843ff2122SChristoph Hellwig (!list_empty_careful(&ailp->xa_buf_list) || 37943ff2122SChristoph Hellwig xfs_ail_min_lsn(ailp))) { 380670ce93fSDave Chinner ailp->xa_log_flush = 0; 38143ff2122SChristoph Hellwig 382670ce93fSDave Chinner XFS_STATS_INC(xs_push_ail_flush); 383670ce93fSDave Chinner xfs_log_force(mp, XFS_LOG_SYNC); 384670ce93fSDave Chinner } 385670ce93fSDave Chinner 38643ff2122SChristoph Hellwig spin_lock(&ailp->xa_lock); 387af3e4022SDave Chinner lip = xfs_trans_ail_cursor_first(ailp, &cur, ailp->xa_last_pushed_lsn); 388211e4d43SChristoph Hellwig if (!lip) { 3891da177e4SLinus Torvalds /* 39043ff2122SChristoph Hellwig * If the AIL is empty or our push has reached the end we are 39143ff2122SChristoph Hellwig * done now. 3921da177e4SLinus Torvalds */ 393af3e4022SDave Chinner xfs_trans_ail_cursor_done(ailp, &cur); 394c7e8f268SDavid Chinner spin_unlock(&ailp->xa_lock); 3959e7004e7SDave Chinner goto out_done; 3961da177e4SLinus Torvalds } 3971da177e4SLinus Torvalds 3981da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail); 3991da177e4SLinus Torvalds 400249a8c11SDavid Chinner lsn = lip->li_lsn; 401211e4d43SChristoph Hellwig target = ailp->xa_target; 40250e86686SDave Chinner while ((XFS_LSN_CMP(lip->li_lsn, target) <= 0)) { 403249a8c11SDavid Chinner int lock_result; 40443ff2122SChristoph Hellwig 405249a8c11SDavid Chinner /* 40643ff2122SChristoph Hellwig * Note that IOP_PUSH may unlock and reacquire the AIL lock. We 40743ff2122SChristoph Hellwig * rely on the AIL cursor implementation to be able to deal with 40843ff2122SChristoph Hellwig * the dropped lock. 4091da177e4SLinus Torvalds */ 41043ff2122SChristoph Hellwig lock_result = IOP_PUSH(lip, &ailp->xa_buf_list); 4111da177e4SLinus Torvalds switch (lock_result) { 4121da177e4SLinus Torvalds case XFS_ITEM_SUCCESS: 4131da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_success); 4149e4c109aSChristoph Hellwig trace_xfs_ail_push(lip); 4159e4c109aSChristoph Hellwig 4160bf6a5bdSDave Chinner ailp->xa_last_pushed_lsn = lsn; 4171da177e4SLinus Torvalds break; 4181da177e4SLinus Torvalds 41943ff2122SChristoph Hellwig case XFS_ITEM_FLUSHING: 42043ff2122SChristoph Hellwig /* 42143ff2122SChristoph Hellwig * The item or its backing buffer is already beeing 42243ff2122SChristoph Hellwig * flushed. The typical reason for that is that an 42343ff2122SChristoph Hellwig * inode buffer is locked because we already pushed the 42443ff2122SChristoph Hellwig * updates to it as part of inode clustering. 42543ff2122SChristoph Hellwig * 42643ff2122SChristoph Hellwig * We do not want to to stop flushing just because lots 42743ff2122SChristoph Hellwig * of items are already beeing flushed, but we need to 42843ff2122SChristoph Hellwig * re-try the flushing relatively soon if most of the 42943ff2122SChristoph Hellwig * AIL is beeing flushed. 43043ff2122SChristoph Hellwig */ 43143ff2122SChristoph Hellwig XFS_STATS_INC(xs_push_ail_flushing); 43243ff2122SChristoph Hellwig trace_xfs_ail_flushing(lip); 43317b38471SChristoph Hellwig 43443ff2122SChristoph Hellwig flushing++; 4350bf6a5bdSDave Chinner ailp->xa_last_pushed_lsn = lsn; 4361da177e4SLinus Torvalds break; 4371da177e4SLinus Torvalds 4381da177e4SLinus Torvalds case XFS_ITEM_PINNED: 4391da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_pinned); 4409e4c109aSChristoph Hellwig trace_xfs_ail_pinned(lip); 4419e4c109aSChristoph Hellwig 442249a8c11SDavid Chinner stuck++; 443670ce93fSDave Chinner ailp->xa_log_flush++; 4441da177e4SLinus Torvalds break; 4451da177e4SLinus Torvalds case XFS_ITEM_LOCKED: 4461da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_locked); 4479e4c109aSChristoph Hellwig trace_xfs_ail_locked(lip); 44843ff2122SChristoph Hellwig 449249a8c11SDavid Chinner stuck++; 4501da177e4SLinus Torvalds break; 4511da177e4SLinus Torvalds default: 4521da177e4SLinus Torvalds ASSERT(0); 4531da177e4SLinus Torvalds break; 4541da177e4SLinus Torvalds } 4551da177e4SLinus Torvalds 456249a8c11SDavid Chinner count++; 457249a8c11SDavid Chinner 458249a8c11SDavid Chinner /* 459249a8c11SDavid Chinner * Are there too many items we can't do anything with? 46043ff2122SChristoph Hellwig * 461249a8c11SDavid Chinner * If we we are skipping too many items because we can't flush 462249a8c11SDavid Chinner * them or they are already being flushed, we back off and 463249a8c11SDavid Chinner * given them time to complete whatever operation is being 464249a8c11SDavid Chinner * done. i.e. remove pressure from the AIL while we can't make 465249a8c11SDavid Chinner * progress so traversals don't slow down further inserts and 466249a8c11SDavid Chinner * removals to/from the AIL. 467249a8c11SDavid Chinner * 468249a8c11SDavid Chinner * The value of 100 is an arbitrary magic number based on 469249a8c11SDavid Chinner * observation. 470249a8c11SDavid Chinner */ 471249a8c11SDavid Chinner if (stuck > 100) 472249a8c11SDavid Chinner break; 473249a8c11SDavid Chinner 474af3e4022SDave Chinner lip = xfs_trans_ail_cursor_next(ailp, &cur); 475249a8c11SDavid Chinner if (lip == NULL) 476249a8c11SDavid Chinner break; 477249a8c11SDavid Chinner lsn = lip->li_lsn; 4781da177e4SLinus Torvalds } 479af3e4022SDave Chinner xfs_trans_ail_cursor_done(ailp, &cur); 480c7e8f268SDavid Chinner spin_unlock(&ailp->xa_lock); 4811da177e4SLinus Torvalds 48243ff2122SChristoph Hellwig if (xfs_buf_delwri_submit_nowait(&ailp->xa_buf_list)) 48343ff2122SChristoph Hellwig ailp->xa_log_flush++; 484d808f617SDave Chinner 48543ff2122SChristoph Hellwig if (!count || XFS_LSN_CMP(lsn, target) >= 0) { 4869e7004e7SDave Chinner out_done: 487249a8c11SDavid Chinner /* 48843ff2122SChristoph Hellwig * We reached the target or the AIL is empty, so wait a bit 48943ff2122SChristoph Hellwig * longer for I/O to complete and remove pushed items from the 49043ff2122SChristoph Hellwig * AIL before we start the next scan from the start of the AIL. 491249a8c11SDavid Chinner */ 492453eac8aSDave Chinner tout = 50; 4930bf6a5bdSDave Chinner ailp->xa_last_pushed_lsn = 0; 49443ff2122SChristoph Hellwig } else if (((stuck + flushing) * 100) / count > 90) { 495249a8c11SDavid Chinner /* 49643ff2122SChristoph Hellwig * Either there is a lot of contention on the AIL or we are 49743ff2122SChristoph Hellwig * stuck due to operations in progress. "Stuck" in this case 49843ff2122SChristoph Hellwig * is defined as >90% of the items we tried to push were stuck. 499249a8c11SDavid Chinner * 500249a8c11SDavid Chinner * Backoff a bit more to allow some I/O to complete before 50143ff2122SChristoph Hellwig * restarting from the start of the AIL. This prevents us from 50243ff2122SChristoph Hellwig * spinning on the same items, and if they are pinned will all 50343ff2122SChristoph Hellwig * the restart to issue a log force to unpin the stuck items. 504249a8c11SDavid Chinner */ 505453eac8aSDave Chinner tout = 20; 506670ce93fSDave Chinner ailp->xa_last_pushed_lsn = 0; 50743ff2122SChristoph Hellwig } else { 50843ff2122SChristoph Hellwig /* 50943ff2122SChristoph Hellwig * Assume we have more work to do in a short while. 51043ff2122SChristoph Hellwig */ 51143ff2122SChristoph Hellwig tout = 10; 512453eac8aSDave Chinner } 5131da177e4SLinus Torvalds 5140030807cSChristoph Hellwig return tout; 5150030807cSChristoph Hellwig } 5160030807cSChristoph Hellwig 5170030807cSChristoph Hellwig static int 5180030807cSChristoph Hellwig xfsaild( 5190030807cSChristoph Hellwig void *data) 5200030807cSChristoph Hellwig { 5210030807cSChristoph Hellwig struct xfs_ail *ailp = data; 5220030807cSChristoph Hellwig long tout = 0; /* milliseconds */ 5230030807cSChristoph Hellwig 52443ff2122SChristoph Hellwig current->flags |= PF_MEMALLOC; 52543ff2122SChristoph Hellwig 5260030807cSChristoph Hellwig while (!kthread_should_stop()) { 5270030807cSChristoph Hellwig if (tout && tout <= 20) 5280030807cSChristoph Hellwig __set_current_state(TASK_KILLABLE); 5290030807cSChristoph Hellwig else 5300030807cSChristoph Hellwig __set_current_state(TASK_INTERRUPTIBLE); 5310030807cSChristoph Hellwig schedule_timeout(tout ? 5320030807cSChristoph Hellwig msecs_to_jiffies(tout) : MAX_SCHEDULE_TIMEOUT); 5330030807cSChristoph Hellwig 5340030807cSChristoph Hellwig try_to_freeze(); 5350030807cSChristoph Hellwig 5360030807cSChristoph Hellwig tout = xfsaild_push(ailp); 5370030807cSChristoph Hellwig } 5380030807cSChristoph Hellwig 5390030807cSChristoph Hellwig return 0; 5400bf6a5bdSDave Chinner } 5410bf6a5bdSDave Chinner 5420bf6a5bdSDave Chinner /* 5430bf6a5bdSDave Chinner * This routine is called to move the tail of the AIL forward. It does this by 5440bf6a5bdSDave Chinner * trying to flush items in the AIL whose lsns are below the given 5450bf6a5bdSDave Chinner * threshold_lsn. 5460bf6a5bdSDave Chinner * 5470bf6a5bdSDave Chinner * The push is run asynchronously in a workqueue, which means the caller needs 5480bf6a5bdSDave Chinner * to handle waiting on the async flush for space to become available. 5490bf6a5bdSDave Chinner * We don't want to interrupt any push that is in progress, hence we only queue 5500bf6a5bdSDave Chinner * work if we set the pushing bit approriately. 5510bf6a5bdSDave Chinner * 5520bf6a5bdSDave Chinner * We do this unlocked - we only need to know whether there is anything in the 5530bf6a5bdSDave Chinner * AIL at the time we are called. We don't need to access the contents of 5540bf6a5bdSDave Chinner * any of the objects, so the lock is not needed. 5550bf6a5bdSDave Chinner */ 5560bf6a5bdSDave Chinner void 557fd074841SDave Chinner xfs_ail_push( 5580bf6a5bdSDave Chinner struct xfs_ail *ailp, 5590bf6a5bdSDave Chinner xfs_lsn_t threshold_lsn) 5600bf6a5bdSDave Chinner { 5610bf6a5bdSDave Chinner xfs_log_item_t *lip; 5620bf6a5bdSDave Chinner 5630bf6a5bdSDave Chinner lip = xfs_ail_min(ailp); 5640bf6a5bdSDave Chinner if (!lip || XFS_FORCED_SHUTDOWN(ailp->xa_mount) || 5650bf6a5bdSDave Chinner XFS_LSN_CMP(threshold_lsn, ailp->xa_target) <= 0) 5660bf6a5bdSDave Chinner return; 5670bf6a5bdSDave Chinner 5680bf6a5bdSDave Chinner /* 5690bf6a5bdSDave Chinner * Ensure that the new target is noticed in push code before it clears 5700bf6a5bdSDave Chinner * the XFS_AIL_PUSHING_BIT. 5710bf6a5bdSDave Chinner */ 5720bf6a5bdSDave Chinner smp_wmb(); 573fe0da767SDave Chinner xfs_trans_ail_copy_lsn(ailp, &ailp->xa_target, &threshold_lsn); 5740030807cSChristoph Hellwig smp_wmb(); 5750030807cSChristoph Hellwig 5760030807cSChristoph Hellwig wake_up_process(ailp->xa_task); 5770bf6a5bdSDave Chinner } 5781da177e4SLinus Torvalds 5791da177e4SLinus Torvalds /* 580fd074841SDave Chinner * Push out all items in the AIL immediately 581fd074841SDave Chinner */ 582fd074841SDave Chinner void 583fd074841SDave Chinner xfs_ail_push_all( 584fd074841SDave Chinner struct xfs_ail *ailp) 585fd074841SDave Chinner { 586fd074841SDave Chinner xfs_lsn_t threshold_lsn = xfs_ail_max_lsn(ailp); 587fd074841SDave Chinner 588fd074841SDave Chinner if (threshold_lsn) 589fd074841SDave Chinner xfs_ail_push(ailp, threshold_lsn); 590fd074841SDave Chinner } 591fd074841SDave Chinner 592fd074841SDave Chinner /* 593211e4d43SChristoph Hellwig * Push out all items in the AIL immediately and wait until the AIL is empty. 594211e4d43SChristoph Hellwig */ 595211e4d43SChristoph Hellwig void 596211e4d43SChristoph Hellwig xfs_ail_push_all_sync( 597211e4d43SChristoph Hellwig struct xfs_ail *ailp) 598211e4d43SChristoph Hellwig { 599211e4d43SChristoph Hellwig struct xfs_log_item *lip; 600211e4d43SChristoph Hellwig DEFINE_WAIT(wait); 601211e4d43SChristoph Hellwig 602211e4d43SChristoph Hellwig spin_lock(&ailp->xa_lock); 603211e4d43SChristoph Hellwig while ((lip = xfs_ail_max(ailp)) != NULL) { 604211e4d43SChristoph Hellwig prepare_to_wait(&ailp->xa_empty, &wait, TASK_UNINTERRUPTIBLE); 605211e4d43SChristoph Hellwig ailp->xa_target = lip->li_lsn; 606211e4d43SChristoph Hellwig wake_up_process(ailp->xa_task); 607211e4d43SChristoph Hellwig spin_unlock(&ailp->xa_lock); 608211e4d43SChristoph Hellwig schedule(); 609211e4d43SChristoph Hellwig spin_lock(&ailp->xa_lock); 610211e4d43SChristoph Hellwig } 611211e4d43SChristoph Hellwig spin_unlock(&ailp->xa_lock); 612211e4d43SChristoph Hellwig 613211e4d43SChristoph Hellwig finish_wait(&ailp->xa_empty, &wait); 614211e4d43SChristoph Hellwig } 615211e4d43SChristoph Hellwig 616211e4d43SChristoph Hellwig /* 6170e57f6a3SDave Chinner * xfs_trans_ail_update - bulk AIL insertion operation. 6180e57f6a3SDave Chinner * 6190e57f6a3SDave Chinner * @xfs_trans_ail_update takes an array of log items that all need to be 6200e57f6a3SDave Chinner * positioned at the same LSN in the AIL. If an item is not in the AIL, it will 6210e57f6a3SDave Chinner * be added. Otherwise, it will be repositioned by removing it and re-adding 6220e57f6a3SDave Chinner * it to the AIL. If we move the first item in the AIL, update the log tail to 6230e57f6a3SDave Chinner * match the new minimum LSN in the AIL. 6240e57f6a3SDave Chinner * 6250e57f6a3SDave Chinner * This function takes the AIL lock once to execute the update operations on 6260e57f6a3SDave Chinner * all the items in the array, and as such should not be called with the AIL 6270e57f6a3SDave Chinner * lock held. As a result, once we have the AIL lock, we need to check each log 6280e57f6a3SDave Chinner * item LSN to confirm it needs to be moved forward in the AIL. 6290e57f6a3SDave Chinner * 6300e57f6a3SDave Chinner * To optimise the insert operation, we delete all the items from the AIL in 6310e57f6a3SDave Chinner * the first pass, moving them into a temporary list, then splice the temporary 6320e57f6a3SDave Chinner * list into the correct position in the AIL. This avoids needing to do an 6330e57f6a3SDave Chinner * insert operation on every item. 6340e57f6a3SDave Chinner * 6350e57f6a3SDave Chinner * This function must be called with the AIL lock held. The lock is dropped 6360e57f6a3SDave Chinner * before returning. 6370e57f6a3SDave Chinner */ 6380e57f6a3SDave Chinner void 6390e57f6a3SDave Chinner xfs_trans_ail_update_bulk( 6400e57f6a3SDave Chinner struct xfs_ail *ailp, 6411d8c95a3SDave Chinner struct xfs_ail_cursor *cur, 6420e57f6a3SDave Chinner struct xfs_log_item **log_items, 6430e57f6a3SDave Chinner int nr_items, 6440e57f6a3SDave Chinner xfs_lsn_t lsn) __releases(ailp->xa_lock) 6450e57f6a3SDave Chinner { 6460e57f6a3SDave Chinner xfs_log_item_t *mlip; 6470e57f6a3SDave Chinner int mlip_changed = 0; 6480e57f6a3SDave Chinner int i; 6490e57f6a3SDave Chinner LIST_HEAD(tmp); 6500e57f6a3SDave Chinner 651e44f4112SAlex Elder ASSERT(nr_items > 0); /* Not required, but true. */ 6520e57f6a3SDave Chinner mlip = xfs_ail_min(ailp); 6530e57f6a3SDave Chinner 6540e57f6a3SDave Chinner for (i = 0; i < nr_items; i++) { 6550e57f6a3SDave Chinner struct xfs_log_item *lip = log_items[i]; 6560e57f6a3SDave Chinner if (lip->li_flags & XFS_LI_IN_AIL) { 6570e57f6a3SDave Chinner /* check if we really need to move the item */ 6580e57f6a3SDave Chinner if (XFS_LSN_CMP(lsn, lip->li_lsn) <= 0) 6590e57f6a3SDave Chinner continue; 6600e57f6a3SDave Chinner 6610e57f6a3SDave Chinner xfs_ail_delete(ailp, lip); 6620e57f6a3SDave Chinner if (mlip == lip) 6630e57f6a3SDave Chinner mlip_changed = 1; 6640e57f6a3SDave Chinner } else { 6650e57f6a3SDave Chinner lip->li_flags |= XFS_LI_IN_AIL; 6660e57f6a3SDave Chinner } 6670e57f6a3SDave Chinner lip->li_lsn = lsn; 6680e57f6a3SDave Chinner list_add(&lip->li_ail, &tmp); 6690e57f6a3SDave Chinner } 6700e57f6a3SDave Chinner 671e44f4112SAlex Elder if (!list_empty(&tmp)) 6721d8c95a3SDave Chinner xfs_ail_splice(ailp, cur, &tmp, lsn); 6731c304625SChristoph Hellwig 6741c304625SChristoph Hellwig if (mlip_changed) { 6751c304625SChristoph Hellwig if (!XFS_FORCED_SHUTDOWN(ailp->xa_mount)) 6761c304625SChristoph Hellwig xlog_assign_tail_lsn_locked(ailp->xa_mount); 6770e57f6a3SDave Chinner spin_unlock(&ailp->xa_lock); 67809a423a3SChristoph Hellwig 679cfb7cdcaSChristoph Hellwig xfs_log_space_wake(ailp->xa_mount); 6801c304625SChristoph Hellwig } else { 6811c304625SChristoph Hellwig spin_unlock(&ailp->xa_lock); 6820e57f6a3SDave Chinner } 6830e57f6a3SDave Chinner } 6840e57f6a3SDave Chinner 6850e57f6a3SDave Chinner /* 68630136832SDave Chinner * xfs_trans_ail_delete_bulk - remove multiple log items from the AIL 68730136832SDave Chinner * 68830136832SDave Chinner * @xfs_trans_ail_delete_bulk takes an array of log items that all need to 68930136832SDave Chinner * removed from the AIL. The caller is already holding the AIL lock, and done 69030136832SDave Chinner * all the checks necessary to ensure the items passed in via @log_items are 69130136832SDave Chinner * ready for deletion. This includes checking that the items are in the AIL. 69230136832SDave Chinner * 69330136832SDave Chinner * For each log item to be removed, unlink it from the AIL, clear the IN_AIL 69430136832SDave Chinner * flag from the item and reset the item's lsn to 0. If we remove the first 69530136832SDave Chinner * item in the AIL, update the log tail to match the new minimum LSN in the 69630136832SDave Chinner * AIL. 69730136832SDave Chinner * 69830136832SDave Chinner * This function will not drop the AIL lock until all items are removed from 69930136832SDave Chinner * the AIL to minimise the amount of lock traffic on the AIL. This does not 70030136832SDave Chinner * greatly increase the AIL hold time, but does significantly reduce the amount 70130136832SDave Chinner * of traffic on the lock, especially during IO completion. 70230136832SDave Chinner * 70330136832SDave Chinner * This function must be called with the AIL lock held. The lock is dropped 70430136832SDave Chinner * before returning. 70530136832SDave Chinner */ 70630136832SDave Chinner void 70730136832SDave Chinner xfs_trans_ail_delete_bulk( 70830136832SDave Chinner struct xfs_ail *ailp, 70930136832SDave Chinner struct xfs_log_item **log_items, 71004913fddSDave Chinner int nr_items, 71104913fddSDave Chinner int shutdown_type) __releases(ailp->xa_lock) 71230136832SDave Chinner { 71330136832SDave Chinner xfs_log_item_t *mlip; 71430136832SDave Chinner int mlip_changed = 0; 71530136832SDave Chinner int i; 71630136832SDave Chinner 71730136832SDave Chinner mlip = xfs_ail_min(ailp); 71830136832SDave Chinner 71930136832SDave Chinner for (i = 0; i < nr_items; i++) { 72030136832SDave Chinner struct xfs_log_item *lip = log_items[i]; 72130136832SDave Chinner if (!(lip->li_flags & XFS_LI_IN_AIL)) { 72230136832SDave Chinner struct xfs_mount *mp = ailp->xa_mount; 72330136832SDave Chinner 72430136832SDave Chinner spin_unlock(&ailp->xa_lock); 72530136832SDave Chinner if (!XFS_FORCED_SHUTDOWN(mp)) { 7266a19d939SDave Chinner xfs_alert_tag(mp, XFS_PTAG_AILDELETE, 72730136832SDave Chinner "%s: attempting to delete a log item that is not in the AIL", 72830136832SDave Chinner __func__); 72904913fddSDave Chinner xfs_force_shutdown(mp, shutdown_type); 73030136832SDave Chinner } 73130136832SDave Chinner return; 73230136832SDave Chinner } 73330136832SDave Chinner 73430136832SDave Chinner xfs_ail_delete(ailp, lip); 73530136832SDave Chinner lip->li_flags &= ~XFS_LI_IN_AIL; 73630136832SDave Chinner lip->li_lsn = 0; 73730136832SDave Chinner if (mlip == lip) 73830136832SDave Chinner mlip_changed = 1; 73930136832SDave Chinner } 7401c304625SChristoph Hellwig 7411c304625SChristoph Hellwig if (mlip_changed) { 7421c304625SChristoph Hellwig if (!XFS_FORCED_SHUTDOWN(ailp->xa_mount)) 7431c304625SChristoph Hellwig xlog_assign_tail_lsn_locked(ailp->xa_mount); 744211e4d43SChristoph Hellwig if (list_empty(&ailp->xa_ail)) 745211e4d43SChristoph Hellwig wake_up_all(&ailp->xa_empty); 74630136832SDave Chinner spin_unlock(&ailp->xa_lock); 74709a423a3SChristoph Hellwig 748cfb7cdcaSChristoph Hellwig xfs_log_space_wake(ailp->xa_mount); 7491c304625SChristoph Hellwig } else { 7501c304625SChristoph Hellwig spin_unlock(&ailp->xa_lock); 75130136832SDave Chinner } 75230136832SDave Chinner } 7531da177e4SLinus Torvalds 754249a8c11SDavid Chinner int 7551da177e4SLinus Torvalds xfs_trans_ail_init( 7561da177e4SLinus Torvalds xfs_mount_t *mp) 7571da177e4SLinus Torvalds { 75882fa9012SDavid Chinner struct xfs_ail *ailp; 75982fa9012SDavid Chinner 76082fa9012SDavid Chinner ailp = kmem_zalloc(sizeof(struct xfs_ail), KM_MAYFAIL); 76182fa9012SDavid Chinner if (!ailp) 76282fa9012SDavid Chinner return ENOMEM; 76382fa9012SDavid Chinner 76482fa9012SDavid Chinner ailp->xa_mount = mp; 76582fa9012SDavid Chinner INIT_LIST_HEAD(&ailp->xa_ail); 766af3e4022SDave Chinner INIT_LIST_HEAD(&ailp->xa_cursors); 767c7e8f268SDavid Chinner spin_lock_init(&ailp->xa_lock); 76843ff2122SChristoph Hellwig INIT_LIST_HEAD(&ailp->xa_buf_list); 769211e4d43SChristoph Hellwig init_waitqueue_head(&ailp->xa_empty); 7700030807cSChristoph Hellwig 7710030807cSChristoph Hellwig ailp->xa_task = kthread_run(xfsaild, ailp, "xfsaild/%s", 7720030807cSChristoph Hellwig ailp->xa_mount->m_fsname); 7730030807cSChristoph Hellwig if (IS_ERR(ailp->xa_task)) 7740030807cSChristoph Hellwig goto out_free_ailp; 7750030807cSChristoph Hellwig 77627d8d5feSDavid Chinner mp->m_ail = ailp; 77727d8d5feSDavid Chinner return 0; 7780030807cSChristoph Hellwig 7790030807cSChristoph Hellwig out_free_ailp: 7800030807cSChristoph Hellwig kmem_free(ailp); 7810030807cSChristoph Hellwig return ENOMEM; 782249a8c11SDavid Chinner } 783249a8c11SDavid Chinner 784249a8c11SDavid Chinner void 785249a8c11SDavid Chinner xfs_trans_ail_destroy( 786249a8c11SDavid Chinner xfs_mount_t *mp) 787249a8c11SDavid Chinner { 78882fa9012SDavid Chinner struct xfs_ail *ailp = mp->m_ail; 78982fa9012SDavid Chinner 7900030807cSChristoph Hellwig kthread_stop(ailp->xa_task); 79182fa9012SDavid Chinner kmem_free(ailp); 7921da177e4SLinus Torvalds } 793