10b61f8a4SDave Chinner // SPDX-License-Identifier: GPL-2.0+
23fd129b6SDarrick J. Wong /*
33fd129b6SDarrick J. Wong * Copyright (C) 2016 Oracle. All Rights Reserved.
43fd129b6SDarrick J. Wong * Author: Darrick J. Wong <darrick.wong@oracle.com>
53fd129b6SDarrick J. Wong */
63fd129b6SDarrick J. Wong #include "xfs.h"
73fd129b6SDarrick J. Wong #include "xfs_fs.h"
83fd129b6SDarrick J. Wong #include "xfs_shared.h"
93fd129b6SDarrick J. Wong #include "xfs_format.h"
103fd129b6SDarrick J. Wong #include "xfs_log_format.h"
113fd129b6SDarrick J. Wong #include "xfs_trans_resv.h"
123fd129b6SDarrick J. Wong #include "xfs_mount.h"
133fd129b6SDarrick J. Wong #include "xfs_alloc.h"
14e9e899a2SDarrick J. Wong #include "xfs_errortag.h"
153fd129b6SDarrick J. Wong #include "xfs_error.h"
163fd129b6SDarrick J. Wong #include "xfs_trace.h"
173fd129b6SDarrick J. Wong #include "xfs_trans.h"
183fd129b6SDarrick J. Wong #include "xfs_rmap_btree.h"
193fd129b6SDarrick J. Wong #include "xfs_btree.h"
2084d69619SDarrick J. Wong #include "xfs_refcount_btree.h"
2176d771b4SChristoph Hellwig #include "xfs_ialloc_btree.h"
229bbafc71SDave Chinner #include "xfs_ag.h"
235f213ddbSDarrick J. Wong #include "xfs_ag_resv.h"
243fd129b6SDarrick J. Wong
253fd129b6SDarrick J. Wong /*
263fd129b6SDarrick J. Wong * Per-AG Block Reservations
273fd129b6SDarrick J. Wong *
283fd129b6SDarrick J. Wong * For some kinds of allocation group metadata structures, it is advantageous
293fd129b6SDarrick J. Wong * to reserve a small number of blocks in each AG so that future expansions of
303fd129b6SDarrick J. Wong * that data structure do not encounter ENOSPC because errors during a btree
313fd129b6SDarrick J. Wong * split cause the filesystem to go offline.
323fd129b6SDarrick J. Wong *
333fd129b6SDarrick J. Wong * Prior to the introduction of reflink, this wasn't an issue because the free
343fd129b6SDarrick J. Wong * space btrees maintain a reserve of space (the AGFL) to handle any expansion
353fd129b6SDarrick J. Wong * that may be necessary; and allocations of other metadata (inodes, BMBT,
363fd129b6SDarrick J. Wong * dir/attr) aren't restricted to a single AG. However, with reflink it is
373fd129b6SDarrick J. Wong * possible to allocate all the space in an AG, have subsequent reflink/CoW
383fd129b6SDarrick J. Wong * activity expand the refcount btree, and discover that there's no space left
393fd129b6SDarrick J. Wong * to handle that expansion. Since we can calculate the maximum size of the
403fd129b6SDarrick J. Wong * refcount btree, we can reserve space for it and avoid ENOSPC.
413fd129b6SDarrick J. Wong *
423fd129b6SDarrick J. Wong * Handling per-AG reservations consists of three changes to the allocator's
433fd129b6SDarrick J. Wong * behavior: First, because these reservations are always needed, we decrease
443fd129b6SDarrick J. Wong * the ag_max_usable counter to reflect the size of the AG after the reserved
453fd129b6SDarrick J. Wong * blocks are taken. Second, the reservations must be reflected in the
463fd129b6SDarrick J. Wong * fdblocks count to maintain proper accounting. Third, each AG must maintain
473fd129b6SDarrick J. Wong * its own reserved block counter so that we can calculate the amount of space
483fd129b6SDarrick J. Wong * that must remain free to maintain the reservations. Fourth, the "remaining
493fd129b6SDarrick J. Wong * reserved blocks" count must be used when calculating the length of the
503fd129b6SDarrick J. Wong * longest free extent in an AG and to clamp maxlen in the per-AG allocation
513fd129b6SDarrick J. Wong * functions. In other words, we maintain a virtual allocation via in-core
523fd129b6SDarrick J. Wong * accounting tricks so that we don't have to clean up after a crash. :)
533fd129b6SDarrick J. Wong *
543fd129b6SDarrick J. Wong * Reserved blocks can be managed by passing one of the enum xfs_ag_resv_type
553fd129b6SDarrick J. Wong * values via struct xfs_alloc_arg or directly to the xfs_free_extent
563fd129b6SDarrick J. Wong * function. It might seem a little funny to maintain a reservoir of blocks
573fd129b6SDarrick J. Wong * to feed another reservoir, but the AGFL only holds enough blocks to get
583fd129b6SDarrick J. Wong * through the next transaction. The per-AG reservation is to ensure (we
593fd129b6SDarrick J. Wong * hope) that each AG never runs out of blocks. Each data structure wanting
603fd129b6SDarrick J. Wong * to use the reservation system should update ask/used in xfs_ag_resv_init.
613fd129b6SDarrick J. Wong */
623fd129b6SDarrick J. Wong
633fd129b6SDarrick J. Wong /*
643fd129b6SDarrick J. Wong * Are we critically low on blocks? For now we'll define that as the number
653fd129b6SDarrick J. Wong * of blocks we can get our hands on being less than 10% of what we reserved
663fd129b6SDarrick J. Wong * or less than some arbitrary number (maximum btree height).
673fd129b6SDarrick J. Wong */
683fd129b6SDarrick J. Wong bool
xfs_ag_resv_critical(struct xfs_perag * pag,enum xfs_ag_resv_type type)693fd129b6SDarrick J. Wong xfs_ag_resv_critical(
703fd129b6SDarrick J. Wong struct xfs_perag *pag,
713fd129b6SDarrick J. Wong enum xfs_ag_resv_type type)
723fd129b6SDarrick J. Wong {
733fd129b6SDarrick J. Wong xfs_extlen_t avail;
743fd129b6SDarrick J. Wong xfs_extlen_t orig;
753fd129b6SDarrick J. Wong
763fd129b6SDarrick J. Wong switch (type) {
773fd129b6SDarrick J. Wong case XFS_AG_RESV_METADATA:
7821592863SBrian Foster avail = pag->pagf_freeblks - pag->pag_rmapbt_resv.ar_reserved;
793fd129b6SDarrick J. Wong orig = pag->pag_meta_resv.ar_asked;
803fd129b6SDarrick J. Wong break;
8121592863SBrian Foster case XFS_AG_RESV_RMAPBT:
823fd129b6SDarrick J. Wong avail = pag->pagf_freeblks + pag->pagf_flcount -
833fd129b6SDarrick J. Wong pag->pag_meta_resv.ar_reserved;
8421592863SBrian Foster orig = pag->pag_rmapbt_resv.ar_asked;
853fd129b6SDarrick J. Wong break;
863fd129b6SDarrick J. Wong default:
873fd129b6SDarrick J. Wong ASSERT(0);
883fd129b6SDarrick J. Wong return false;
893fd129b6SDarrick J. Wong }
903fd129b6SDarrick J. Wong
913fd129b6SDarrick J. Wong trace_xfs_ag_resv_critical(pag, type, avail);
923fd129b6SDarrick J. Wong
933fd129b6SDarrick J. Wong /* Critically low if less than 10% or max btree height remains. */
94b74e15d7SDarrick J. Wong return XFS_TEST_ERROR(avail < orig / 10 ||
95b74e15d7SDarrick J. Wong avail < pag->pag_mount->m_agbtree_maxlevels,
969e24cfd0SDarrick J. Wong pag->pag_mount, XFS_ERRTAG_AG_RESV_CRITICAL);
973fd129b6SDarrick J. Wong }
983fd129b6SDarrick J. Wong
993fd129b6SDarrick J. Wong /*
1003fd129b6SDarrick J. Wong * How many blocks are reserved but not used, and therefore must not be
1013fd129b6SDarrick J. Wong * allocated away?
1023fd129b6SDarrick J. Wong */
1033fd129b6SDarrick J. Wong xfs_extlen_t
xfs_ag_resv_needed(struct xfs_perag * pag,enum xfs_ag_resv_type type)1043fd129b6SDarrick J. Wong xfs_ag_resv_needed(
1053fd129b6SDarrick J. Wong struct xfs_perag *pag,
1063fd129b6SDarrick J. Wong enum xfs_ag_resv_type type)
1073fd129b6SDarrick J. Wong {
1083fd129b6SDarrick J. Wong xfs_extlen_t len;
1093fd129b6SDarrick J. Wong
11021592863SBrian Foster len = pag->pag_meta_resv.ar_reserved + pag->pag_rmapbt_resv.ar_reserved;
1113fd129b6SDarrick J. Wong switch (type) {
1123fd129b6SDarrick J. Wong case XFS_AG_RESV_METADATA:
11321592863SBrian Foster case XFS_AG_RESV_RMAPBT:
1143fd129b6SDarrick J. Wong len -= xfs_perag_resv(pag, type)->ar_reserved;
1153fd129b6SDarrick J. Wong break;
1163fd129b6SDarrick J. Wong case XFS_AG_RESV_NONE:
1173fd129b6SDarrick J. Wong /* empty */
1183fd129b6SDarrick J. Wong break;
1193fd129b6SDarrick J. Wong default:
1203fd129b6SDarrick J. Wong ASSERT(0);
1213fd129b6SDarrick J. Wong }
1223fd129b6SDarrick J. Wong
1233fd129b6SDarrick J. Wong trace_xfs_ag_resv_needed(pag, type, len);
1243fd129b6SDarrick J. Wong
1253fd129b6SDarrick J. Wong return len;
1263fd129b6SDarrick J. Wong }
1273fd129b6SDarrick J. Wong
1283fd129b6SDarrick J. Wong /* Clean out a reservation */
1293fd129b6SDarrick J. Wong static int
__xfs_ag_resv_free(struct xfs_perag * pag,enum xfs_ag_resv_type type)1303fd129b6SDarrick J. Wong __xfs_ag_resv_free(
1313fd129b6SDarrick J. Wong struct xfs_perag *pag,
1323fd129b6SDarrick J. Wong enum xfs_ag_resv_type type)
1333fd129b6SDarrick J. Wong {
1343fd129b6SDarrick J. Wong struct xfs_ag_resv *resv;
1353fd129b6SDarrick J. Wong xfs_extlen_t oldresv;
1363fd129b6SDarrick J. Wong int error;
1373fd129b6SDarrick J. Wong
1383fd129b6SDarrick J. Wong trace_xfs_ag_resv_free(pag, type, 0);
1393fd129b6SDarrick J. Wong
1403fd129b6SDarrick J. Wong resv = xfs_perag_resv(pag, type);
1419789dd9eSDarrick J. Wong if (pag->pag_agno == 0)
1423fd129b6SDarrick J. Wong pag->pag_mount->m_ag_max_usable += resv->ar_asked;
1433fd129b6SDarrick J. Wong /*
14421592863SBrian Foster * RMAPBT blocks come from the AGFL and AGFL blocks are always
14521592863SBrian Foster * considered "free", so whatever was reserved at mount time must be
14621592863SBrian Foster * given back at umount.
1473fd129b6SDarrick J. Wong */
14821592863SBrian Foster if (type == XFS_AG_RESV_RMAPBT)
1493fd129b6SDarrick J. Wong oldresv = resv->ar_orig_reserved;
1503fd129b6SDarrick J. Wong else
1513fd129b6SDarrick J. Wong oldresv = resv->ar_reserved;
1523fd129b6SDarrick J. Wong error = xfs_mod_fdblocks(pag->pag_mount, oldresv, true);
1533fd129b6SDarrick J. Wong resv->ar_reserved = 0;
1543fd129b6SDarrick J. Wong resv->ar_asked = 0;
155d8cb5e42SDarrick J. Wong resv->ar_orig_reserved = 0;
1563fd129b6SDarrick J. Wong
1573fd129b6SDarrick J. Wong if (error)
1583fd129b6SDarrick J. Wong trace_xfs_ag_resv_free_error(pag->pag_mount, pag->pag_agno,
1593fd129b6SDarrick J. Wong error, _RET_IP_);
1603fd129b6SDarrick J. Wong return error;
1613fd129b6SDarrick J. Wong }
1623fd129b6SDarrick J. Wong
1633fd129b6SDarrick J. Wong /* Free a per-AG reservation. */
1643fd129b6SDarrick J. Wong int
xfs_ag_resv_free(struct xfs_perag * pag)1653fd129b6SDarrick J. Wong xfs_ag_resv_free(
1663fd129b6SDarrick J. Wong struct xfs_perag *pag)
1673fd129b6SDarrick J. Wong {
1683fd129b6SDarrick J. Wong int error;
1693fd129b6SDarrick J. Wong int err2;
1703fd129b6SDarrick J. Wong
17121592863SBrian Foster error = __xfs_ag_resv_free(pag, XFS_AG_RESV_RMAPBT);
1723fd129b6SDarrick J. Wong err2 = __xfs_ag_resv_free(pag, XFS_AG_RESV_METADATA);
1733fd129b6SDarrick J. Wong if (err2 && !error)
1743fd129b6SDarrick J. Wong error = err2;
1753fd129b6SDarrick J. Wong return error;
1763fd129b6SDarrick J. Wong }
1773fd129b6SDarrick J. Wong
1783fd129b6SDarrick J. Wong static int
__xfs_ag_resv_init(struct xfs_perag * pag,enum xfs_ag_resv_type type,xfs_extlen_t ask,xfs_extlen_t used)1793fd129b6SDarrick J. Wong __xfs_ag_resv_init(
1803fd129b6SDarrick J. Wong struct xfs_perag *pag,
1813fd129b6SDarrick J. Wong enum xfs_ag_resv_type type,
1823fd129b6SDarrick J. Wong xfs_extlen_t ask,
1833fd129b6SDarrick J. Wong xfs_extlen_t used)
1843fd129b6SDarrick J. Wong {
1853fd129b6SDarrick J. Wong struct xfs_mount *mp = pag->pag_mount;
1863fd129b6SDarrick J. Wong struct xfs_ag_resv *resv;
1873fd129b6SDarrick J. Wong int error;
188d8cb5e42SDarrick J. Wong xfs_extlen_t hidden_space;
1893fd129b6SDarrick J. Wong
1903fd129b6SDarrick J. Wong if (used > ask)
1913fd129b6SDarrick J. Wong ask = used;
1923fd129b6SDarrick J. Wong
193d8cb5e42SDarrick J. Wong switch (type) {
194d8cb5e42SDarrick J. Wong case XFS_AG_RESV_RMAPBT:
195d8cb5e42SDarrick J. Wong /*
196d8cb5e42SDarrick J. Wong * Space taken by the rmapbt is not subtracted from fdblocks
197d8cb5e42SDarrick J. Wong * because the rmapbt lives in the free space. Here we must
198d8cb5e42SDarrick J. Wong * subtract the entire reservation from fdblocks so that we
199d8cb5e42SDarrick J. Wong * always have blocks available for rmapbt expansion.
200d8cb5e42SDarrick J. Wong */
201d8cb5e42SDarrick J. Wong hidden_space = ask;
202d8cb5e42SDarrick J. Wong break;
203d8cb5e42SDarrick J. Wong case XFS_AG_RESV_METADATA:
204d8cb5e42SDarrick J. Wong /*
205d8cb5e42SDarrick J. Wong * Space taken by all other metadata btrees are accounted
206d8cb5e42SDarrick J. Wong * on-disk as used space. We therefore only hide the space
207d8cb5e42SDarrick J. Wong * that is reserved but not used by the trees.
208d8cb5e42SDarrick J. Wong */
209d8cb5e42SDarrick J. Wong hidden_space = ask - used;
210d8cb5e42SDarrick J. Wong break;
211d8cb5e42SDarrick J. Wong default:
212d8cb5e42SDarrick J. Wong ASSERT(0);
213d8cb5e42SDarrick J. Wong return -EINVAL;
214d8cb5e42SDarrick J. Wong }
2152b92faedSGao Xiang
2162b92faedSGao Xiang if (XFS_TEST_ERROR(false, mp, XFS_ERRTAG_AG_RESV_FAIL))
2172b92faedSGao Xiang error = -ENOSPC;
2182b92faedSGao Xiang else
219d8cb5e42SDarrick J. Wong error = xfs_mod_fdblocks(mp, -(int64_t)hidden_space, true);
2204dfa2b84SChristoph Hellwig if (error) {
2213fd129b6SDarrick J. Wong trace_xfs_ag_resv_init_error(pag->pag_mount, pag->pag_agno,
2223fd129b6SDarrick J. Wong error, _RET_IP_);
22376d771b4SChristoph Hellwig xfs_warn(mp,
22476d771b4SChristoph Hellwig "Per-AG reservation for AG %u failed. Filesystem may run out of space.",
22576d771b4SChristoph Hellwig pag->pag_agno);
2263fd129b6SDarrick J. Wong return error;
2273fd129b6SDarrick J. Wong }
2283fd129b6SDarrick J. Wong
2299789dd9eSDarrick J. Wong /*
2309789dd9eSDarrick J. Wong * Reduce the maximum per-AG allocation length by however much we're
2319789dd9eSDarrick J. Wong * trying to reserve for an AG. Since this is a filesystem-wide
2329789dd9eSDarrick J. Wong * counter, we only make the adjustment for AG 0. This assumes that
2339789dd9eSDarrick J. Wong * there aren't any AGs hungrier for per-AG reservation than AG 0.
2349789dd9eSDarrick J. Wong */
2359789dd9eSDarrick J. Wong if (pag->pag_agno == 0)
2364dfa2b84SChristoph Hellwig mp->m_ag_max_usable -= ask;
2374dfa2b84SChristoph Hellwig
2384dfa2b84SChristoph Hellwig resv = xfs_perag_resv(pag, type);
2394dfa2b84SChristoph Hellwig resv->ar_asked = ask;
240d8cb5e42SDarrick J. Wong resv->ar_orig_reserved = hidden_space;
241d8cb5e42SDarrick J. Wong resv->ar_reserved = ask - used;
2424dfa2b84SChristoph Hellwig
2434dfa2b84SChristoph Hellwig trace_xfs_ag_resv_init(pag, type, ask);
2444dfa2b84SChristoph Hellwig return 0;
2454dfa2b84SChristoph Hellwig }
2464dfa2b84SChristoph Hellwig
2473fd129b6SDarrick J. Wong /* Create a per-AG block reservation. */
2483fd129b6SDarrick J. Wong int
xfs_ag_resv_init(struct xfs_perag * pag,struct xfs_trans * tp)2493fd129b6SDarrick J. Wong xfs_ag_resv_init(
250ebcbef3aSDarrick J. Wong struct xfs_perag *pag,
251ebcbef3aSDarrick J. Wong struct xfs_trans *tp)
2523fd129b6SDarrick J. Wong {
25376d771b4SChristoph Hellwig struct xfs_mount *mp = pag->pag_mount;
2543fd129b6SDarrick J. Wong xfs_extlen_t ask;
2553fd129b6SDarrick J. Wong xfs_extlen_t used;
2562675ad38SBrian Foster int error = 0, error2;
2572675ad38SBrian Foster bool has_resv = false;
2583fd129b6SDarrick J. Wong
2593fd129b6SDarrick J. Wong /* Create the metadata reservation. */
2603fd129b6SDarrick J. Wong if (pag->pag_meta_resv.ar_asked == 0) {
2613fd129b6SDarrick J. Wong ask = used = 0;
2623fd129b6SDarrick J. Wong
26330933120SDave Chinner error = xfs_refcountbt_calc_reserves(mp, tp, pag, &ask, &used);
26476d771b4SChristoph Hellwig if (error)
26576d771b4SChristoph Hellwig goto out;
26676d771b4SChristoph Hellwig
267*bab8b795SDave Chinner error = xfs_finobt_calc_reserves(pag, tp, &ask, &used);
26876d771b4SChristoph Hellwig if (error)
26976d771b4SChristoph Hellwig goto out;
27076d771b4SChristoph Hellwig
27176d771b4SChristoph Hellwig error = __xfs_ag_resv_init(pag, XFS_AG_RESV_METADATA,
27276d771b4SChristoph Hellwig ask, used);
27376d771b4SChristoph Hellwig if (error) {
27476d771b4SChristoph Hellwig /*
27576d771b4SChristoph Hellwig * Because we didn't have per-AG reservations when the
27676d771b4SChristoph Hellwig * finobt feature was added we might not be able to
27776d771b4SChristoph Hellwig * reserve all needed blocks. Warn and fall back to the
27876d771b4SChristoph Hellwig * old and potentially buggy code in that case, but
27976d771b4SChristoph Hellwig * ensure we do have the reservation for the refcountbt.
28076d771b4SChristoph Hellwig */
28176d771b4SChristoph Hellwig ask = used = 0;
28276d771b4SChristoph Hellwig
283e1f6ca11SDarrick J. Wong mp->m_finobt_nores = true;
28476d771b4SChristoph Hellwig
28530933120SDave Chinner error = xfs_refcountbt_calc_reserves(mp, tp, pag, &ask,
28676d771b4SChristoph Hellwig &used);
28784d69619SDarrick J. Wong if (error)
28884d69619SDarrick J. Wong goto out;
28984d69619SDarrick J. Wong
2903fd129b6SDarrick J. Wong error = __xfs_ag_resv_init(pag, XFS_AG_RESV_METADATA,
2913fd129b6SDarrick J. Wong ask, used);
2923fd129b6SDarrick J. Wong if (error)
2933fd129b6SDarrick J. Wong goto out;
2943fd129b6SDarrick J. Wong }
2952675ad38SBrian Foster if (ask)
2962675ad38SBrian Foster has_resv = true;
29776d771b4SChristoph Hellwig }
2983fd129b6SDarrick J. Wong
29921592863SBrian Foster /* Create the RMAPBT metadata reservation */
30021592863SBrian Foster if (pag->pag_rmapbt_resv.ar_asked == 0) {
3013fd129b6SDarrick J. Wong ask = used = 0;
3023fd129b6SDarrick J. Wong
30330933120SDave Chinner error = xfs_rmapbt_calc_reserves(mp, tp, pag, &ask, &used);
30484d69619SDarrick J. Wong if (error)
30584d69619SDarrick J. Wong goto out;
30684d69619SDarrick J. Wong
30721592863SBrian Foster error = __xfs_ag_resv_init(pag, XFS_AG_RESV_RMAPBT, ask, used);
3083fd129b6SDarrick J. Wong if (error)
3093fd129b6SDarrick J. Wong goto out;
3102675ad38SBrian Foster if (ask)
3112675ad38SBrian Foster has_resv = true;
3123fd129b6SDarrick J. Wong }
3133fd129b6SDarrick J. Wong
3142675ad38SBrian Foster out:
3152675ad38SBrian Foster /*
3162675ad38SBrian Foster * Initialize the pagf if we have at least one active reservation on the
3172675ad38SBrian Foster * AG. This may have occurred already via reservation calculation, but
3182675ad38SBrian Foster * fall back to an explicit init to ensure the in-core allocbt usage
3192675ad38SBrian Foster * counters are initialized as soon as possible. This is important
3202675ad38SBrian Foster * because filesystems with large perag reservations are susceptible to
3212675ad38SBrian Foster * free space reservation problems that the allocbt counter is used to
3222675ad38SBrian Foster * address.
3232675ad38SBrian Foster */
3242675ad38SBrian Foster if (has_resv) {
32508d3e84fSDave Chinner error2 = xfs_alloc_read_agf(pag, tp, 0, NULL);
3262675ad38SBrian Foster if (error2)
3272675ad38SBrian Foster return error2;
3280f934251SDarrick J. Wong
3290f934251SDarrick J. Wong /*
3300f934251SDarrick J. Wong * If there isn't enough space in the AG to satisfy the
3310f934251SDarrick J. Wong * reservation, let the caller know that there wasn't enough
3320f934251SDarrick J. Wong * space. Callers are responsible for deciding what to do
3330f934251SDarrick J. Wong * next, since (in theory) we can stumble along with
3340f934251SDarrick J. Wong * insufficient reservation if data blocks are being freed to
3350f934251SDarrick J. Wong * replenish the AG's free space.
3360f934251SDarrick J. Wong */
3370f934251SDarrick J. Wong if (!error &&
3380f934251SDarrick J. Wong xfs_perag_resv(pag, XFS_AG_RESV_METADATA)->ar_reserved +
3390f934251SDarrick J. Wong xfs_perag_resv(pag, XFS_AG_RESV_RMAPBT)->ar_reserved >
3400f934251SDarrick J. Wong pag->pagf_freeblks + pag->pagf_flcount)
3410f934251SDarrick J. Wong error = -ENOSPC;
3422675ad38SBrian Foster }
3430f934251SDarrick J. Wong
3443fd129b6SDarrick J. Wong return error;
3453fd129b6SDarrick J. Wong }
3463fd129b6SDarrick J. Wong
3473fd129b6SDarrick J. Wong /* Allocate a block from the reservation. */
3483fd129b6SDarrick J. Wong void
xfs_ag_resv_alloc_extent(struct xfs_perag * pag,enum xfs_ag_resv_type type,struct xfs_alloc_arg * args)3493fd129b6SDarrick J. Wong xfs_ag_resv_alloc_extent(
3503fd129b6SDarrick J. Wong struct xfs_perag *pag,
3513fd129b6SDarrick J. Wong enum xfs_ag_resv_type type,
3523fd129b6SDarrick J. Wong struct xfs_alloc_arg *args)
3533fd129b6SDarrick J. Wong {
3543fd129b6SDarrick J. Wong struct xfs_ag_resv *resv;
3553fd129b6SDarrick J. Wong xfs_extlen_t len;
3563fd129b6SDarrick J. Wong uint field;
3573fd129b6SDarrick J. Wong
3583fd129b6SDarrick J. Wong trace_xfs_ag_resv_alloc_extent(pag, type, args->len);
3593fd129b6SDarrick J. Wong
3603fd129b6SDarrick J. Wong switch (type) {
3610ab32086SBrian Foster case XFS_AG_RESV_AGFL:
3620ab32086SBrian Foster return;
3633fd129b6SDarrick J. Wong case XFS_AG_RESV_METADATA:
36421592863SBrian Foster case XFS_AG_RESV_RMAPBT:
3653fd129b6SDarrick J. Wong resv = xfs_perag_resv(pag, type);
3663fd129b6SDarrick J. Wong break;
3673fd129b6SDarrick J. Wong default:
3683fd129b6SDarrick J. Wong ASSERT(0);
36953004ee7SGustavo A. R. Silva fallthrough;
3703fd129b6SDarrick J. Wong case XFS_AG_RESV_NONE:
3713fd129b6SDarrick J. Wong field = args->wasdel ? XFS_TRANS_SB_RES_FDBLOCKS :
3723fd129b6SDarrick J. Wong XFS_TRANS_SB_FDBLOCKS;
3733fd129b6SDarrick J. Wong xfs_trans_mod_sb(args->tp, field, -(int64_t)args->len);
3743fd129b6SDarrick J. Wong return;
3753fd129b6SDarrick J. Wong }
3763fd129b6SDarrick J. Wong
3773fd129b6SDarrick J. Wong len = min_t(xfs_extlen_t, args->len, resv->ar_reserved);
3783fd129b6SDarrick J. Wong resv->ar_reserved -= len;
37921592863SBrian Foster if (type == XFS_AG_RESV_RMAPBT)
3803fd129b6SDarrick J. Wong return;
3813fd129b6SDarrick J. Wong /* Allocations of reserved blocks only need on-disk sb updates... */
3823fd129b6SDarrick J. Wong xfs_trans_mod_sb(args->tp, XFS_TRANS_SB_RES_FDBLOCKS, -(int64_t)len);
3833fd129b6SDarrick J. Wong /* ...but non-reserved blocks need in-core and on-disk updates. */
3843fd129b6SDarrick J. Wong if (args->len > len)
3853fd129b6SDarrick J. Wong xfs_trans_mod_sb(args->tp, XFS_TRANS_SB_FDBLOCKS,
3863fd129b6SDarrick J. Wong -((int64_t)args->len - len));
3873fd129b6SDarrick J. Wong }
3883fd129b6SDarrick J. Wong
3893fd129b6SDarrick J. Wong /* Free a block to the reservation. */
3903fd129b6SDarrick J. Wong void
xfs_ag_resv_free_extent(struct xfs_perag * pag,enum xfs_ag_resv_type type,struct xfs_trans * tp,xfs_extlen_t len)3913fd129b6SDarrick J. Wong xfs_ag_resv_free_extent(
3923fd129b6SDarrick J. Wong struct xfs_perag *pag,
3933fd129b6SDarrick J. Wong enum xfs_ag_resv_type type,
3943fd129b6SDarrick J. Wong struct xfs_trans *tp,
3953fd129b6SDarrick J. Wong xfs_extlen_t len)
3963fd129b6SDarrick J. Wong {
3973fd129b6SDarrick J. Wong xfs_extlen_t leftover;
3983fd129b6SDarrick J. Wong struct xfs_ag_resv *resv;
3993fd129b6SDarrick J. Wong
4003fd129b6SDarrick J. Wong trace_xfs_ag_resv_free_extent(pag, type, len);
4013fd129b6SDarrick J. Wong
4023fd129b6SDarrick J. Wong switch (type) {
4030ab32086SBrian Foster case XFS_AG_RESV_AGFL:
4040ab32086SBrian Foster return;
4053fd129b6SDarrick J. Wong case XFS_AG_RESV_METADATA:
40621592863SBrian Foster case XFS_AG_RESV_RMAPBT:
4073fd129b6SDarrick J. Wong resv = xfs_perag_resv(pag, type);
4083fd129b6SDarrick J. Wong break;
4093fd129b6SDarrick J. Wong default:
4103fd129b6SDarrick J. Wong ASSERT(0);
41153004ee7SGustavo A. R. Silva fallthrough;
4123fd129b6SDarrick J. Wong case XFS_AG_RESV_NONE:
4133fd129b6SDarrick J. Wong xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, (int64_t)len);
4143fd129b6SDarrick J. Wong return;
4153fd129b6SDarrick J. Wong }
4163fd129b6SDarrick J. Wong
4173fd129b6SDarrick J. Wong leftover = min_t(xfs_extlen_t, len, resv->ar_asked - resv->ar_reserved);
4183fd129b6SDarrick J. Wong resv->ar_reserved += leftover;
41921592863SBrian Foster if (type == XFS_AG_RESV_RMAPBT)
4203fd129b6SDarrick J. Wong return;
4213fd129b6SDarrick J. Wong /* Freeing into the reserved pool only requires on-disk update... */
4223fd129b6SDarrick J. Wong xfs_trans_mod_sb(tp, XFS_TRANS_SB_RES_FDBLOCKS, len);
4233fd129b6SDarrick J. Wong /* ...but freeing beyond that requires in-core and on-disk update. */
4243fd129b6SDarrick J. Wong if (len > leftover)
4253fd129b6SDarrick J. Wong xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, len - leftover);
4263fd129b6SDarrick J. Wong }
427