11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * Copyright (c) 2000-2002 Silicon Graphics, Inc. All Rights Reserved. 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or modify it 51da177e4SLinus Torvalds * under the terms of version 2 of the GNU General Public License as 61da177e4SLinus Torvalds * published by the Free Software Foundation. 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * This program is distributed in the hope that it would be useful, but 91da177e4SLinus Torvalds * WITHOUT ANY WARRANTY; without even the implied warranty of 101da177e4SLinus Torvalds * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds * Further, this software is distributed without any warranty that it is 131da177e4SLinus Torvalds * free of the rightful claim of any third person regarding infringement 141da177e4SLinus Torvalds * or the like. Any license provided herein, whether implied or 151da177e4SLinus Torvalds * otherwise, applies only to this software file. Patent licenses, if 161da177e4SLinus Torvalds * any, provided herein do not apply to combinations of this program with 171da177e4SLinus Torvalds * other software, or any other product whatsoever. 181da177e4SLinus Torvalds * 191da177e4SLinus Torvalds * You should have received a copy of the GNU General Public License along 201da177e4SLinus Torvalds * with this program; if not, write the Free Software Foundation, Inc., 59 211da177e4SLinus Torvalds * Temple Place - Suite 330, Boston MA 02111-1307, USA. 221da177e4SLinus Torvalds * 231da177e4SLinus Torvalds * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy, 241da177e4SLinus Torvalds * Mountain View, CA 94043, or: 251da177e4SLinus Torvalds * 261da177e4SLinus Torvalds * http://www.sgi.com 271da177e4SLinus Torvalds * 281da177e4SLinus Torvalds * For further information regarding this notice, see: 291da177e4SLinus Torvalds * 301da177e4SLinus Torvalds * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/ 311da177e4SLinus Torvalds */ 321da177e4SLinus Torvalds 331da177e4SLinus Torvalds #include "xfs.h" 341da177e4SLinus Torvalds #include "xfs_macros.h" 351da177e4SLinus Torvalds #include "xfs_types.h" 361da177e4SLinus Torvalds #include "xfs_inum.h" 371da177e4SLinus Torvalds #include "xfs_log.h" 381da177e4SLinus Torvalds #include "xfs_trans.h" 391da177e4SLinus Torvalds #include "xfs_sb.h" 401da177e4SLinus Torvalds #include "xfs_dir.h" 411da177e4SLinus Torvalds #include "xfs_dmapi.h" 421da177e4SLinus Torvalds #include "xfs_mount.h" 431da177e4SLinus Torvalds #include "xfs_trans_priv.h" 441da177e4SLinus Torvalds #include "xfs_error.h" 451da177e4SLinus Torvalds 461da177e4SLinus Torvalds STATIC void xfs_ail_insert(xfs_ail_entry_t *, xfs_log_item_t *); 471da177e4SLinus Torvalds STATIC xfs_log_item_t * xfs_ail_delete(xfs_ail_entry_t *, xfs_log_item_t *); 481da177e4SLinus Torvalds STATIC xfs_log_item_t * xfs_ail_min(xfs_ail_entry_t *); 491da177e4SLinus Torvalds STATIC xfs_log_item_t * xfs_ail_next(xfs_ail_entry_t *, xfs_log_item_t *); 501da177e4SLinus Torvalds 511da177e4SLinus Torvalds #ifdef DEBUG 521da177e4SLinus Torvalds STATIC void xfs_ail_check(xfs_ail_entry_t *); 531da177e4SLinus Torvalds #else 541da177e4SLinus Torvalds #define xfs_ail_check(a) 551da177e4SLinus Torvalds #endif /* DEBUG */ 561da177e4SLinus Torvalds 571da177e4SLinus Torvalds 581da177e4SLinus Torvalds /* 591da177e4SLinus Torvalds * This is called by the log manager code to determine the LSN 601da177e4SLinus Torvalds * of the tail of the log. This is exactly the LSN of the first 611da177e4SLinus Torvalds * item in the AIL. If the AIL is empty, then this function 621da177e4SLinus Torvalds * returns 0. 631da177e4SLinus Torvalds * 641da177e4SLinus Torvalds * We need the AIL lock in order to get a coherent read of the 651da177e4SLinus Torvalds * lsn of the last item in the AIL. 661da177e4SLinus Torvalds */ 671da177e4SLinus Torvalds xfs_lsn_t 681da177e4SLinus Torvalds xfs_trans_tail_ail( 691da177e4SLinus Torvalds xfs_mount_t *mp) 701da177e4SLinus Torvalds { 711da177e4SLinus Torvalds xfs_lsn_t lsn; 721da177e4SLinus Torvalds xfs_log_item_t *lip; 731da177e4SLinus Torvalds SPLDECL(s); 741da177e4SLinus Torvalds 751da177e4SLinus Torvalds AIL_LOCK(mp,s); 761da177e4SLinus Torvalds lip = xfs_ail_min(&(mp->m_ail)); 771da177e4SLinus Torvalds if (lip == NULL) { 781da177e4SLinus Torvalds lsn = (xfs_lsn_t)0; 791da177e4SLinus Torvalds } else { 801da177e4SLinus Torvalds lsn = lip->li_lsn; 811da177e4SLinus Torvalds } 821da177e4SLinus Torvalds AIL_UNLOCK(mp, s); 831da177e4SLinus Torvalds 841da177e4SLinus Torvalds return lsn; 851da177e4SLinus Torvalds } 861da177e4SLinus Torvalds 871da177e4SLinus Torvalds /* 881da177e4SLinus Torvalds * xfs_trans_push_ail 891da177e4SLinus Torvalds * 901da177e4SLinus Torvalds * This routine is called to move the tail of the AIL 911da177e4SLinus Torvalds * forward. It does this by trying to flush items in the AIL 921da177e4SLinus Torvalds * whose lsns are below the given threshold_lsn. 931da177e4SLinus Torvalds * 941da177e4SLinus Torvalds * The routine returns the lsn of the tail of the log. 951da177e4SLinus Torvalds */ 961da177e4SLinus Torvalds xfs_lsn_t 971da177e4SLinus Torvalds xfs_trans_push_ail( 981da177e4SLinus Torvalds xfs_mount_t *mp, 991da177e4SLinus Torvalds xfs_lsn_t threshold_lsn) 1001da177e4SLinus Torvalds { 1011da177e4SLinus Torvalds xfs_lsn_t lsn; 1021da177e4SLinus Torvalds xfs_log_item_t *lip; 1031da177e4SLinus Torvalds int gen; 1041da177e4SLinus Torvalds int restarts; 1051da177e4SLinus Torvalds int lock_result; 1061da177e4SLinus Torvalds int flush_log; 1071da177e4SLinus Torvalds SPLDECL(s); 1081da177e4SLinus Torvalds 1091da177e4SLinus Torvalds #define XFS_TRANS_PUSH_AIL_RESTARTS 10 1101da177e4SLinus Torvalds 1111da177e4SLinus Torvalds AIL_LOCK(mp,s); 1121da177e4SLinus Torvalds lip = xfs_trans_first_ail(mp, &gen); 1131da177e4SLinus Torvalds if (lip == NULL || XFS_FORCED_SHUTDOWN(mp)) { 1141da177e4SLinus Torvalds /* 1151da177e4SLinus Torvalds * Just return if the AIL is empty. 1161da177e4SLinus Torvalds */ 1171da177e4SLinus Torvalds AIL_UNLOCK(mp, s); 1181da177e4SLinus Torvalds return (xfs_lsn_t)0; 1191da177e4SLinus Torvalds } 1201da177e4SLinus Torvalds 1211da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail); 1221da177e4SLinus Torvalds 1231da177e4SLinus Torvalds /* 1241da177e4SLinus Torvalds * While the item we are looking at is below the given threshold 1251da177e4SLinus Torvalds * try to flush it out. Make sure to limit the number of times 1261da177e4SLinus Torvalds * we allow xfs_trans_next_ail() to restart scanning from the 1271da177e4SLinus Torvalds * beginning of the list. We'd like not to stop until we've at least 1281da177e4SLinus Torvalds * tried to push on everything in the AIL with an LSN less than 1291da177e4SLinus Torvalds * the given threshold. However, we may give up before that if 1301da177e4SLinus Torvalds * we realize that we've been holding the AIL_LOCK for 'too long', 1311da177e4SLinus Torvalds * blocking interrupts. Currently, too long is < 500us roughly. 1321da177e4SLinus Torvalds */ 1331da177e4SLinus Torvalds flush_log = 0; 1341da177e4SLinus Torvalds restarts = 0; 1351da177e4SLinus Torvalds while (((restarts < XFS_TRANS_PUSH_AIL_RESTARTS) && 1361da177e4SLinus Torvalds (XFS_LSN_CMP(lip->li_lsn, threshold_lsn) < 0))) { 1371da177e4SLinus Torvalds /* 1381da177e4SLinus Torvalds * If we can lock the item without sleeping, unlock 1391da177e4SLinus Torvalds * the AIL lock and flush the item. Then re-grab the 1401da177e4SLinus Torvalds * AIL lock so we can look for the next item on the 1411da177e4SLinus Torvalds * AIL. Since we unlock the AIL while we flush the 1421da177e4SLinus Torvalds * item, the next routine may start over again at the 1431da177e4SLinus Torvalds * the beginning of the list if anything has changed. 1441da177e4SLinus Torvalds * That is what the generation count is for. 1451da177e4SLinus Torvalds * 1461da177e4SLinus Torvalds * If we can't lock the item, either its holder will flush 1471da177e4SLinus Torvalds * it or it is already being flushed or it is being relogged. 1481da177e4SLinus Torvalds * In any of these case it is being taken care of and we 1491da177e4SLinus Torvalds * can just skip to the next item in the list. 1501da177e4SLinus Torvalds */ 1511da177e4SLinus Torvalds lock_result = IOP_TRYLOCK(lip); 1521da177e4SLinus Torvalds switch (lock_result) { 1531da177e4SLinus Torvalds case XFS_ITEM_SUCCESS: 1541da177e4SLinus Torvalds AIL_UNLOCK(mp, s); 1551da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_success); 1561da177e4SLinus Torvalds IOP_PUSH(lip); 1571da177e4SLinus Torvalds AIL_LOCK(mp,s); 1581da177e4SLinus Torvalds break; 1591da177e4SLinus Torvalds 1601da177e4SLinus Torvalds case XFS_ITEM_PUSHBUF: 1611da177e4SLinus Torvalds AIL_UNLOCK(mp, s); 1621da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_pushbuf); 1631da177e4SLinus Torvalds #ifdef XFSRACEDEBUG 1641da177e4SLinus Torvalds delay_for_intr(); 1651da177e4SLinus Torvalds delay(300); 1661da177e4SLinus Torvalds #endif 1671da177e4SLinus Torvalds ASSERT(lip->li_ops->iop_pushbuf); 1681da177e4SLinus Torvalds ASSERT(lip); 1691da177e4SLinus Torvalds IOP_PUSHBUF(lip); 1701da177e4SLinus Torvalds AIL_LOCK(mp,s); 1711da177e4SLinus Torvalds break; 1721da177e4SLinus Torvalds 1731da177e4SLinus Torvalds case XFS_ITEM_PINNED: 1741da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_pinned); 1751da177e4SLinus Torvalds flush_log = 1; 1761da177e4SLinus Torvalds break; 1771da177e4SLinus Torvalds 1781da177e4SLinus Torvalds case XFS_ITEM_LOCKED: 1791da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_locked); 1801da177e4SLinus Torvalds break; 1811da177e4SLinus Torvalds 1821da177e4SLinus Torvalds case XFS_ITEM_FLUSHING: 1831da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_flushing); 1841da177e4SLinus Torvalds break; 1851da177e4SLinus Torvalds 1861da177e4SLinus Torvalds default: 1871da177e4SLinus Torvalds ASSERT(0); 1881da177e4SLinus Torvalds break; 1891da177e4SLinus Torvalds } 1901da177e4SLinus Torvalds 1911da177e4SLinus Torvalds lip = xfs_trans_next_ail(mp, lip, &gen, &restarts); 1921da177e4SLinus Torvalds if (lip == NULL) { 1931da177e4SLinus Torvalds break; 1941da177e4SLinus Torvalds } 1951da177e4SLinus Torvalds if (XFS_FORCED_SHUTDOWN(mp)) { 1961da177e4SLinus Torvalds /* 1971da177e4SLinus Torvalds * Just return if we shut down during the last try. 1981da177e4SLinus Torvalds */ 1991da177e4SLinus Torvalds AIL_UNLOCK(mp, s); 2001da177e4SLinus Torvalds return (xfs_lsn_t)0; 2011da177e4SLinus Torvalds } 2021da177e4SLinus Torvalds 2031da177e4SLinus Torvalds } 2041da177e4SLinus Torvalds 2051da177e4SLinus Torvalds if (flush_log) { 2061da177e4SLinus Torvalds /* 2071da177e4SLinus Torvalds * If something we need to push out was pinned, then 2081da177e4SLinus Torvalds * push out the log so it will become unpinned and 2091da177e4SLinus Torvalds * move forward in the AIL. 2101da177e4SLinus Torvalds */ 2111da177e4SLinus Torvalds AIL_UNLOCK(mp, s); 2121da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_flush); 2131da177e4SLinus Torvalds xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE); 2141da177e4SLinus Torvalds AIL_LOCK(mp, s); 2151da177e4SLinus Torvalds } 2161da177e4SLinus Torvalds 2171da177e4SLinus Torvalds lip = xfs_ail_min(&(mp->m_ail)); 2181da177e4SLinus Torvalds if (lip == NULL) { 2191da177e4SLinus Torvalds lsn = (xfs_lsn_t)0; 2201da177e4SLinus Torvalds } else { 2211da177e4SLinus Torvalds lsn = lip->li_lsn; 2221da177e4SLinus Torvalds } 2231da177e4SLinus Torvalds 2241da177e4SLinus Torvalds AIL_UNLOCK(mp, s); 2251da177e4SLinus Torvalds return lsn; 2261da177e4SLinus Torvalds } /* xfs_trans_push_ail */ 2271da177e4SLinus Torvalds 2281da177e4SLinus Torvalds 2291da177e4SLinus Torvalds /* 2301da177e4SLinus Torvalds * This is to be called when an item is unlocked that may have 2311da177e4SLinus Torvalds * been in the AIL. It will wake up the first member of the AIL 2321da177e4SLinus Torvalds * wait list if this item's unlocking might allow it to progress. 2331da177e4SLinus Torvalds * If the item is in the AIL, then we need to get the AIL lock 2341da177e4SLinus Torvalds * while doing our checking so we don't race with someone going 2351da177e4SLinus Torvalds * to sleep waiting for this event in xfs_trans_push_ail(). 2361da177e4SLinus Torvalds */ 2371da177e4SLinus Torvalds void 2381da177e4SLinus Torvalds xfs_trans_unlocked_item( 2391da177e4SLinus Torvalds xfs_mount_t *mp, 2401da177e4SLinus Torvalds xfs_log_item_t *lip) 2411da177e4SLinus Torvalds { 2421da177e4SLinus Torvalds xfs_log_item_t *min_lip; 2431da177e4SLinus Torvalds 2441da177e4SLinus Torvalds /* 2451da177e4SLinus Torvalds * If we're forcibly shutting down, we may have 2461da177e4SLinus Torvalds * unlocked log items arbitrarily. The last thing 2471da177e4SLinus Torvalds * we want to do is to move the tail of the log 2481da177e4SLinus Torvalds * over some potentially valid data. 2491da177e4SLinus Torvalds */ 2501da177e4SLinus Torvalds if (!(lip->li_flags & XFS_LI_IN_AIL) || 2511da177e4SLinus Torvalds XFS_FORCED_SHUTDOWN(mp)) { 2521da177e4SLinus Torvalds return; 2531da177e4SLinus Torvalds } 2541da177e4SLinus Torvalds 2551da177e4SLinus Torvalds /* 2561da177e4SLinus Torvalds * This is the one case where we can call into xfs_ail_min() 2571da177e4SLinus Torvalds * without holding the AIL lock because we only care about the 2581da177e4SLinus Torvalds * case where we are at the tail of the AIL. If the object isn't 2591da177e4SLinus Torvalds * at the tail, it doesn't matter what result we get back. This 2601da177e4SLinus Torvalds * is slightly racy because since we were just unlocked, we could 2611da177e4SLinus Torvalds * go to sleep between the call to xfs_ail_min and the call to 2621da177e4SLinus Torvalds * xfs_log_move_tail, have someone else lock us, commit to us disk, 2631da177e4SLinus Torvalds * move us out of the tail of the AIL, and then we wake up. However, 2641da177e4SLinus Torvalds * the call to xfs_log_move_tail() doesn't do anything if there's 2651da177e4SLinus Torvalds * not enough free space to wake people up so we're safe calling it. 2661da177e4SLinus Torvalds */ 2671da177e4SLinus Torvalds min_lip = xfs_ail_min(&mp->m_ail); 2681da177e4SLinus Torvalds 2691da177e4SLinus Torvalds if (min_lip == lip) 2701da177e4SLinus Torvalds xfs_log_move_tail(mp, 1); 2711da177e4SLinus Torvalds } /* xfs_trans_unlocked_item */ 2721da177e4SLinus Torvalds 2731da177e4SLinus Torvalds 2741da177e4SLinus Torvalds /* 2751da177e4SLinus Torvalds * Update the position of the item in the AIL with the new 2761da177e4SLinus Torvalds * lsn. If it is not yet in the AIL, add it. Otherwise, move 2771da177e4SLinus Torvalds * it to its new position by removing it and re-adding it. 2781da177e4SLinus Torvalds * 2791da177e4SLinus Torvalds * Wakeup anyone with an lsn less than the item's lsn. If the item 2801da177e4SLinus Torvalds * we move in the AIL is the minimum one, update the tail lsn in the 2811da177e4SLinus Torvalds * log manager. 2821da177e4SLinus Torvalds * 2831da177e4SLinus Torvalds * Increment the AIL's generation count to indicate that the tree 2841da177e4SLinus Torvalds * has changed. 2851da177e4SLinus Torvalds * 2861da177e4SLinus Torvalds * This function must be called with the AIL lock held. The lock 2871da177e4SLinus Torvalds * is dropped before returning, so the caller must pass in the 2881da177e4SLinus Torvalds * cookie returned by AIL_LOCK. 2891da177e4SLinus Torvalds */ 2901da177e4SLinus Torvalds void 2911da177e4SLinus Torvalds xfs_trans_update_ail( 2921da177e4SLinus Torvalds xfs_mount_t *mp, 2931da177e4SLinus Torvalds xfs_log_item_t *lip, 2941da177e4SLinus Torvalds xfs_lsn_t lsn, 2951da177e4SLinus Torvalds unsigned long s) 2961da177e4SLinus Torvalds { 2971da177e4SLinus Torvalds xfs_ail_entry_t *ailp; 2981da177e4SLinus Torvalds xfs_log_item_t *dlip=NULL; 2991da177e4SLinus Torvalds xfs_log_item_t *mlip; /* ptr to minimum lip */ 3001da177e4SLinus Torvalds 3011da177e4SLinus Torvalds ailp = &(mp->m_ail); 3021da177e4SLinus Torvalds mlip = xfs_ail_min(ailp); 3031da177e4SLinus Torvalds 3041da177e4SLinus Torvalds if (lip->li_flags & XFS_LI_IN_AIL) { 3051da177e4SLinus Torvalds dlip = xfs_ail_delete(ailp, lip); 3061da177e4SLinus Torvalds ASSERT(dlip == lip); 3071da177e4SLinus Torvalds } else { 3081da177e4SLinus Torvalds lip->li_flags |= XFS_LI_IN_AIL; 3091da177e4SLinus Torvalds } 3101da177e4SLinus Torvalds 3111da177e4SLinus Torvalds lip->li_lsn = lsn; 3121da177e4SLinus Torvalds 3131da177e4SLinus Torvalds xfs_ail_insert(ailp, lip); 3141da177e4SLinus Torvalds mp->m_ail_gen++; 3151da177e4SLinus Torvalds 3161da177e4SLinus Torvalds if (mlip == dlip) { 3171da177e4SLinus Torvalds mlip = xfs_ail_min(&(mp->m_ail)); 3181da177e4SLinus Torvalds AIL_UNLOCK(mp, s); 3191da177e4SLinus Torvalds xfs_log_move_tail(mp, mlip->li_lsn); 3201da177e4SLinus Torvalds } else { 3211da177e4SLinus Torvalds AIL_UNLOCK(mp, s); 3221da177e4SLinus Torvalds } 3231da177e4SLinus Torvalds 3241da177e4SLinus Torvalds 3251da177e4SLinus Torvalds } /* xfs_trans_update_ail */ 3261da177e4SLinus Torvalds 3271da177e4SLinus Torvalds /* 3281da177e4SLinus Torvalds * Delete the given item from the AIL. It must already be in 3291da177e4SLinus Torvalds * the AIL. 3301da177e4SLinus Torvalds * 3311da177e4SLinus Torvalds * Wakeup anyone with an lsn less than item's lsn. If the item 3321da177e4SLinus Torvalds * we delete in the AIL is the minimum one, update the tail lsn in the 3331da177e4SLinus Torvalds * log manager. 3341da177e4SLinus Torvalds * 3351da177e4SLinus Torvalds * Clear the IN_AIL flag from the item, reset its lsn to 0, and 3361da177e4SLinus Torvalds * bump the AIL's generation count to indicate that the tree 3371da177e4SLinus Torvalds * has changed. 3381da177e4SLinus Torvalds * 3391da177e4SLinus Torvalds * This function must be called with the AIL lock held. The lock 3401da177e4SLinus Torvalds * is dropped before returning, so the caller must pass in the 3411da177e4SLinus Torvalds * cookie returned by AIL_LOCK. 3421da177e4SLinus Torvalds */ 3431da177e4SLinus Torvalds void 3441da177e4SLinus Torvalds xfs_trans_delete_ail( 3451da177e4SLinus Torvalds xfs_mount_t *mp, 3461da177e4SLinus Torvalds xfs_log_item_t *lip, 3471da177e4SLinus Torvalds unsigned long s) 3481da177e4SLinus Torvalds { 3491da177e4SLinus Torvalds xfs_ail_entry_t *ailp; 3501da177e4SLinus Torvalds xfs_log_item_t *dlip; 3511da177e4SLinus Torvalds xfs_log_item_t *mlip; 3521da177e4SLinus Torvalds 3531da177e4SLinus Torvalds if (lip->li_flags & XFS_LI_IN_AIL) { 3541da177e4SLinus Torvalds ailp = &(mp->m_ail); 3551da177e4SLinus Torvalds mlip = xfs_ail_min(ailp); 3561da177e4SLinus Torvalds dlip = xfs_ail_delete(ailp, lip); 3571da177e4SLinus Torvalds ASSERT(dlip == lip); 3581da177e4SLinus Torvalds 3591da177e4SLinus Torvalds 3601da177e4SLinus Torvalds lip->li_flags &= ~XFS_LI_IN_AIL; 3611da177e4SLinus Torvalds lip->li_lsn = 0; 3621da177e4SLinus Torvalds mp->m_ail_gen++; 3631da177e4SLinus Torvalds 3641da177e4SLinus Torvalds if (mlip == dlip) { 3651da177e4SLinus Torvalds mlip = xfs_ail_min(&(mp->m_ail)); 3661da177e4SLinus Torvalds AIL_UNLOCK(mp, s); 3671da177e4SLinus Torvalds xfs_log_move_tail(mp, (mlip ? mlip->li_lsn : 0)); 3681da177e4SLinus Torvalds } else { 3691da177e4SLinus Torvalds AIL_UNLOCK(mp, s); 3701da177e4SLinus Torvalds } 3711da177e4SLinus Torvalds } 3721da177e4SLinus Torvalds else { 3731da177e4SLinus Torvalds /* 3741da177e4SLinus Torvalds * If the file system is not being shutdown, we are in 3751da177e4SLinus Torvalds * serious trouble if we get to this stage. 3761da177e4SLinus Torvalds */ 3771da177e4SLinus Torvalds if (XFS_FORCED_SHUTDOWN(mp)) 3781da177e4SLinus Torvalds AIL_UNLOCK(mp, s); 3791da177e4SLinus Torvalds else { 3801da177e4SLinus Torvalds xfs_cmn_err(XFS_PTAG_AILDELETE, CE_ALERT, mp, 3811da177e4SLinus Torvalds "xfs_trans_delete_ail: attempting to delete a log item that is not in the AIL"); 3821da177e4SLinus Torvalds xfs_force_shutdown(mp, XFS_CORRUPT_INCORE); 3831da177e4SLinus Torvalds AIL_UNLOCK(mp, s); 3841da177e4SLinus Torvalds } 3851da177e4SLinus Torvalds } 3861da177e4SLinus Torvalds } 3871da177e4SLinus Torvalds 3881da177e4SLinus Torvalds 3891da177e4SLinus Torvalds 3901da177e4SLinus Torvalds /* 3911da177e4SLinus Torvalds * Return the item in the AIL with the smallest lsn. 3921da177e4SLinus Torvalds * Return the current tree generation number for use 3931da177e4SLinus Torvalds * in calls to xfs_trans_next_ail(). 3941da177e4SLinus Torvalds */ 3951da177e4SLinus Torvalds xfs_log_item_t * 3961da177e4SLinus Torvalds xfs_trans_first_ail( 3971da177e4SLinus Torvalds xfs_mount_t *mp, 3981da177e4SLinus Torvalds int *gen) 3991da177e4SLinus Torvalds { 4001da177e4SLinus Torvalds xfs_log_item_t *lip; 4011da177e4SLinus Torvalds 4021da177e4SLinus Torvalds lip = xfs_ail_min(&(mp->m_ail)); 4031da177e4SLinus Torvalds *gen = (int)mp->m_ail_gen; 4041da177e4SLinus Torvalds 4051da177e4SLinus Torvalds return (lip); 4061da177e4SLinus Torvalds } 4071da177e4SLinus Torvalds 4081da177e4SLinus Torvalds /* 4091da177e4SLinus Torvalds * If the generation count of the tree has not changed since the 4101da177e4SLinus Torvalds * caller last took something from the AIL, then return the elmt 4111da177e4SLinus Torvalds * in the tree which follows the one given. If the count has changed, 4121da177e4SLinus Torvalds * then return the minimum elmt of the AIL and bump the restarts counter 4131da177e4SLinus Torvalds * if one is given. 4141da177e4SLinus Torvalds */ 4151da177e4SLinus Torvalds xfs_log_item_t * 4161da177e4SLinus Torvalds xfs_trans_next_ail( 4171da177e4SLinus Torvalds xfs_mount_t *mp, 4181da177e4SLinus Torvalds xfs_log_item_t *lip, 4191da177e4SLinus Torvalds int *gen, 4201da177e4SLinus Torvalds int *restarts) 4211da177e4SLinus Torvalds { 4221da177e4SLinus Torvalds xfs_log_item_t *nlip; 4231da177e4SLinus Torvalds 4241da177e4SLinus Torvalds ASSERT(mp && lip && gen); 4251da177e4SLinus Torvalds if (mp->m_ail_gen == *gen) { 4261da177e4SLinus Torvalds nlip = xfs_ail_next(&(mp->m_ail), lip); 4271da177e4SLinus Torvalds } else { 4281da177e4SLinus Torvalds nlip = xfs_ail_min(&(mp->m_ail)); 4291da177e4SLinus Torvalds *gen = (int)mp->m_ail_gen; 4301da177e4SLinus Torvalds if (restarts != NULL) { 4311da177e4SLinus Torvalds XFS_STATS_INC(xs_push_ail_restarts); 4321da177e4SLinus Torvalds (*restarts)++; 4331da177e4SLinus Torvalds } 4341da177e4SLinus Torvalds } 4351da177e4SLinus Torvalds 4361da177e4SLinus Torvalds return (nlip); 4371da177e4SLinus Torvalds } 4381da177e4SLinus Torvalds 4391da177e4SLinus Torvalds 4401da177e4SLinus Torvalds /* 4411da177e4SLinus Torvalds * The active item list (AIL) is a doubly linked list of log 4421da177e4SLinus Torvalds * items sorted by ascending lsn. The base of the list is 4431da177e4SLinus Torvalds * a forw/back pointer pair embedded in the xfs mount structure. 4441da177e4SLinus Torvalds * The base is initialized with both pointers pointing to the 4451da177e4SLinus Torvalds * base. This case always needs to be distinguished, because 4461da177e4SLinus Torvalds * the base has no lsn to look at. We almost always insert 4471da177e4SLinus Torvalds * at the end of the list, so on inserts we search from the 4481da177e4SLinus Torvalds * end of the list to find where the new item belongs. 4491da177e4SLinus Torvalds */ 4501da177e4SLinus Torvalds 4511da177e4SLinus Torvalds /* 4521da177e4SLinus Torvalds * Initialize the doubly linked list to point only to itself. 4531da177e4SLinus Torvalds */ 4541da177e4SLinus Torvalds void 4551da177e4SLinus Torvalds xfs_trans_ail_init( 4561da177e4SLinus Torvalds xfs_mount_t *mp) 4571da177e4SLinus Torvalds { 4581da177e4SLinus Torvalds mp->m_ail.ail_forw = (xfs_log_item_t*)&(mp->m_ail); 4591da177e4SLinus Torvalds mp->m_ail.ail_back = (xfs_log_item_t*)&(mp->m_ail); 4601da177e4SLinus Torvalds } 4611da177e4SLinus Torvalds 4621da177e4SLinus Torvalds /* 4631da177e4SLinus Torvalds * Insert the given log item into the AIL. 4641da177e4SLinus Torvalds * We almost always insert at the end of the list, so on inserts 4651da177e4SLinus Torvalds * we search from the end of the list to find where the 4661da177e4SLinus Torvalds * new item belongs. 4671da177e4SLinus Torvalds */ 4681da177e4SLinus Torvalds STATIC void 4691da177e4SLinus Torvalds xfs_ail_insert( 4701da177e4SLinus Torvalds xfs_ail_entry_t *base, 4711da177e4SLinus Torvalds xfs_log_item_t *lip) 4721da177e4SLinus Torvalds /* ARGSUSED */ 4731da177e4SLinus Torvalds { 4741da177e4SLinus Torvalds xfs_log_item_t *next_lip; 4751da177e4SLinus Torvalds 4761da177e4SLinus Torvalds /* 4771da177e4SLinus Torvalds * If the list is empty, just insert the item. 4781da177e4SLinus Torvalds */ 4791da177e4SLinus Torvalds if (base->ail_back == (xfs_log_item_t*)base) { 4801da177e4SLinus Torvalds base->ail_forw = lip; 4811da177e4SLinus Torvalds base->ail_back = lip; 4821da177e4SLinus Torvalds lip->li_ail.ail_forw = (xfs_log_item_t*)base; 4831da177e4SLinus Torvalds lip->li_ail.ail_back = (xfs_log_item_t*)base; 4841da177e4SLinus Torvalds return; 4851da177e4SLinus Torvalds } 4861da177e4SLinus Torvalds 4871da177e4SLinus Torvalds next_lip = base->ail_back; 4881da177e4SLinus Torvalds while ((next_lip != (xfs_log_item_t*)base) && 4891da177e4SLinus Torvalds (XFS_LSN_CMP(next_lip->li_lsn, lip->li_lsn) > 0)) { 4901da177e4SLinus Torvalds next_lip = next_lip->li_ail.ail_back; 4911da177e4SLinus Torvalds } 4921da177e4SLinus Torvalds ASSERT((next_lip == (xfs_log_item_t*)base) || 4931da177e4SLinus Torvalds (XFS_LSN_CMP(next_lip->li_lsn, lip->li_lsn) <= 0)); 4941da177e4SLinus Torvalds lip->li_ail.ail_forw = next_lip->li_ail.ail_forw; 4951da177e4SLinus Torvalds lip->li_ail.ail_back = next_lip; 4961da177e4SLinus Torvalds next_lip->li_ail.ail_forw = lip; 4971da177e4SLinus Torvalds lip->li_ail.ail_forw->li_ail.ail_back = lip; 4981da177e4SLinus Torvalds 4991da177e4SLinus Torvalds xfs_ail_check(base); 5001da177e4SLinus Torvalds return; 5011da177e4SLinus Torvalds } 5021da177e4SLinus Torvalds 5031da177e4SLinus Torvalds /* 5041da177e4SLinus Torvalds * Delete the given item from the AIL. Return a pointer to the item. 5051da177e4SLinus Torvalds */ 5061da177e4SLinus Torvalds /*ARGSUSED*/ 5071da177e4SLinus Torvalds STATIC xfs_log_item_t * 5081da177e4SLinus Torvalds xfs_ail_delete( 5091da177e4SLinus Torvalds xfs_ail_entry_t *base, 5101da177e4SLinus Torvalds xfs_log_item_t *lip) 5111da177e4SLinus Torvalds /* ARGSUSED */ 5121da177e4SLinus Torvalds { 5131da177e4SLinus Torvalds lip->li_ail.ail_forw->li_ail.ail_back = lip->li_ail.ail_back; 5141da177e4SLinus Torvalds lip->li_ail.ail_back->li_ail.ail_forw = lip->li_ail.ail_forw; 5151da177e4SLinus Torvalds lip->li_ail.ail_forw = NULL; 5161da177e4SLinus Torvalds lip->li_ail.ail_back = NULL; 5171da177e4SLinus Torvalds 5181da177e4SLinus Torvalds xfs_ail_check(base); 5191da177e4SLinus Torvalds return lip; 5201da177e4SLinus Torvalds } 5211da177e4SLinus Torvalds 5221da177e4SLinus Torvalds /* 5231da177e4SLinus Torvalds * Return a pointer to the first item in the AIL. 5241da177e4SLinus Torvalds * If the AIL is empty, then return NULL. 5251da177e4SLinus Torvalds */ 5261da177e4SLinus Torvalds STATIC xfs_log_item_t * 5271da177e4SLinus Torvalds xfs_ail_min( 5281da177e4SLinus Torvalds xfs_ail_entry_t *base) 5291da177e4SLinus Torvalds /* ARGSUSED */ 5301da177e4SLinus Torvalds { 5311da177e4SLinus Torvalds register xfs_log_item_t *forw = base->ail_forw; 5321da177e4SLinus Torvalds if (forw == (xfs_log_item_t*)base) { 5331da177e4SLinus Torvalds return NULL; 5341da177e4SLinus Torvalds } 5351da177e4SLinus Torvalds return forw; 5361da177e4SLinus Torvalds } 5371da177e4SLinus Torvalds 5381da177e4SLinus Torvalds /* 5391da177e4SLinus Torvalds * Return a pointer to the item which follows 5401da177e4SLinus Torvalds * the given item in the AIL. If the given item 5411da177e4SLinus Torvalds * is the last item in the list, then return NULL. 5421da177e4SLinus Torvalds */ 5431da177e4SLinus Torvalds STATIC xfs_log_item_t * 5441da177e4SLinus Torvalds xfs_ail_next( 5451da177e4SLinus Torvalds xfs_ail_entry_t *base, 5461da177e4SLinus Torvalds xfs_log_item_t *lip) 5471da177e4SLinus Torvalds /* ARGSUSED */ 5481da177e4SLinus Torvalds { 5491da177e4SLinus Torvalds if (lip->li_ail.ail_forw == (xfs_log_item_t*)base) { 5501da177e4SLinus Torvalds return NULL; 5511da177e4SLinus Torvalds } 5521da177e4SLinus Torvalds return lip->li_ail.ail_forw; 5531da177e4SLinus Torvalds 5541da177e4SLinus Torvalds } 5551da177e4SLinus Torvalds 5561da177e4SLinus Torvalds #ifdef DEBUG 5571da177e4SLinus Torvalds /* 5581da177e4SLinus Torvalds * Check that the list is sorted as it should be. 5591da177e4SLinus Torvalds */ 5601da177e4SLinus Torvalds STATIC void 5611da177e4SLinus Torvalds xfs_ail_check( 5621da177e4SLinus Torvalds xfs_ail_entry_t *base) 5631da177e4SLinus Torvalds { 5641da177e4SLinus Torvalds xfs_log_item_t *lip; 5651da177e4SLinus Torvalds xfs_log_item_t *prev_lip; 5661da177e4SLinus Torvalds 5671da177e4SLinus Torvalds lip = base->ail_forw; 5681da177e4SLinus Torvalds if (lip == (xfs_log_item_t*)base) { 5691da177e4SLinus Torvalds /* 5701da177e4SLinus Torvalds * Make sure the pointers are correct when the list 5711da177e4SLinus Torvalds * is empty. 5721da177e4SLinus Torvalds */ 5731da177e4SLinus Torvalds ASSERT(base->ail_back == (xfs_log_item_t*)base); 5741da177e4SLinus Torvalds return; 5751da177e4SLinus Torvalds } 5761da177e4SLinus Torvalds 5771da177e4SLinus Torvalds /* 5781da177e4SLinus Torvalds * Walk the list checking forward and backward pointers, 5791da177e4SLinus Torvalds * lsn ordering, and that every entry has the XFS_LI_IN_AIL 5801da177e4SLinus Torvalds * flag set. 5811da177e4SLinus Torvalds */ 5821da177e4SLinus Torvalds prev_lip = (xfs_log_item_t*)base; 5831da177e4SLinus Torvalds while (lip != (xfs_log_item_t*)base) { 5841da177e4SLinus Torvalds if (prev_lip != (xfs_log_item_t*)base) { 5851da177e4SLinus Torvalds ASSERT(prev_lip->li_ail.ail_forw == lip); 5861da177e4SLinus Torvalds ASSERT(XFS_LSN_CMP(prev_lip->li_lsn, lip->li_lsn) <= 0); 5871da177e4SLinus Torvalds } 5881da177e4SLinus Torvalds ASSERT(lip->li_ail.ail_back == prev_lip); 5891da177e4SLinus Torvalds ASSERT((lip->li_flags & XFS_LI_IN_AIL) != 0); 5901da177e4SLinus Torvalds prev_lip = lip; 5911da177e4SLinus Torvalds lip = lip->li_ail.ail_forw; 5921da177e4SLinus Torvalds } 5931da177e4SLinus Torvalds ASSERT(lip == (xfs_log_item_t*)base); 5941da177e4SLinus Torvalds ASSERT(base->ail_back == prev_lip); 5951da177e4SLinus Torvalds } 5961da177e4SLinus Torvalds #endif /* DEBUG */ 597