/* * like unpin only we have to also clear the xaction descriptor * pointing the log item if we free the item. This routine duplicates * unpin because efi_flags is protected by the AIL lock. Freeing * the descriptor and then calling unpin would force us to drop the AIL * lock which would open up a race condition. */ STATIC void xfs_efi_item_unpin_remove(xfs_efi_log_item_t *efip, xfs_trans_t *tp) { xfs_mount_t *mp; xfs_log_item_desc_t *lidp; SPLDECL(s); mp = efip->efi_item.li_mountp; AIL_LOCK(mp, s); if (efip->efi_flags & XFS_EFI_CANCELED) { /* * free the xaction descriptor pointing to this item */ lidp = xfs_trans_find_item(tp, (xfs_log_item_t *) efip); xfs_trans_free_item(tp, lidp); /* * pull the item off the AIL. * xfs_trans_delete_ail() drops the AIL lock. */ xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip, s); xfs_efi_item_free(efip); } else { efip->efi_flags |= XFS_EFI_COMMITTED; AIL_UNLOCK(mp, s); } }
/* * This is called to mark the fields indicated in fieldmask as needing * to be logged when the transaction is committed. The inode must * already be associated with the given transaction. * * The values for fieldmask are defined in xfs_inode_item.h. We always * log all of the core inode if any of it has changed, and we always log * all of the inline data/extents/b-tree root if any of them has changed. */ void xfs_trans_log_inode( xfs_trans_t *tp, xfs_inode_t *ip, uint flags) { xfs_log_item_desc_t *lidp; ASSERT(ip->i_transp == tp); ASSERT(ip->i_itemp != NULL); ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE)); lidp = xfs_trans_find_item(tp, (xfs_log_item_t*)(ip->i_itemp)); ASSERT(lidp != NULL); tp->t_flags |= XFS_TRANS_DIRTY; lidp->lid_flags |= XFS_LID_DIRTY; /* * Always OR in the bits from the ili_last_fields field. * This is to coordinate with the xfs_iflush() and xfs_iflush_done() * routines in the eventual clearing of the ilf_fields bits. * See the big comment in xfs_iflush() for an explanation of * this coorination mechanism. */ flags |= ip->i_itemp->ili_last_fields; ip->i_itemp->ili_format.ilf_fields |= flags; }
/* * This is called to mark the quotaoff logitem as needing * to be logged when the transaction is committed. The logitem must * already be associated with the given transaction. */ void xfs_trans_log_quotaoff_item( xfs_trans_t *tp, xfs_qoff_logitem_t *qlp) { xfs_log_item_desc_t *lidp; lidp = xfs_trans_find_item(tp, (xfs_log_item_t *)qlp); ASSERT(lidp != NULL); tp->t_flags |= XFS_TRANS_DIRTY; lidp->lid_flags |= XFS_LID_DIRTY; }
/* * This is called to mark the dquot as needing * to be logged when the transaction is committed. The dquot must * already be associated with the given transaction. * Note that it marks the entire transaction as dirty. In the ordinary * case, this gets called via xfs_trans_commit, after the transaction * is already dirty. However, there's nothing stop this from getting * called directly, as done by xfs_qm_scall_setqlim. Hence, the TRANS_DIRTY * flag. */ void xfs_trans_log_dquot( xfs_trans_t *tp, xfs_dquot_t *dqp) { xfs_log_item_desc_t *lidp; ASSERT(dqp->q_transp == tp); ASSERT(XFS_DQ_IS_LOCKED(dqp)); lidp = xfs_trans_find_item(tp, (xfs_log_item_t*)(&dqp->q_logitem)); ASSERT(lidp != NULL); tp->t_flags |= XFS_TRANS_DIRTY; lidp->lid_flags |= XFS_LID_DIRTY; }
/* * like unpin only we have to also clear the xaction descriptor * pointing the log item if we free the item. This routine duplicates * unpin because efi_flags is protected by the AIL lock. Freeing * the descriptor and then calling unpin would force us to drop the AIL * lock which would open up a race condition. */ STATIC void xfs_efi_item_unpin_remove(xfs_efi_log_item_t *efip, xfs_trans_t *tp) { int nexts; int size; xfs_mount_t *mp; xfs_log_item_desc_t *lidp; SPLDECL(s); mp = efip->efi_item.li_mountp; AIL_LOCK(mp, s); if (efip->efi_flags & XFS_EFI_CANCELED) { /* * free the xaction descriptor pointing to this item */ lidp = xfs_trans_find_item(tp, (xfs_log_item_t *) efip); xfs_trans_free_item(tp, lidp); /* * pull the item off the AIL. * xfs_trans_delete_ail() drops the AIL lock. */ xfs_trans_delete_ail(mp, (xfs_log_item_t *)efip, s); /* * now free the item itself */ nexts = efip->efi_format.efi_nextents; if (nexts > XFS_EFI_MAX_FAST_EXTENTS) { size = sizeof(xfs_efi_log_item_t); size += (nexts - 1) * sizeof(xfs_extent_t); kmem_free(efip, size); } else { kmem_zone_free(xfs_efi_zone, efip); } } else { efip->efi_flags |= XFS_EFI_COMMITTED; AIL_UNLOCK(mp, s); } return; }
/* * like unpin only we have to also clear the xaction descriptor * pointing the log item if we free the item. This routine duplicates * unpin because efi_flags is protected by the AIL lock. Freeing * the descriptor and then calling unpin would force us to drop the AIL * lock which would open up a race condition. */ STATIC void xfs_efi_item_unpin_remove(xfs_efi_log_item_t *efip, xfs_trans_t *tp) { struct xfs_ail *ailp = efip->efi_item.li_ailp; xfs_log_item_desc_t *lidp; spin_lock(&ailp->xa_lock); if (efip->efi_flags & XFS_EFI_CANCELED) { /* * free the xaction descriptor pointing to this item */ lidp = xfs_trans_find_item(tp, (xfs_log_item_t *) efip); xfs_trans_free_item(tp, lidp); /* xfs_trans_ail_delete() drops the AIL lock. */ xfs_trans_ail_delete(ailp, (xfs_log_item_t *)efip); xfs_efi_item_free(efip); } else { efip->efi_flags |= XFS_EFI_COMMITTED; spin_unlock(&ailp->xa_lock); } }
/* * This routine is called to indicate that the described * extent is to be logged as needing to be freed. It should * be called once for each extent to be freed. */ void xfs_trans_log_efi_extent(xfs_trans_t *tp, xfs_efi_log_item_t *efip, xfs_fsblock_t start_block, xfs_extlen_t ext_len) { xfs_log_item_desc_t *lidp; uint next_extent; xfs_extent_t *extp; lidp = xfs_trans_find_item(tp, (xfs_log_item_t*)efip); ASSERT(lidp != NULL); tp->t_flags |= XFS_TRANS_DIRTY; lidp->lid_flags |= XFS_LID_DIRTY; next_extent = efip->efi_next_extent; ASSERT(next_extent < efip->efi_format.efi_nextents); extp = &(efip->efi_format.efi_extents[next_extent]); extp->ext_start = start_block; extp->ext_len = ext_len; efip->efi_next_extent++; }
/* * Release the inode ip which was previously acquired with xfs_trans_iget() * or added with xfs_trans_ijoin(). This will decrement the lock * recursion count of the inode item. If the count goes to less than 0, * the inode will be unlocked and disassociated from the transaction. * * If the inode has been modified within the transaction, it will not be * unlocked until the transaction commits. */ void xfs_trans_iput( xfs_trans_t *tp, xfs_inode_t *ip, uint lock_flags) { xfs_inode_log_item_t *iip; xfs_log_item_desc_t *lidp; /* * If the transaction pointer is NULL, just call xfs_iput(). */ if (tp == NULL) { xfs_iput(ip, lock_flags); } ASSERT(ip->i_transp == tp); iip = ip->i_itemp; ASSERT(iip != NULL); /* * Find the item descriptor pointing to this inode's * log item. It must be there. */ lidp = xfs_trans_find_item(tp, (xfs_log_item_t*)iip); ASSERT(lidp != NULL); ASSERT(lidp->lid_item == (xfs_log_item_t*)iip); /* * Be consistent about the bookkeeping for the inode's * io lock, but it doesn't mean much really. */ ASSERT((iip->ili_flags & XFS_ILI_IOLOCKED_ANY) != XFS_ILI_IOLOCKED_ANY); if (lock_flags & (XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED)) { ASSERT(iip->ili_flags & XFS_ILI_IOLOCKED_ANY); ASSERT((!(lock_flags & XFS_IOLOCK_EXCL)) || (iip->ili_flags & XFS_ILI_IOLOCKED_EXCL)); ASSERT((!(lock_flags & XFS_IOLOCK_SHARED)) || (iip->ili_flags & (XFS_ILI_IOLOCKED_EXCL | XFS_ILI_IOLOCKED_SHARED))); if (iip->ili_iolock_recur > 0) { iip->ili_iolock_recur--; } } /* * If the release is just for a recursive lock on the inode lock, * then decrement the count and return. We can assert that * the caller is dropping an EXCL lock on the inode, because * inode must be locked EXCL within transactions. */ ASSERT(lock_flags & XFS_ILOCK_EXCL); if (iip->ili_ilock_recur > 0) { iip->ili_ilock_recur--; return; } ASSERT(iip->ili_iolock_recur == 0); /* * If the inode was dirtied within this transaction, it cannot * be released until the transaction commits. */ if (lidp->lid_flags & XFS_LID_DIRTY) { return; } xfs_trans_free_item(tp, lidp); /* * Clear the hold and iolocked flags in the inode log item. * We wouldn't want the next user of the inode to * get confused. Assert that if the iolocked flag is set * in the item then we are unlocking it in the call to xfs_iput() * below. */ ASSERT((!(iip->ili_flags & XFS_ILI_IOLOCKED_ANY)) || (lock_flags & (XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED))); if (iip->ili_flags & (XFS_ILI_HOLD | XFS_ILI_IOLOCKED_ANY)) { iip->ili_flags &= ~(XFS_ILI_HOLD | XFS_ILI_IOLOCKED_ANY); } /* * Unlike xfs_brelse() the inode log item cannot be * freed, because it is embedded within the inode. * All we have to do is release the inode. */ xfs_iput(ip, lock_flags); return; }