11da177e4SLinus Torvalds /* 27b718769SNathan Scott * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc. 37b718769SNathan Scott * All Rights Reserved. 41da177e4SLinus Torvalds * 57b718769SNathan Scott * This program is free software; you can redistribute it and/or 67b718769SNathan Scott * modify it under the terms of the GNU General Public License as 71da177e4SLinus Torvalds * published by the Free Software Foundation. 81da177e4SLinus Torvalds * 97b718769SNathan Scott * This program is distributed in the hope that it would be useful, 107b718769SNathan Scott * but WITHOUT ANY WARRANTY; without even the implied warranty of 117b718769SNathan Scott * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 127b718769SNathan Scott * GNU General Public License for more details. 131da177e4SLinus Torvalds * 147b718769SNathan Scott * You should have received a copy of the GNU General Public License 157b718769SNathan Scott * along with this program; if not, write the Free Software Foundation, 167b718769SNathan Scott * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 171da177e4SLinus Torvalds */ 181da177e4SLinus Torvalds #include "xfs.h" 19a844f451SNathan Scott #include "xfs_fs.h" 201da177e4SLinus Torvalds #include "xfs_types.h" 211da177e4SLinus Torvalds #include "xfs_log.h" 22a844f451SNathan Scott #include "xfs_inum.h" 231da177e4SLinus Torvalds #include "xfs_trans.h" 241da177e4SLinus Torvalds #include "xfs_sb.h" 25da353b0dSDavid Chinner #include "xfs_ag.h" 261da177e4SLinus Torvalds #include "xfs_dmapi.h" 271da177e4SLinus Torvalds #include "xfs_mount.h" 281da177e4SLinus Torvalds #include "xfs_trans_priv.h" 291da177e4SLinus Torvalds #include "xfs_error.h" 301da177e4SLinus Torvalds 311da177e4SLinus Torvalds STATIC void xfs_ail_insert(xfs_ail_entry_t *, xfs_log_item_t *); 321da177e4SLinus Torvalds STATIC xfs_log_item_t * xfs_ail_delete(xfs_ail_entry_t *, xfs_log_item_t *); 331da177e4SLinus Torvalds STATIC xfs_log_item_t * xfs_ail_min(xfs_ail_entry_t *); 341da177e4SLinus Torvalds STATIC xfs_log_item_t * xfs_ail_next(xfs_ail_entry_t *, xfs_log_item_t *); 351da177e4SLinus Torvalds 361da177e4SLinus Torvalds #ifdef DEBUG 37de08dbc1SDavid Chinner STATIC void xfs_ail_check(xfs_ail_entry_t *, xfs_log_item_t *); 381da177e4SLinus Torvalds #else 39de08dbc1SDavid Chinner #define xfs_ail_check(a,l) 401da177e4SLinus Torvalds #endif /* DEBUG */ 411da177e4SLinus Torvalds 421da177e4SLinus Torvalds 431da177e4SLinus Torvalds /* 441da177e4SLinus Torvalds * This is called by the log manager code to determine the LSN 451da177e4SLinus Torvalds * of the tail of the log. This is exactly the LSN of the first 461da177e4SLinus Torvalds * item in the AIL. If the AIL is empty, then this function 471da177e4SLinus Torvalds * returns 0. 481da177e4SLinus Torvalds * 491da177e4SLinus Torvalds * We need the AIL lock in order to get a coherent read of the 501da177e4SLinus Torvalds * lsn of the last item in the AIL. 511da177e4SLinus Torvalds */ 521da177e4SLinus Torvalds xfs_lsn_t 531da177e4SLinus Torvalds xfs_trans_tail_ail( 541da177e4SLinus Torvalds xfs_mount_t *mp) 551da177e4SLinus Torvalds { 561da177e4SLinus Torvalds xfs_lsn_t lsn; 571da177e4SLinus Torvalds xfs_log_item_t *lip; 581da177e4SLinus Torvalds 59287f3dadSDonald Douwsma spin_lock(&mp->m_ail_lock); 60249a8c11SDavid Chinner lip = xfs_ail_min(&(mp->m_ail.xa_ail)); 611da177e4SLinus Torvalds if (lip == NULL) { 621da177e4SLinus Torvalds lsn = (xfs_lsn_t)0; 631da177e4SLinus Torvalds } else { 641da177e4SLinus Torvalds lsn = lip->li_lsn; 651da177e4SLinus Torvalds } 66287f3dadSDonald Douwsma spin_unlock(&mp->m_ail_lock); 671da177e4SLinus Torvalds 681da177e4SLinus Torvalds return lsn; 691da177e4SLinus Torvalds } 701da177e4SLinus Torvalds 711da177e4SLinus Torvalds /* 721da177e4SLinus Torvalds * xfs_trans_push_ail 731da177e4SLinus Torvalds * 74249a8c11SDavid Chinner * This routine is called to move the tail of the AIL forward. It does this by 75249a8c11SDavid Chinner * trying to flush items in the AIL whose lsns are below the given 76249a8c11SDavid Chinner * threshold_lsn. 771da177e4SLinus Torvalds * 78249a8c11SDavid Chinner * the push is run asynchronously in a separate thread, so we return the tail 79249a8c11SDavid Chinner * of the log right now instead of the tail after the push. This means we will 80249a8c11SDavid Chinner * either continue right away, or we will sleep waiting on the async thread to 81249a8c11SDavid Chinner * do it's work. 82249a8c11SDavid Chinner * 83249a8c11SDavid Chinner * We do this unlocked - we only need to know whether there is anything in the 84249a8c11SDavid Chinner * AIL at the time we are called. We don't need to access the contents of 85249a8c11SDavid Chinner * any of the objects, so the lock is not needed. 861da177e4SLinus Torvalds */ 87249a8c11SDavid Chinner void 881da177e4SLinus Torvalds xfs_trans_push_ail( 891da177e4SLinus Torvalds xfs_mount_t *mp, 901da177e4SLinus Torvalds xfs_lsn_t threshold_lsn) 911da177e4SLinus Torvalds { 92249a8c11SDavid Chinner xfs_log_item_t *lip; 93249a8c11SDavid Chinner 94249a8c11SDavid Chinner lip = xfs_ail_min(&mp->m_ail.xa_ail); 95249a8c11SDavid Chinner if (lip && !XFS_FORCED_SHUTDOWN(mp)) { 96249a8c11SDavid Chinner if (XFS_LSN_CMP(threshold_lsn, mp->m_ail.xa_target) > 0) 97249a8c11SDavid Chinner xfsaild_wakeup(mp, threshold_lsn); 98249a8c11SDavid Chinner } 99249a8c11SDavid Chinner } 100249a8c11SDavid Chinner 101249a8c11SDavid Chinner /* 102249a8c11SDavid Chinner * Return the item in the AIL with the current lsn. 103249a8c11SDavid Chinner * Return the current tree generation number for use 104249a8c11SDavid Chinner * in calls to xfs_trans_next_ail(). 105249a8c11SDavid Chinner */ 106249a8c11SDavid Chinner STATIC xfs_log_item_t * 107249a8c11SDavid Chinner xfs_trans_first_push_ail( 108249a8c11SDavid Chinner xfs_mount_t *mp, 109249a8c11SDavid Chinner int *gen, 110249a8c11SDavid Chinner xfs_lsn_t lsn) 111249a8c11SDavid Chinner { 112249a8c11SDavid Chinner xfs_log_item_t *lip; 113249a8c11SDavid Chinner 114249a8c11SDavid Chinner lip = xfs_ail_min(&(mp->m_ail.xa_ail)); 115249a8c11SDavid Chinner *gen = (int)mp->m_ail.xa_gen; 116249a8c11SDavid Chinner if (lsn == 0) 117249a8c11SDavid Chinner return lip; 118249a8c11SDavid Chinner 119249a8c11SDavid Chinner while (lip && (XFS_LSN_CMP(lip->li_lsn, lsn) < 0)) 120249a8c11SDavid Chinner lip = lip->li_ail.ail_forw; 121249a8c11SDavid Chinner 122249a8c11SDavid Chinner return lip; 123249a8c11SDavid Chinner } 124249a8c11SDavid Chinner 125249a8c11SDavid Chinner /* 126249a8c11SDavid Chinner * Function that does the work of pushing on the AIL 127249a8c11SDavid Chinner */ 128249a8c11SDavid Chinner long 129249a8c11SDavid Chinner xfsaild_push( 130249a8c11SDavid Chinner xfs_mount_t *mp, 131249a8c11SDavid Chinner xfs_lsn_t *last_lsn) 132249a8c11SDavid Chinner { 133249a8c11SDavid Chinner long tout = 1000; /* milliseconds */ 134249a8c11SDavid Chinner xfs_lsn_t last_pushed_lsn = *last_lsn; 135249a8c11SDavid Chinner xfs_lsn_t target = mp->m_ail.xa_target; 1361da177e4SLinus Torvalds xfs_lsn_t lsn; 1371da177e4SLinus Torvalds xfs_log_item_t *lip; 1381da177e4SLinus Torvalds int gen; 1391da177e4SLinus Torvalds int restarts; 140249a8c11SDavid Chinner int flush_log, count, stuck; 1411da177e4SLinus Torvalds 142249a8c11SDavid Chinner #define XFS_TRANS_PUSH_AIL_RESTARTS 10 1431da177e4SLinus Torvalds 144287f3dadSDonald Douwsma spin_lock(&mp->m_ail_lock); 145249a8c11SDavid Chinner lip = xfs_trans_first_push_ail(mp, &gen, *last_lsn); 146249a8c11SDavid Chinner if (!lip || XFS_FORCED_SHUTDOWN(mp)) { 1471da177e4SLinus Torvalds /* 148249a8c11SDavid Chinner * AIL is empty or our push has reached the end. 1491da177e4SLinus Torvalds */ 150287f3dadSDonald Douwsma spin_unlock(&mp->m_ail_lock); 151249a8c11SDavid Chinner last_pushed_lsn = 0; 152249a8c11SDavid Chinner goto out; 1531da177e4SLinus Torvalds } 1541da177e4SLinus Torvalds 1551da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail); 1561da177e4SLinus Torvalds 1571da177e4SLinus Torvalds /* 1581da177e4SLinus Torvalds * While the item we are looking at is below the given threshold 159249a8c11SDavid Chinner * try to flush it out. We'd like not to stop until we've at least 1601da177e4SLinus Torvalds * tried to push on everything in the AIL with an LSN less than 161249a8c11SDavid Chinner * the given threshold. 1621da177e4SLinus Torvalds * 163249a8c11SDavid Chinner * However, we will stop after a certain number of pushes and wait 164249a8c11SDavid Chinner * for a reduced timeout to fire before pushing further. This 165249a8c11SDavid Chinner * prevents use from spinning when we can't do anything or there is 166249a8c11SDavid Chinner * lots of contention on the AIL lists. 167249a8c11SDavid Chinner */ 168249a8c11SDavid Chinner tout = 10; 169249a8c11SDavid Chinner lsn = lip->li_lsn; 170249a8c11SDavid Chinner flush_log = stuck = count = restarts = 0; 171249a8c11SDavid Chinner while ((XFS_LSN_CMP(lip->li_lsn, target) < 0)) { 172249a8c11SDavid Chinner int lock_result; 173249a8c11SDavid Chinner /* 174249a8c11SDavid Chinner * If we can lock the item without sleeping, unlock the AIL 175249a8c11SDavid Chinner * lock and flush the item. Then re-grab the AIL lock so we 176249a8c11SDavid Chinner * can look for the next item on the AIL. List changes are 177249a8c11SDavid Chinner * handled by the AIL lookup functions internally 178249a8c11SDavid Chinner * 179249a8c11SDavid Chinner * If we can't lock the item, either its holder will flush it 180249a8c11SDavid Chinner * or it is already being flushed or it is being relogged. In 181249a8c11SDavid Chinner * any of these case it is being taken care of and we can just 182249a8c11SDavid Chinner * skip to the next item in the list. 1831da177e4SLinus Torvalds */ 1841da177e4SLinus Torvalds lock_result = IOP_TRYLOCK(lip); 185249a8c11SDavid Chinner spin_unlock(&mp->m_ail_lock); 1861da177e4SLinus Torvalds switch (lock_result) { 1871da177e4SLinus Torvalds case XFS_ITEM_SUCCESS: 1881da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_success); 1891da177e4SLinus Torvalds IOP_PUSH(lip); 190249a8c11SDavid Chinner last_pushed_lsn = lsn; 1911da177e4SLinus Torvalds break; 1921da177e4SLinus Torvalds 1931da177e4SLinus Torvalds case XFS_ITEM_PUSHBUF: 1941da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_pushbuf); 1951da177e4SLinus Torvalds IOP_PUSHBUF(lip); 196249a8c11SDavid Chinner last_pushed_lsn = lsn; 1971da177e4SLinus Torvalds break; 1981da177e4SLinus Torvalds 1991da177e4SLinus Torvalds case XFS_ITEM_PINNED: 2001da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_pinned); 201249a8c11SDavid Chinner stuck++; 2021da177e4SLinus Torvalds flush_log = 1; 2031da177e4SLinus Torvalds break; 2041da177e4SLinus Torvalds 2051da177e4SLinus Torvalds case XFS_ITEM_LOCKED: 2061da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_locked); 207249a8c11SDavid Chinner last_pushed_lsn = lsn; 208249a8c11SDavid Chinner stuck++; 2091da177e4SLinus Torvalds break; 2101da177e4SLinus Torvalds 2111da177e4SLinus Torvalds case XFS_ITEM_FLUSHING: 2121da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_flushing); 213249a8c11SDavid Chinner last_pushed_lsn = lsn; 214249a8c11SDavid Chinner stuck++; 2151da177e4SLinus Torvalds break; 2161da177e4SLinus Torvalds 2171da177e4SLinus Torvalds default: 2181da177e4SLinus Torvalds ASSERT(0); 2191da177e4SLinus Torvalds break; 2201da177e4SLinus Torvalds } 2211da177e4SLinus Torvalds 222249a8c11SDavid Chinner spin_lock(&mp->m_ail_lock); 223249a8c11SDavid Chinner /* should we bother continuing? */ 224249a8c11SDavid Chinner if (XFS_FORCED_SHUTDOWN(mp)) 2251da177e4SLinus Torvalds break; 226249a8c11SDavid Chinner ASSERT(mp->m_log); 2271da177e4SLinus Torvalds 228249a8c11SDavid Chinner count++; 229249a8c11SDavid Chinner 230249a8c11SDavid Chinner /* 231249a8c11SDavid Chinner * Are there too many items we can't do anything with? 232249a8c11SDavid Chinner * If we we are skipping too many items because we can't flush 233249a8c11SDavid Chinner * them or they are already being flushed, we back off and 234249a8c11SDavid Chinner * given them time to complete whatever operation is being 235249a8c11SDavid Chinner * done. i.e. remove pressure from the AIL while we can't make 236249a8c11SDavid Chinner * progress so traversals don't slow down further inserts and 237249a8c11SDavid Chinner * removals to/from the AIL. 238249a8c11SDavid Chinner * 239249a8c11SDavid Chinner * The value of 100 is an arbitrary magic number based on 240249a8c11SDavid Chinner * observation. 241249a8c11SDavid Chinner */ 242249a8c11SDavid Chinner if (stuck > 100) 243249a8c11SDavid Chinner break; 244249a8c11SDavid Chinner 245249a8c11SDavid Chinner lip = xfs_trans_next_ail(mp, lip, &gen, &restarts); 246249a8c11SDavid Chinner if (lip == NULL) 247249a8c11SDavid Chinner break; 248249a8c11SDavid Chinner if (restarts > XFS_TRANS_PUSH_AIL_RESTARTS) 249249a8c11SDavid Chinner break; 250249a8c11SDavid Chinner lsn = lip->li_lsn; 2511da177e4SLinus Torvalds } 252249a8c11SDavid Chinner spin_unlock(&mp->m_ail_lock); 2531da177e4SLinus Torvalds 2541da177e4SLinus Torvalds if (flush_log) { 2551da177e4SLinus Torvalds /* 2561da177e4SLinus Torvalds * If something we need to push out was pinned, then 2571da177e4SLinus Torvalds * push out the log so it will become unpinned and 2581da177e4SLinus Torvalds * move forward in the AIL. 2591da177e4SLinus Torvalds */ 2601da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_flush); 2611da177e4SLinus Torvalds xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE); 2621da177e4SLinus Torvalds } 2631da177e4SLinus Torvalds 264249a8c11SDavid Chinner /* 265249a8c11SDavid Chinner * We reached the target so wait a bit longer for I/O to complete and 266249a8c11SDavid Chinner * remove pushed items from the AIL before we start the next scan from 267249a8c11SDavid Chinner * the start of the AIL. 268249a8c11SDavid Chinner */ 269249a8c11SDavid Chinner if ((XFS_LSN_CMP(lsn, target) >= 0)) { 270249a8c11SDavid Chinner tout += 20; 271249a8c11SDavid Chinner last_pushed_lsn = 0; 272249a8c11SDavid Chinner } else if ((restarts > XFS_TRANS_PUSH_AIL_RESTARTS) || 273249a8c11SDavid Chinner (count && ((stuck * 100) / count > 90))) { 274249a8c11SDavid Chinner /* 275249a8c11SDavid Chinner * Either there is a lot of contention on the AIL or we 276249a8c11SDavid Chinner * are stuck due to operations in progress. "Stuck" in this 277249a8c11SDavid Chinner * case is defined as >90% of the items we tried to push 278249a8c11SDavid Chinner * were stuck. 279249a8c11SDavid Chinner * 280249a8c11SDavid Chinner * Backoff a bit more to allow some I/O to complete before 281249a8c11SDavid Chinner * continuing from where we were. 282249a8c11SDavid Chinner */ 283249a8c11SDavid Chinner tout += 10; 2841da177e4SLinus Torvalds } 285249a8c11SDavid Chinner out: 286249a8c11SDavid Chinner *last_lsn = last_pushed_lsn; 287249a8c11SDavid Chinner return tout; 288249a8c11SDavid Chinner } /* xfsaild_push */ 2891da177e4SLinus Torvalds 2901da177e4SLinus Torvalds 2911da177e4SLinus Torvalds /* 2921da177e4SLinus Torvalds * This is to be called when an item is unlocked that may have 2931da177e4SLinus Torvalds * been in the AIL. It will wake up the first member of the AIL 2941da177e4SLinus Torvalds * wait list if this item's unlocking might allow it to progress. 2951da177e4SLinus Torvalds * If the item is in the AIL, then we need to get the AIL lock 2961da177e4SLinus Torvalds * while doing our checking so we don't race with someone going 2971da177e4SLinus Torvalds * to sleep waiting for this event in xfs_trans_push_ail(). 2981da177e4SLinus Torvalds */ 2991da177e4SLinus Torvalds void 3001da177e4SLinus Torvalds xfs_trans_unlocked_item( 3011da177e4SLinus Torvalds xfs_mount_t *mp, 3021da177e4SLinus Torvalds xfs_log_item_t *lip) 3031da177e4SLinus Torvalds { 3041da177e4SLinus Torvalds xfs_log_item_t *min_lip; 3051da177e4SLinus Torvalds 3061da177e4SLinus Torvalds /* 3071da177e4SLinus Torvalds * If we're forcibly shutting down, we may have 3081da177e4SLinus Torvalds * unlocked log items arbitrarily. The last thing 3091da177e4SLinus Torvalds * we want to do is to move the tail of the log 3101da177e4SLinus Torvalds * over some potentially valid data. 3111da177e4SLinus Torvalds */ 3121da177e4SLinus Torvalds if (!(lip->li_flags & XFS_LI_IN_AIL) || 3131da177e4SLinus Torvalds XFS_FORCED_SHUTDOWN(mp)) { 3141da177e4SLinus Torvalds return; 3151da177e4SLinus Torvalds } 3161da177e4SLinus Torvalds 3171da177e4SLinus Torvalds /* 3181da177e4SLinus Torvalds * This is the one case where we can call into xfs_ail_min() 3191da177e4SLinus Torvalds * without holding the AIL lock because we only care about the 3201da177e4SLinus Torvalds * case where we are at the tail of the AIL. If the object isn't 3211da177e4SLinus Torvalds * at the tail, it doesn't matter what result we get back. This 3221da177e4SLinus Torvalds * is slightly racy because since we were just unlocked, we could 3231da177e4SLinus Torvalds * go to sleep between the call to xfs_ail_min and the call to 3241da177e4SLinus Torvalds * xfs_log_move_tail, have someone else lock us, commit to us disk, 3251da177e4SLinus Torvalds * move us out of the tail of the AIL, and then we wake up. However, 3261da177e4SLinus Torvalds * the call to xfs_log_move_tail() doesn't do anything if there's 3271da177e4SLinus Torvalds * not enough free space to wake people up so we're safe calling it. 3281da177e4SLinus Torvalds */ 329249a8c11SDavid Chinner min_lip = xfs_ail_min(&mp->m_ail.xa_ail); 3301da177e4SLinus Torvalds 3311da177e4SLinus Torvalds if (min_lip == lip) 3321da177e4SLinus Torvalds xfs_log_move_tail(mp, 1); 3331da177e4SLinus Torvalds } /* xfs_trans_unlocked_item */ 3341da177e4SLinus Torvalds 3351da177e4SLinus Torvalds 3361da177e4SLinus Torvalds /* 3371da177e4SLinus Torvalds * Update the position of the item in the AIL with the new 3381da177e4SLinus Torvalds * lsn. If it is not yet in the AIL, add it. Otherwise, move 3391da177e4SLinus Torvalds * it to its new position by removing it and re-adding it. 3401da177e4SLinus Torvalds * 3411da177e4SLinus Torvalds * Wakeup anyone with an lsn less than the item's lsn. If the item 3421da177e4SLinus Torvalds * we move in the AIL is the minimum one, update the tail lsn in the 3431da177e4SLinus Torvalds * log manager. 3441da177e4SLinus Torvalds * 3451da177e4SLinus Torvalds * Increment the AIL's generation count to indicate that the tree 3461da177e4SLinus Torvalds * has changed. 3471da177e4SLinus Torvalds * 3481da177e4SLinus Torvalds * This function must be called with the AIL lock held. The lock 349287f3dadSDonald Douwsma * is dropped before returning. 3501da177e4SLinus Torvalds */ 3511da177e4SLinus Torvalds void 3521da177e4SLinus Torvalds xfs_trans_update_ail( 3531da177e4SLinus Torvalds xfs_mount_t *mp, 3541da177e4SLinus Torvalds xfs_log_item_t *lip, 355287f3dadSDonald Douwsma xfs_lsn_t lsn) __releases(mp->m_ail_lock) 3561da177e4SLinus Torvalds { 3571da177e4SLinus Torvalds xfs_ail_entry_t *ailp; 3581da177e4SLinus Torvalds xfs_log_item_t *dlip=NULL; 3591da177e4SLinus Torvalds xfs_log_item_t *mlip; /* ptr to minimum lip */ 3601da177e4SLinus Torvalds 361249a8c11SDavid Chinner ailp = &(mp->m_ail.xa_ail); 3621da177e4SLinus Torvalds mlip = xfs_ail_min(ailp); 3631da177e4SLinus Torvalds 3641da177e4SLinus Torvalds if (lip->li_flags & XFS_LI_IN_AIL) { 3651da177e4SLinus Torvalds dlip = xfs_ail_delete(ailp, lip); 3661da177e4SLinus Torvalds ASSERT(dlip == lip); 3671da177e4SLinus Torvalds } else { 3681da177e4SLinus Torvalds lip->li_flags |= XFS_LI_IN_AIL; 3691da177e4SLinus Torvalds } 3701da177e4SLinus Torvalds 3711da177e4SLinus Torvalds lip->li_lsn = lsn; 3721da177e4SLinus Torvalds 3731da177e4SLinus Torvalds xfs_ail_insert(ailp, lip); 374249a8c11SDavid Chinner mp->m_ail.xa_gen++; 3751da177e4SLinus Torvalds 3761da177e4SLinus Torvalds if (mlip == dlip) { 377249a8c11SDavid Chinner mlip = xfs_ail_min(&(mp->m_ail.xa_ail)); 378287f3dadSDonald Douwsma spin_unlock(&mp->m_ail_lock); 3791da177e4SLinus Torvalds xfs_log_move_tail(mp, mlip->li_lsn); 3801da177e4SLinus Torvalds } else { 381287f3dadSDonald Douwsma spin_unlock(&mp->m_ail_lock); 3821da177e4SLinus Torvalds } 3831da177e4SLinus Torvalds 3841da177e4SLinus Torvalds 3851da177e4SLinus Torvalds } /* xfs_trans_update_ail */ 3861da177e4SLinus Torvalds 3871da177e4SLinus Torvalds /* 3881da177e4SLinus Torvalds * Delete the given item from the AIL. It must already be in 3891da177e4SLinus Torvalds * the AIL. 3901da177e4SLinus Torvalds * 3911da177e4SLinus Torvalds * Wakeup anyone with an lsn less than item's lsn. If the item 3921da177e4SLinus Torvalds * we delete in the AIL is the minimum one, update the tail lsn in the 3931da177e4SLinus Torvalds * log manager. 3941da177e4SLinus Torvalds * 3951da177e4SLinus Torvalds * Clear the IN_AIL flag from the item, reset its lsn to 0, and 3961da177e4SLinus Torvalds * bump the AIL's generation count to indicate that the tree 3971da177e4SLinus Torvalds * has changed. 3981da177e4SLinus Torvalds * 3991da177e4SLinus Torvalds * This function must be called with the AIL lock held. The lock 400287f3dadSDonald Douwsma * is dropped before returning. 4011da177e4SLinus Torvalds */ 4021da177e4SLinus Torvalds void 4031da177e4SLinus Torvalds xfs_trans_delete_ail( 4041da177e4SLinus Torvalds xfs_mount_t *mp, 405287f3dadSDonald Douwsma xfs_log_item_t *lip) __releases(mp->m_ail_lock) 4061da177e4SLinus Torvalds { 4071da177e4SLinus Torvalds xfs_ail_entry_t *ailp; 4081da177e4SLinus Torvalds xfs_log_item_t *dlip; 4091da177e4SLinus Torvalds xfs_log_item_t *mlip; 4101da177e4SLinus Torvalds 4111da177e4SLinus Torvalds if (lip->li_flags & XFS_LI_IN_AIL) { 412249a8c11SDavid Chinner ailp = &(mp->m_ail.xa_ail); 4131da177e4SLinus Torvalds mlip = xfs_ail_min(ailp); 4141da177e4SLinus Torvalds dlip = xfs_ail_delete(ailp, lip); 4151da177e4SLinus Torvalds ASSERT(dlip == lip); 4161da177e4SLinus Torvalds 4171da177e4SLinus Torvalds 4181da177e4SLinus Torvalds lip->li_flags &= ~XFS_LI_IN_AIL; 4191da177e4SLinus Torvalds lip->li_lsn = 0; 420249a8c11SDavid Chinner mp->m_ail.xa_gen++; 4211da177e4SLinus Torvalds 4221da177e4SLinus Torvalds if (mlip == dlip) { 423249a8c11SDavid Chinner mlip = xfs_ail_min(&(mp->m_ail.xa_ail)); 424287f3dadSDonald Douwsma spin_unlock(&mp->m_ail_lock); 4251da177e4SLinus Torvalds xfs_log_move_tail(mp, (mlip ? mlip->li_lsn : 0)); 4261da177e4SLinus Torvalds } else { 427287f3dadSDonald Douwsma spin_unlock(&mp->m_ail_lock); 4281da177e4SLinus Torvalds } 4291da177e4SLinus Torvalds } 4301da177e4SLinus Torvalds else { 4311da177e4SLinus Torvalds /* 4321da177e4SLinus Torvalds * If the file system is not being shutdown, we are in 4331da177e4SLinus Torvalds * serious trouble if we get to this stage. 4341da177e4SLinus Torvalds */ 4351da177e4SLinus Torvalds if (XFS_FORCED_SHUTDOWN(mp)) 436287f3dadSDonald Douwsma spin_unlock(&mp->m_ail_lock); 4371da177e4SLinus Torvalds else { 4381da177e4SLinus Torvalds xfs_cmn_err(XFS_PTAG_AILDELETE, CE_ALERT, mp, 4397d04a335SNathan Scott "%s: attempting to delete a log item that is not in the AIL", 4407d04a335SNathan Scott __FUNCTION__); 441287f3dadSDonald Douwsma spin_unlock(&mp->m_ail_lock); 4427d04a335SNathan Scott xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); 4431da177e4SLinus Torvalds } 4441da177e4SLinus Torvalds } 4451da177e4SLinus Torvalds } 4461da177e4SLinus Torvalds 4471da177e4SLinus Torvalds 4481da177e4SLinus Torvalds 4491da177e4SLinus Torvalds /* 4501da177e4SLinus Torvalds * Return the item in the AIL with the smallest lsn. 4511da177e4SLinus Torvalds * Return the current tree generation number for use 4521da177e4SLinus Torvalds * in calls to xfs_trans_next_ail(). 4531da177e4SLinus Torvalds */ 4541da177e4SLinus Torvalds xfs_log_item_t * 4551da177e4SLinus Torvalds xfs_trans_first_ail( 4561da177e4SLinus Torvalds xfs_mount_t *mp, 4571da177e4SLinus Torvalds int *gen) 4581da177e4SLinus Torvalds { 4591da177e4SLinus Torvalds xfs_log_item_t *lip; 4601da177e4SLinus Torvalds 461249a8c11SDavid Chinner lip = xfs_ail_min(&(mp->m_ail.xa_ail)); 462249a8c11SDavid Chinner *gen = (int)mp->m_ail.xa_gen; 4631da177e4SLinus Torvalds 464249a8c11SDavid Chinner return lip; 4651da177e4SLinus Torvalds } 4661da177e4SLinus Torvalds 4671da177e4SLinus Torvalds /* 4681da177e4SLinus Torvalds * If the generation count of the tree has not changed since the 4691da177e4SLinus Torvalds * caller last took something from the AIL, then return the elmt 4701da177e4SLinus Torvalds * in the tree which follows the one given. If the count has changed, 4711da177e4SLinus Torvalds * then return the minimum elmt of the AIL and bump the restarts counter 4721da177e4SLinus Torvalds * if one is given. 4731da177e4SLinus Torvalds */ 4741da177e4SLinus Torvalds xfs_log_item_t * 4751da177e4SLinus Torvalds xfs_trans_next_ail( 4761da177e4SLinus Torvalds xfs_mount_t *mp, 4771da177e4SLinus Torvalds xfs_log_item_t *lip, 4781da177e4SLinus Torvalds int *gen, 4791da177e4SLinus Torvalds int *restarts) 4801da177e4SLinus Torvalds { 4811da177e4SLinus Torvalds xfs_log_item_t *nlip; 4821da177e4SLinus Torvalds 4831da177e4SLinus Torvalds ASSERT(mp && lip && gen); 484249a8c11SDavid Chinner if (mp->m_ail.xa_gen == *gen) { 485249a8c11SDavid Chinner nlip = xfs_ail_next(&(mp->m_ail.xa_ail), lip); 4861da177e4SLinus Torvalds } else { 487249a8c11SDavid Chinner nlip = xfs_ail_min(&(mp->m_ail).xa_ail); 488249a8c11SDavid Chinner *gen = (int)mp->m_ail.xa_gen; 4891da177e4SLinus Torvalds if (restarts != NULL) { 4901da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_restarts); 4911da177e4SLinus Torvalds (*restarts)++; 4921da177e4SLinus Torvalds } 4931da177e4SLinus Torvalds } 4941da177e4SLinus Torvalds 4951da177e4SLinus Torvalds return (nlip); 4961da177e4SLinus Torvalds } 4971da177e4SLinus Torvalds 4981da177e4SLinus Torvalds 4991da177e4SLinus Torvalds /* 5001da177e4SLinus Torvalds * The active item list (AIL) is a doubly linked list of log 5011da177e4SLinus Torvalds * items sorted by ascending lsn. The base of the list is 5021da177e4SLinus Torvalds * a forw/back pointer pair embedded in the xfs mount structure. 5031da177e4SLinus Torvalds * The base is initialized with both pointers pointing to the 5041da177e4SLinus Torvalds * base. This case always needs to be distinguished, because 5051da177e4SLinus Torvalds * the base has no lsn to look at. We almost always insert 5061da177e4SLinus Torvalds * at the end of the list, so on inserts we search from the 5071da177e4SLinus Torvalds * end of the list to find where the new item belongs. 5081da177e4SLinus Torvalds */ 5091da177e4SLinus Torvalds 5101da177e4SLinus Torvalds /* 5111da177e4SLinus Torvalds * Initialize the doubly linked list to point only to itself. 5121da177e4SLinus Torvalds */ 513249a8c11SDavid Chinner int 5141da177e4SLinus Torvalds xfs_trans_ail_init( 5151da177e4SLinus Torvalds xfs_mount_t *mp) 5161da177e4SLinus Torvalds { 517249a8c11SDavid Chinner mp->m_ail.xa_ail.ail_forw = (xfs_log_item_t*)&mp->m_ail.xa_ail; 518249a8c11SDavid Chinner mp->m_ail.xa_ail.ail_back = (xfs_log_item_t*)&mp->m_ail.xa_ail; 519249a8c11SDavid Chinner return xfsaild_start(mp); 520249a8c11SDavid Chinner } 521249a8c11SDavid Chinner 522249a8c11SDavid Chinner void 523249a8c11SDavid Chinner xfs_trans_ail_destroy( 524249a8c11SDavid Chinner xfs_mount_t *mp) 525249a8c11SDavid Chinner { 526249a8c11SDavid Chinner xfsaild_stop(mp); 5271da177e4SLinus Torvalds } 5281da177e4SLinus Torvalds 5291da177e4SLinus Torvalds /* 5301da177e4SLinus Torvalds * Insert the given log item into the AIL. 5311da177e4SLinus Torvalds * We almost always insert at the end of the list, so on inserts 5321da177e4SLinus Torvalds * we search from the end of the list to find where the 5331da177e4SLinus Torvalds * new item belongs. 5341da177e4SLinus Torvalds */ 5351da177e4SLinus Torvalds STATIC void 5361da177e4SLinus Torvalds xfs_ail_insert( 5371da177e4SLinus Torvalds xfs_ail_entry_t *base, 5381da177e4SLinus Torvalds xfs_log_item_t *lip) 5391da177e4SLinus Torvalds /* ARGSUSED */ 5401da177e4SLinus Torvalds { 5411da177e4SLinus Torvalds xfs_log_item_t *next_lip; 5421da177e4SLinus Torvalds 5431da177e4SLinus Torvalds /* 5441da177e4SLinus Torvalds * If the list is empty, just insert the item. 5451da177e4SLinus Torvalds */ 5461da177e4SLinus Torvalds if (base->ail_back == (xfs_log_item_t*)base) { 5471da177e4SLinus Torvalds base->ail_forw = lip; 5481da177e4SLinus Torvalds base->ail_back = lip; 5491da177e4SLinus Torvalds lip->li_ail.ail_forw = (xfs_log_item_t*)base; 5501da177e4SLinus Torvalds lip->li_ail.ail_back = (xfs_log_item_t*)base; 5511da177e4SLinus Torvalds return; 5521da177e4SLinus Torvalds } 5531da177e4SLinus Torvalds 5541da177e4SLinus Torvalds next_lip = base->ail_back; 5551da177e4SLinus Torvalds while ((next_lip != (xfs_log_item_t*)base) && 5561da177e4SLinus Torvalds (XFS_LSN_CMP(next_lip->li_lsn, lip->li_lsn) > 0)) { 5571da177e4SLinus Torvalds next_lip = next_lip->li_ail.ail_back; 5581da177e4SLinus Torvalds } 5591da177e4SLinus Torvalds ASSERT((next_lip == (xfs_log_item_t*)base) || 5601da177e4SLinus Torvalds (XFS_LSN_CMP(next_lip->li_lsn, lip->li_lsn) <= 0)); 5611da177e4SLinus Torvalds lip->li_ail.ail_forw = next_lip->li_ail.ail_forw; 5621da177e4SLinus Torvalds lip->li_ail.ail_back = next_lip; 5631da177e4SLinus Torvalds next_lip->li_ail.ail_forw = lip; 5641da177e4SLinus Torvalds lip->li_ail.ail_forw->li_ail.ail_back = lip; 5651da177e4SLinus Torvalds 566de08dbc1SDavid Chinner xfs_ail_check(base, lip); 5671da177e4SLinus Torvalds return; 5681da177e4SLinus Torvalds } 5691da177e4SLinus Torvalds 5701da177e4SLinus Torvalds /* 5711da177e4SLinus Torvalds * Delete the given item from the AIL. Return a pointer to the item. 5721da177e4SLinus Torvalds */ 5731da177e4SLinus Torvalds /*ARGSUSED*/ 5741da177e4SLinus Torvalds STATIC xfs_log_item_t * 5751da177e4SLinus Torvalds xfs_ail_delete( 5761da177e4SLinus Torvalds xfs_ail_entry_t *base, 5771da177e4SLinus Torvalds xfs_log_item_t *lip) 5781da177e4SLinus Torvalds /* ARGSUSED */ 5791da177e4SLinus Torvalds { 580de08dbc1SDavid Chinner xfs_ail_check(base, lip); 5811da177e4SLinus Torvalds lip->li_ail.ail_forw->li_ail.ail_back = lip->li_ail.ail_back; 5821da177e4SLinus Torvalds lip->li_ail.ail_back->li_ail.ail_forw = lip->li_ail.ail_forw; 5831da177e4SLinus Torvalds lip->li_ail.ail_forw = NULL; 5841da177e4SLinus Torvalds lip->li_ail.ail_back = NULL; 5851da177e4SLinus Torvalds 5861da177e4SLinus Torvalds return lip; 5871da177e4SLinus Torvalds } 5881da177e4SLinus Torvalds 5891da177e4SLinus Torvalds /* 5901da177e4SLinus Torvalds * Return a pointer to the first item in the AIL. 5911da177e4SLinus Torvalds * If the AIL is empty, then return NULL. 5921da177e4SLinus Torvalds */ 5931da177e4SLinus Torvalds STATIC xfs_log_item_t * 5941da177e4SLinus Torvalds xfs_ail_min( 5951da177e4SLinus Torvalds xfs_ail_entry_t *base) 5961da177e4SLinus Torvalds /* ARGSUSED */ 5971da177e4SLinus Torvalds { 5981da177e4SLinus Torvalds register xfs_log_item_t *forw = base->ail_forw; 5991da177e4SLinus Torvalds if (forw == (xfs_log_item_t*)base) { 6001da177e4SLinus Torvalds return NULL; 6011da177e4SLinus Torvalds } 6021da177e4SLinus Torvalds return forw; 6031da177e4SLinus Torvalds } 6041da177e4SLinus Torvalds 6051da177e4SLinus Torvalds /* 6061da177e4SLinus Torvalds * Return a pointer to the item which follows 6071da177e4SLinus Torvalds * the given item in the AIL. If the given item 6081da177e4SLinus Torvalds * is the last item in the list, then return NULL. 6091da177e4SLinus Torvalds */ 6101da177e4SLinus Torvalds STATIC xfs_log_item_t * 6111da177e4SLinus Torvalds xfs_ail_next( 6121da177e4SLinus Torvalds xfs_ail_entry_t *base, 6131da177e4SLinus Torvalds xfs_log_item_t *lip) 6141da177e4SLinus Torvalds /* ARGSUSED */ 6151da177e4SLinus Torvalds { 6161da177e4SLinus Torvalds if (lip->li_ail.ail_forw == (xfs_log_item_t*)base) { 6171da177e4SLinus Torvalds return NULL; 6181da177e4SLinus Torvalds } 6191da177e4SLinus Torvalds return lip->li_ail.ail_forw; 6201da177e4SLinus Torvalds 6211da177e4SLinus Torvalds } 6221da177e4SLinus Torvalds 6231da177e4SLinus Torvalds #ifdef DEBUG 6241da177e4SLinus Torvalds /* 6251da177e4SLinus Torvalds * Check that the list is sorted as it should be. 6261da177e4SLinus Torvalds */ 6271da177e4SLinus Torvalds STATIC void 6281da177e4SLinus Torvalds xfs_ail_check( 629de08dbc1SDavid Chinner xfs_ail_entry_t *base, 630de08dbc1SDavid Chinner xfs_log_item_t *lip) 6311da177e4SLinus Torvalds { 6321da177e4SLinus Torvalds xfs_log_item_t *prev_lip; 6331da177e4SLinus Torvalds 634de08dbc1SDavid Chinner prev_lip = base->ail_forw; 635de08dbc1SDavid Chinner if (prev_lip == (xfs_log_item_t*)base) { 6361da177e4SLinus Torvalds /* 6371da177e4SLinus Torvalds * Make sure the pointers are correct when the list 6381da177e4SLinus Torvalds * is empty. 6391da177e4SLinus Torvalds */ 6401da177e4SLinus Torvalds ASSERT(base->ail_back == (xfs_log_item_t*)base); 6411da177e4SLinus Torvalds return; 6421da177e4SLinus Torvalds } 6431da177e4SLinus Torvalds 6441da177e4SLinus Torvalds /* 645de08dbc1SDavid Chinner * Check the next and previous entries are valid. 646de08dbc1SDavid Chinner */ 647de08dbc1SDavid Chinner ASSERT((lip->li_flags & XFS_LI_IN_AIL) != 0); 648de08dbc1SDavid Chinner prev_lip = lip->li_ail.ail_back; 649de08dbc1SDavid Chinner if (prev_lip != (xfs_log_item_t*)base) { 650de08dbc1SDavid Chinner ASSERT(prev_lip->li_ail.ail_forw == lip); 651de08dbc1SDavid Chinner ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) <= 0); 652de08dbc1SDavid Chinner } 653de08dbc1SDavid Chinner prev_lip = lip->li_ail.ail_forw; 654de08dbc1SDavid Chinner if (prev_lip != (xfs_log_item_t*)base) { 655de08dbc1SDavid Chinner ASSERT(prev_lip->li_ail.ail_back == lip); 656de08dbc1SDavid Chinner ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) >= 0); 657de08dbc1SDavid Chinner } 658de08dbc1SDavid Chinner 659de08dbc1SDavid Chinner 660de08dbc1SDavid Chinner #ifdef XFS_TRANS_DEBUG 661de08dbc1SDavid Chinner /* 6621da177e4SLinus Torvalds * Walk the list checking forward and backward pointers, 6631da177e4SLinus Torvalds * lsn ordering, and that every entry has the XFS_LI_IN_AIL 664de08dbc1SDavid Chinner * flag set. This is really expensive, so only do it when 665de08dbc1SDavid Chinner * specifically debugging the transaction subsystem. 6661da177e4SLinus Torvalds */ 6671da177e4SLinus Torvalds prev_lip = (xfs_log_item_t*)base; 6681da177e4SLinus Torvalds while (lip != (xfs_log_item_t*)base) { 6691da177e4SLinus Torvalds if (prev_lip != (xfs_log_item_t*)base) { 6701da177e4SLinus Torvalds ASSERT(prev_lip->li_ail.ail_forw == lip); 6711da177e4SLinus Torvalds ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) <= 0); 6721da177e4SLinus Torvalds } 6731da177e4SLinus Torvalds ASSERT(lip->li_ail.ail_back == prev_lip); 6741da177e4SLinus Torvalds ASSERT((lip->li_flags & XFS_LI_IN_AIL) != 0); 6751da177e4SLinus Torvalds prev_lip = lip; 6761da177e4SLinus Torvalds lip = lip->li_ail.ail_forw; 6771da177e4SLinus Torvalds } 6781da177e4SLinus Torvalds ASSERT(lip == (xfs_log_item_t*)base); 6791da177e4SLinus Torvalds ASSERT(base->ail_back == prev_lip); 680de08dbc1SDavid Chinner #endif /* XFS_TRANS_DEBUG */ 6811da177e4SLinus Torvalds } 6821da177e4SLinus Torvalds #endif /* DEBUG */ 683