Lines Matching +full:down +full:- +full:counters
1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
69 xfs_extent_busy_sort(&tp->t_busy); in xfs_trans_free()
70 xfs_extent_busy_clear(tp->t_mountp, &tp->t_busy, false); in xfs_trans_free()
74 if (!(tp->t_flags & XFS_TRANS_NO_WRITECOUNT)) in xfs_trans_free()
75 sb_end_intwrite(tp->t_mountp->m_super); in xfs_trans_free()
101 ntp->t_magic = XFS_TRANS_HEADER_MAGIC; in xfs_trans_dup()
102 ntp->t_mountp = tp->t_mountp; in xfs_trans_dup()
103 INIT_LIST_HEAD(&ntp->t_items); in xfs_trans_dup()
104 INIT_LIST_HEAD(&ntp->t_busy); in xfs_trans_dup()
105 INIT_LIST_HEAD(&ntp->t_dfops); in xfs_trans_dup()
106 ntp->t_highest_agno = NULLAGNUMBER; in xfs_trans_dup()
108 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES); in xfs_trans_dup()
109 ASSERT(tp->t_ticket != NULL); in xfs_trans_dup()
111 ntp->t_flags = XFS_TRANS_PERM_LOG_RES | in xfs_trans_dup()
112 (tp->t_flags & XFS_TRANS_RESERVE) | in xfs_trans_dup()
113 (tp->t_flags & XFS_TRANS_NO_WRITECOUNT) | in xfs_trans_dup()
114 (tp->t_flags & XFS_TRANS_RES_FDBLKS); in xfs_trans_dup()
116 tp->t_flags |= XFS_TRANS_NO_WRITECOUNT; in xfs_trans_dup()
117 ntp->t_ticket = xfs_log_ticket_get(tp->t_ticket); in xfs_trans_dup()
119 ASSERT(tp->t_blk_res >= tp->t_blk_res_used); in xfs_trans_dup()
120 ntp->t_blk_res = tp->t_blk_res - tp->t_blk_res_used; in xfs_trans_dup()
121 tp->t_blk_res = tp->t_blk_res_used; in xfs_trans_dup()
123 ntp->t_rtx_res = tp->t_rtx_res - tp->t_rtx_res_used; in xfs_trans_dup()
124 tp->t_rtx_res = tp->t_rtx_res_used; in xfs_trans_dup()
156 struct xfs_mount *mp = tp->t_mountp; in xfs_trans_reserve()
158 bool rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0; in xfs_trans_reserve()
168 return -ENOSPC; in xfs_trans_reserve()
169 tp->t_blk_res += blocks; in xfs_trans_reserve()
175 if (resp->tr_logres > 0) { in xfs_trans_reserve()
178 ASSERT(tp->t_log_res == 0 || in xfs_trans_reserve()
179 tp->t_log_res == resp->tr_logres); in xfs_trans_reserve()
180 ASSERT(tp->t_log_count == 0 || in xfs_trans_reserve()
181 tp->t_log_count == resp->tr_logcount); in xfs_trans_reserve()
183 if (resp->tr_logflags & XFS_TRANS_PERM_LOG_RES) { in xfs_trans_reserve()
184 tp->t_flags |= XFS_TRANS_PERM_LOG_RES; in xfs_trans_reserve()
187 ASSERT(tp->t_ticket == NULL); in xfs_trans_reserve()
188 ASSERT(!(tp->t_flags & XFS_TRANS_PERM_LOG_RES)); in xfs_trans_reserve()
191 if (tp->t_ticket != NULL) { in xfs_trans_reserve()
192 ASSERT(resp->tr_logflags & XFS_TRANS_PERM_LOG_RES); in xfs_trans_reserve()
193 error = xfs_log_regrant(mp, tp->t_ticket); in xfs_trans_reserve()
195 error = xfs_log_reserve(mp, resp->tr_logres, in xfs_trans_reserve()
196 resp->tr_logcount, in xfs_trans_reserve()
197 &tp->t_ticket, permanent); in xfs_trans_reserve()
203 tp->t_log_res = resp->tr_logres; in xfs_trans_reserve()
204 tp->t_log_count = resp->tr_logcount; in xfs_trans_reserve()
215 error = -ENOSPC; in xfs_trans_reserve()
218 tp->t_rtx_res += rtextents; in xfs_trans_reserve()
228 if (resp->tr_logres > 0) { in xfs_trans_reserve()
229 xfs_log_ticket_ungrant(mp->m_log, tp->t_ticket); in xfs_trans_reserve()
230 tp->t_ticket = NULL; in xfs_trans_reserve()
231 tp->t_log_res = 0; in xfs_trans_reserve()
232 tp->t_flags &= ~XFS_TRANS_PERM_LOG_RES; in xfs_trans_reserve()
238 tp->t_blk_res = 0; in xfs_trans_reserve()
264 sb_start_intwrite(mp->m_super); in xfs_trans_alloc()
268 * Zero-reservation ("empty") transactions can't modify anything, so in xfs_trans_alloc()
271 WARN_ON(resp->tr_logres > 0 && in xfs_trans_alloc()
272 mp->m_super->s_writers.frozen == SB_FREEZE_COMPLETE); in xfs_trans_alloc()
276 tp->t_magic = XFS_TRANS_HEADER_MAGIC; in xfs_trans_alloc()
277 tp->t_flags = flags; in xfs_trans_alloc()
278 tp->t_mountp = mp; in xfs_trans_alloc()
279 INIT_LIST_HEAD(&tp->t_items); in xfs_trans_alloc()
280 INIT_LIST_HEAD(&tp->t_busy); in xfs_trans_alloc()
281 INIT_LIST_HEAD(&tp->t_dfops); in xfs_trans_alloc()
282 tp->t_highest_agno = NULLAGNUMBER; in xfs_trans_alloc()
285 if (error == -ENOSPC && want_retry) { in xfs_trans_alloc()
313 * mechanism for routines that query metadata without actually modifying them --
314 * if the metadata being queried is somehow cross-linked (think a btree block
316 * grabbed as part of a transaction can be re-grabbed. The verifiers will
320 * Note the zero-length reservation; this transaction MUST be cancelled without
360 xfs_mount_t *mp = tp->t_mountp; in xfs_trans_mod_sb()
364 tp->t_icount_delta += delta; in xfs_trans_mod_sb()
369 tp->t_ifree_delta += delta; in xfs_trans_mod_sb()
380 tp->t_blk_res_used += (uint)-delta; in xfs_trans_mod_sb()
381 if (tp->t_blk_res_used > tp->t_blk_res) in xfs_trans_mod_sb()
383 } else if (delta > 0 && (tp->t_flags & XFS_TRANS_RES_FDBLKS)) { in xfs_trans_mod_sb()
394 UINT_MAX - tp->t_blk_res); in xfs_trans_mod_sb()
395 tp->t_blk_res += blkres_delta; in xfs_trans_mod_sb()
396 delta -= blkres_delta; in xfs_trans_mod_sb()
398 tp->t_fdblocks_delta += delta; in xfs_trans_mod_sb()
405 * in-core superblock's counter. This should only in xfs_trans_mod_sb()
406 * be applied to the on-disk superblock. in xfs_trans_mod_sb()
408 tp->t_res_fdblocks_delta += delta; in xfs_trans_mod_sb()
419 tp->t_rtx_res_used += (uint)-delta; in xfs_trans_mod_sb()
420 ASSERT(tp->t_rtx_res_used <= tp->t_rtx_res); in xfs_trans_mod_sb()
422 tp->t_frextents_delta += delta; in xfs_trans_mod_sb()
427 * in-core superblock's counter. This should only in xfs_trans_mod_sb()
428 * be applied to the on-disk superblock. in xfs_trans_mod_sb()
431 tp->t_res_frextents_delta += delta; in xfs_trans_mod_sb()
434 tp->t_dblocks_delta += delta; in xfs_trans_mod_sb()
438 tp->t_agcount_delta += delta; in xfs_trans_mod_sb()
441 tp->t_imaxpct_delta += delta; in xfs_trans_mod_sb()
444 tp->t_rextsize_delta += delta; in xfs_trans_mod_sb()
447 tp->t_rbmblocks_delta += delta; in xfs_trans_mod_sb()
450 tp->t_rblocks_delta += delta; in xfs_trans_mod_sb()
453 tp->t_rextents_delta += delta; in xfs_trans_mod_sb()
456 tp->t_rextslog_delta += delta; in xfs_trans_mod_sb()
463 tp->t_flags |= flags; in xfs_trans_mod_sb()
483 sbp = bp->b_addr; in xfs_trans_apply_sb_deltas()
486 * Only update the superblock counters if we are logging them in xfs_trans_apply_sb_deltas()
488 if (!xfs_has_lazysbcount((tp->t_mountp))) { in xfs_trans_apply_sb_deltas()
489 if (tp->t_icount_delta) in xfs_trans_apply_sb_deltas()
490 be64_add_cpu(&sbp->sb_icount, tp->t_icount_delta); in xfs_trans_apply_sb_deltas()
491 if (tp->t_ifree_delta) in xfs_trans_apply_sb_deltas()
492 be64_add_cpu(&sbp->sb_ifree, tp->t_ifree_delta); in xfs_trans_apply_sb_deltas()
493 if (tp->t_fdblocks_delta) in xfs_trans_apply_sb_deltas()
494 be64_add_cpu(&sbp->sb_fdblocks, tp->t_fdblocks_delta); in xfs_trans_apply_sb_deltas()
495 if (tp->t_res_fdblocks_delta) in xfs_trans_apply_sb_deltas()
496 be64_add_cpu(&sbp->sb_fdblocks, tp->t_res_fdblocks_delta); in xfs_trans_apply_sb_deltas()
501 * behave like the lazysb counters because we cannot rely on log in xfs_trans_apply_sb_deltas()
513 if (tp->t_frextents_delta || tp->t_res_frextents_delta) { in xfs_trans_apply_sb_deltas()
514 struct xfs_mount *mp = tp->t_mountp; in xfs_trans_apply_sb_deltas()
517 rtxdelta = tp->t_frextents_delta + tp->t_res_frextents_delta; in xfs_trans_apply_sb_deltas()
519 spin_lock(&mp->m_sb_lock); in xfs_trans_apply_sb_deltas()
520 be64_add_cpu(&sbp->sb_frextents, rtxdelta); in xfs_trans_apply_sb_deltas()
521 mp->m_sb.sb_frextents += rtxdelta; in xfs_trans_apply_sb_deltas()
522 spin_unlock(&mp->m_sb_lock); in xfs_trans_apply_sb_deltas()
525 if (tp->t_dblocks_delta) { in xfs_trans_apply_sb_deltas()
526 be64_add_cpu(&sbp->sb_dblocks, tp->t_dblocks_delta); in xfs_trans_apply_sb_deltas()
529 if (tp->t_agcount_delta) { in xfs_trans_apply_sb_deltas()
530 be32_add_cpu(&sbp->sb_agcount, tp->t_agcount_delta); in xfs_trans_apply_sb_deltas()
533 if (tp->t_imaxpct_delta) { in xfs_trans_apply_sb_deltas()
534 sbp->sb_imax_pct += tp->t_imaxpct_delta; in xfs_trans_apply_sb_deltas()
537 if (tp->t_rextsize_delta) { in xfs_trans_apply_sb_deltas()
538 be32_add_cpu(&sbp->sb_rextsize, tp->t_rextsize_delta); in xfs_trans_apply_sb_deltas()
541 if (tp->t_rbmblocks_delta) { in xfs_trans_apply_sb_deltas()
542 be32_add_cpu(&sbp->sb_rbmblocks, tp->t_rbmblocks_delta); in xfs_trans_apply_sb_deltas()
545 if (tp->t_rblocks_delta) { in xfs_trans_apply_sb_deltas()
546 be64_add_cpu(&sbp->sb_rblocks, tp->t_rblocks_delta); in xfs_trans_apply_sb_deltas()
549 if (tp->t_rextents_delta) { in xfs_trans_apply_sb_deltas()
550 be64_add_cpu(&sbp->sb_rextents, tp->t_rextents_delta); in xfs_trans_apply_sb_deltas()
553 if (tp->t_rextslog_delta) { in xfs_trans_apply_sb_deltas()
554 sbp->sb_rextslog += tp->t_rextslog_delta; in xfs_trans_apply_sb_deltas()
563 xfs_trans_log_buf(tp, bp, 0, sizeof(struct xfs_dsb) - 1); in xfs_trans_apply_sb_deltas()
571 sizeof(sbp->sb_frextents) - 1); in xfs_trans_apply_sb_deltas()
576 * apply superblock counter changes to the in-core superblock. The
578 * applied to the in-core superblock. The idea is that that has already been
581 * If we are not logging superblock counters, then the inode allocated/free and
586 * Deltas for the inode count are +/-64, hence we use a large batch size of 128
595 struct xfs_mount *mp = tp->t_mountp; in xfs_trans_unreserve_and_mod_sb()
596 int64_t blkdelta = tp->t_blk_res; in xfs_trans_unreserve_and_mod_sb()
597 int64_t rtxdelta = tp->t_rtx_res; in xfs_trans_unreserve_and_mod_sb()
606 * - positive values indicate blocks freed in the transaction. in xfs_trans_unreserve_and_mod_sb()
607 * - negative values indicate blocks allocated in the transaction in xfs_trans_unreserve_and_mod_sb()
614 ASSERT(tp->t_blk_res || tp->t_fdblocks_delta >= 0); in xfs_trans_unreserve_and_mod_sb()
615 if (xfs_has_lazysbcount(mp) || (tp->t_flags & XFS_TRANS_SB_DIRTY)) { in xfs_trans_unreserve_and_mod_sb()
616 blkdelta += tp->t_fdblocks_delta; in xfs_trans_unreserve_and_mod_sb()
620 ASSERT(tp->t_rtx_res || tp->t_frextents_delta >= 0); in xfs_trans_unreserve_and_mod_sb()
621 if (tp->t_flags & XFS_TRANS_SB_DIRTY) { in xfs_trans_unreserve_and_mod_sb()
622 rtxdelta += tp->t_frextents_delta; in xfs_trans_unreserve_and_mod_sb()
626 if (xfs_has_lazysbcount(mp) || (tp->t_flags & XFS_TRANS_SB_DIRTY)) { in xfs_trans_unreserve_and_mod_sb()
627 idelta = tp->t_icount_delta; in xfs_trans_unreserve_and_mod_sb()
628 ifreedelta = tp->t_ifree_delta; in xfs_trans_unreserve_and_mod_sb()
631 /* apply the per-cpu counters */ in xfs_trans_unreserve_and_mod_sb()
636 percpu_counter_add_batch(&mp->m_icount, idelta, in xfs_trans_unreserve_and_mod_sb()
640 percpu_counter_add(&mp->m_ifree, ifreedelta); in xfs_trans_unreserve_and_mod_sb()
645 if (!(tp->t_flags & XFS_TRANS_SB_DIRTY)) in xfs_trans_unreserve_and_mod_sb()
649 spin_lock(&mp->m_sb_lock); in xfs_trans_unreserve_and_mod_sb()
650 mp->m_sb.sb_fdblocks += tp->t_fdblocks_delta + tp->t_res_fdblocks_delta; in xfs_trans_unreserve_and_mod_sb()
651 mp->m_sb.sb_icount += idelta; in xfs_trans_unreserve_and_mod_sb()
652 mp->m_sb.sb_ifree += ifreedelta; in xfs_trans_unreserve_and_mod_sb()
655 * reservation. sb_frextents is not part of the lazy sb counters so it in xfs_trans_unreserve_and_mod_sb()
659 mp->m_sb.sb_dblocks += tp->t_dblocks_delta; in xfs_trans_unreserve_and_mod_sb()
660 mp->m_sb.sb_agcount += tp->t_agcount_delta; in xfs_trans_unreserve_and_mod_sb()
661 mp->m_sb.sb_imax_pct += tp->t_imaxpct_delta; in xfs_trans_unreserve_and_mod_sb()
662 mp->m_sb.sb_rextsize += tp->t_rextsize_delta; in xfs_trans_unreserve_and_mod_sb()
663 if (tp->t_rextsize_delta) { in xfs_trans_unreserve_and_mod_sb()
664 mp->m_rtxblklog = log2_if_power2(mp->m_sb.sb_rextsize); in xfs_trans_unreserve_and_mod_sb()
665 mp->m_rtxblkmask = mask64_if_power2(mp->m_sb.sb_rextsize); in xfs_trans_unreserve_and_mod_sb()
667 mp->m_sb.sb_rbmblocks += tp->t_rbmblocks_delta; in xfs_trans_unreserve_and_mod_sb()
668 mp->m_sb.sb_rblocks += tp->t_rblocks_delta; in xfs_trans_unreserve_and_mod_sb()
669 mp->m_sb.sb_rextents += tp->t_rextents_delta; in xfs_trans_unreserve_and_mod_sb()
670 mp->m_sb.sb_rextslog += tp->t_rextslog_delta; in xfs_trans_unreserve_and_mod_sb()
671 spin_unlock(&mp->m_sb_lock); in xfs_trans_unreserve_and_mod_sb()
677 ASSERT(mp->m_sb.sb_imax_pct >= 0); in xfs_trans_unreserve_and_mod_sb()
678 ASSERT(mp->m_sb.sb_rextslog >= 0); in xfs_trans_unreserve_and_mod_sb()
687 ASSERT(lip->li_log == tp->t_mountp->m_log); in xfs_trans_add_item()
688 ASSERT(lip->li_ailp == tp->t_mountp->m_ail); in xfs_trans_add_item()
689 ASSERT(list_empty(&lip->li_trans)); in xfs_trans_add_item()
690 ASSERT(!test_bit(XFS_LI_DIRTY, &lip->li_flags)); in xfs_trans_add_item()
692 list_add_tail(&lip->li_trans, &tp->t_items); in xfs_trans_add_item()
705 clear_bit(XFS_LI_DIRTY, &lip->li_flags); in xfs_trans_del_item()
706 list_del_init(&lip->li_trans); in xfs_trans_del_item()
719 list_for_each_entry_safe(lip, next, &tp->t_items, li_trans) { in xfs_trans_free_items()
722 set_bit(XFS_LI_ABORTED, &lip->li_flags); in xfs_trans_free_items()
723 if (lip->li_ops->iop_release) in xfs_trans_free_items()
724 lip->li_ops->iop_release(lip); in xfs_trans_free_items()
752 * If both items are non-sortable, leave them alone. If only one is in xfs_trans_precommit_sort()
753 * sortable, move the non-sortable item towards the end of the list. in xfs_trans_precommit_sort()
755 if (!lia->li_ops->iop_sort && !lib->li_ops->iop_sort) in xfs_trans_precommit_sort()
757 if (!lia->li_ops->iop_sort) in xfs_trans_precommit_sort()
759 if (!lib->li_ops->iop_sort) in xfs_trans_precommit_sort()
760 return -1; in xfs_trans_precommit_sort()
762 diff = lia->li_ops->iop_sort(lia) - lib->li_ops->iop_sort(lib); in xfs_trans_precommit_sort()
764 return -1; in xfs_trans_precommit_sort()
781 struct xfs_mount *mp = tp->t_mountp; in xfs_trans_run_precommits()
790 list_sort(NULL, &tp->t_items, xfs_trans_precommit_sort); in xfs_trans_run_precommits()
798 list_for_each_entry_safe(lip, n, &tp->t_items, li_trans) { in xfs_trans_run_precommits()
799 if (!test_bit(XFS_LI_DIRTY, &lip->li_flags)) in xfs_trans_run_precommits()
801 if (lip->li_ops->iop_precommit) { in xfs_trans_run_precommits()
802 error = lip->li_ops->iop_precommit(tp, lip); in xfs_trans_run_precommits()
818 * be durable - ie. committed to disk - because some metadata might
829 struct xfs_mount *mp = tp->t_mountp; in __xfs_trans_commit()
830 struct xlog *log = mp->m_log; in __xfs_trans_commit()
833 int sync = tp->t_flags & XFS_TRANS_SYNC; in __xfs_trans_commit()
839 if (tp->t_flags & XFS_TRANS_PERM_LOG_RES) in __xfs_trans_commit()
848 WARN_ON_ONCE(!list_empty(&tp->t_dfops) && in __xfs_trans_commit()
849 !(tp->t_flags & XFS_TRANS_PERM_LOG_RES)); in __xfs_trans_commit()
850 if (!regrant && (tp->t_flags & XFS_TRANS_PERM_LOG_RES)) { in __xfs_trans_commit()
868 if (!(tp->t_flags & XFS_TRANS_DIRTY)) in __xfs_trans_commit()
875 * disk, and that will lead to on-disk corruption. in __xfs_trans_commit()
878 error = -EIO; in __xfs_trans_commit()
882 ASSERT(tp->t_ticket != NULL); in __xfs_trans_commit()
887 if (tp->t_flags & XFS_TRANS_SB_DIRTY) in __xfs_trans_commit()
914 * (non-persistent) quota reservations that need to be unreserved. in __xfs_trans_commit()
917 if (tp->t_ticket) { in __xfs_trans_commit()
919 xfs_log_ticket_regrant(log, tp->t_ticket); in __xfs_trans_commit()
921 xfs_log_ticket_ungrant(log, tp->t_ticket); in __xfs_trans_commit()
922 tp->t_ticket = NULL; in __xfs_trans_commit()
940 * transaction is dirty, we must shut down the filesystem because there is no
948 * being shut down. However, if the mount has not been shut down and the
949 * transaction is dirty we will shut the mount down and, in doing so, that
950 * guarantees that the log is shut down, too. Hence we don't need to be as
958 struct xfs_mount *mp = tp->t_mountp; in xfs_trans_cancel()
959 struct xlog *log = mp->m_log; in xfs_trans_cancel()
960 bool dirty = (tp->t_flags & XFS_TRANS_DIRTY); in xfs_trans_cancel()
967 * loudly before freeing the in-memory defer items and shutting down the in xfs_trans_cancel()
970 if (!list_empty(&tp->t_dfops)) { in xfs_trans_cancel()
971 ASSERT(tp->t_flags & XFS_TRANS_PERM_LOG_RES); in xfs_trans_cancel()
977 * See if the caller is relying on us to shut down the filesystem. We in xfs_trans_cancel()
987 /* Log items need to be consistent until the log is shut down. */ in xfs_trans_cancel()
991 list_for_each_entry(lip, &tp->t_items, li_trans) in xfs_trans_cancel()
998 if (tp->t_ticket) { in xfs_trans_cancel()
999 xfs_log_ticket_ungrant(log, tp->t_ticket); in xfs_trans_cancel()
1000 tp->t_ticket = NULL; in xfs_trans_cancel()
1027 tres.tr_logres = trans->t_log_res; in xfs_trans_roll()
1028 tres.tr_logcount = trans->t_log_count; in xfs_trans_roll()
1058 * The caller must ensure that the on-disk dquots attached to this inode have
1072 struct xfs_mount *mp = ip->i_mount; in xfs_trans_alloc_inode()
1089 ASSERT(error != -ENOENT); in xfs_trans_alloc_inode()
1094 if ((error == -EDQUOT || error == -ENOSPC) && !retried) { in xfs_trans_alloc_inode()
1120 * without shutting down the fs.
1146 struct xfs_mount *mp = ip->i_mount; in xfs_trans_reserve_more_inode()
1156 if (!XFS_IS_QUOTA_ON(mp) || xfs_is_quota_inode(&mp->m_sb, ip->i_ino)) in xfs_trans_reserve_more_inode()
1159 if (tp->t_flags & XFS_TRANS_RESERVE) in xfs_trans_reserve_more_inode()
1169 tp->t_blk_res -= dblocks; in xfs_trans_reserve_more_inode()
1171 tp->t_rtx_res -= rtx; in xfs_trans_reserve_more_inode()
1199 if ((error == -EDQUOT || error == -ENOSPC) && !retried) { in xfs_trans_alloc_icreate()
1219 * The caller must ensure that the on-disk dquots attached to this inode have
1233 struct xfs_mount *mp = ip->i_mount; in xfs_trans_alloc_ichange()
1241 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp); in xfs_trans_alloc_ichange()
1251 ASSERT(error != -ENOENT); in xfs_trans_alloc_ichange()
1261 udqp = (new_udqp != ip->i_udquot) ? new_udqp : NULL; in xfs_trans_alloc_ichange()
1262 gdqp = (new_gdqp != ip->i_gdquot) ? new_gdqp : NULL; in xfs_trans_alloc_ichange()
1263 pdqp = (new_pdqp != ip->i_pdquot) ? new_pdqp : NULL; in xfs_trans_alloc_ichange()
1274 * though that part is only semi-transactional. in xfs_trans_alloc_ichange()
1277 pdqp, ip->i_nblocks + ip->i_delayed_blks, in xfs_trans_alloc_ichange()
1279 if ((error == -EDQUOT || error == -ENOSPC) && !retried) { in xfs_trans_alloc_ichange()
1304 * The caller must ensure that the on-disk dquots attached to this inode have
1320 struct xfs_mount *mp = ip->i_mount; in xfs_trans_alloc_dir()
1329 if (error == -ENOSPC) { in xfs_trans_alloc_dir()
1345 ASSERT(error != -ENOENT); in xfs_trans_alloc_dir()
1352 ASSERT(error != -ENOENT); in xfs_trans_alloc_dir()
1360 if (error == -EDQUOT || error == -ENOSPC) { in xfs_trans_alloc_dir()