1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (C) 2016 Oracle. All Rights Reserved.
4 * Author: Darrick J. Wong <darrick.wong@oracle.com>
8 #include "xfs_shared.h"
9 #include "xfs_format.h"
10 #include "xfs_log_format.h"
11 #include "xfs_trans_resv.h"
13 #include "xfs_mount.h"
14 #include "xfs_btree.h"
16 #include "xfs_refcount_btree.h"
17 #include "xfs_alloc.h"
18 #include "xfs_error.h"
19 #include "xfs_trace.h"
20 #include "xfs_cksum.h"
21 #include "xfs_trans.h"
25 static struct xfs_btree_cur *
26 xfs_refcountbt_dup_cursor(
27 struct xfs_btree_cur *cur)
29 return xfs_refcountbt_init_cursor(cur->bc_mp, cur->bc_tp,
30 cur->bc_private.a.agbp, cur->bc_private.a.agno);
34 xfs_refcountbt_set_root(
35 struct xfs_btree_cur *cur,
36 union xfs_btree_ptr *ptr,
39 struct xfs_buf *agbp = cur->bc_private.a.agbp;
40 struct xfs_agf *agf = XFS_BUF_TO_AGF(agbp);
41 xfs_agnumber_t seqno = be32_to_cpu(agf->agf_seqno);
42 struct xfs_perag *pag = xfs_perag_get(cur->bc_mp, seqno);
46 agf->agf_refcount_root = ptr->s;
47 be32_add_cpu(&agf->agf_refcount_level, inc);
48 pag->pagf_refcount_level += inc;
51 xfs_alloc_log_agf(cur->bc_tp, agbp,
52 XFS_AGF_REFCOUNT_ROOT | XFS_AGF_REFCOUNT_LEVEL);
56 xfs_refcountbt_alloc_block(
57 struct xfs_btree_cur *cur,
58 union xfs_btree_ptr *start,
59 union xfs_btree_ptr *new,
62 struct xfs_buf *agbp = cur->bc_private.a.agbp;
63 struct xfs_agf *agf = XFS_BUF_TO_AGF(agbp);
64 struct xfs_alloc_arg args; /* block allocation args */
65 int error; /* error return value */
67 memset(&args, 0, sizeof(args));
70 args.type = XFS_ALLOCTYPE_NEAR_BNO;
71 args.fsbno = XFS_AGB_TO_FSB(cur->bc_mp, cur->bc_private.a.agno,
72 xfs_refc_block(args.mp));
73 xfs_rmap_ag_owner(&args.oinfo, XFS_RMAP_OWN_REFC);
74 args.minlen = args.maxlen = args.prod = 1;
75 args.resv = XFS_AG_RESV_METADATA;
77 error = xfs_alloc_vextent(&args);
80 trace_xfs_refcountbt_alloc_block(cur->bc_mp, cur->bc_private.a.agno,
82 if (args.fsbno == NULLFSBLOCK) {
86 ASSERT(args.agno == cur->bc_private.a.agno);
87 ASSERT(args.len == 1);
89 new->s = cpu_to_be32(args.agbno);
90 be32_add_cpu(&agf->agf_refcount_blocks, 1);
91 xfs_alloc_log_agf(cur->bc_tp, agbp, XFS_AGF_REFCOUNT_BLOCKS);
101 xfs_refcountbt_free_block(
102 struct xfs_btree_cur *cur,
105 struct xfs_mount *mp = cur->bc_mp;
106 struct xfs_buf *agbp = cur->bc_private.a.agbp;
107 struct xfs_agf *agf = XFS_BUF_TO_AGF(agbp);
108 xfs_fsblock_t fsbno = XFS_DADDR_TO_FSB(mp, XFS_BUF_ADDR(bp));
109 struct xfs_owner_info oinfo;
112 trace_xfs_refcountbt_free_block(cur->bc_mp, cur->bc_private.a.agno,
113 XFS_FSB_TO_AGBNO(cur->bc_mp, fsbno), 1);
114 xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_REFC);
115 be32_add_cpu(&agf->agf_refcount_blocks, -1);
116 xfs_alloc_log_agf(cur->bc_tp, agbp, XFS_AGF_REFCOUNT_BLOCKS);
117 error = xfs_free_extent(cur->bc_tp, fsbno, 1, &oinfo,
118 XFS_AG_RESV_METADATA);
126 xfs_refcountbt_get_minrecs(
127 struct xfs_btree_cur *cur,
130 return cur->bc_mp->m_refc_mnr[level != 0];
134 xfs_refcountbt_get_maxrecs(
135 struct xfs_btree_cur *cur,
138 return cur->bc_mp->m_refc_mxr[level != 0];
142 xfs_refcountbt_init_key_from_rec(
143 union xfs_btree_key *key,
144 union xfs_btree_rec *rec)
146 key->refc.rc_startblock = rec->refc.rc_startblock;
150 xfs_refcountbt_init_high_key_from_rec(
151 union xfs_btree_key *key,
152 union xfs_btree_rec *rec)
156 x = be32_to_cpu(rec->refc.rc_startblock);
157 x += be32_to_cpu(rec->refc.rc_blockcount) - 1;
158 key->refc.rc_startblock = cpu_to_be32(x);
162 xfs_refcountbt_init_rec_from_cur(
163 struct xfs_btree_cur *cur,
164 union xfs_btree_rec *rec)
166 rec->refc.rc_startblock = cpu_to_be32(cur->bc_rec.rc.rc_startblock);
167 rec->refc.rc_blockcount = cpu_to_be32(cur->bc_rec.rc.rc_blockcount);
168 rec->refc.rc_refcount = cpu_to_be32(cur->bc_rec.rc.rc_refcount);
172 xfs_refcountbt_init_ptr_from_cur(
173 struct xfs_btree_cur *cur,
174 union xfs_btree_ptr *ptr)
176 struct xfs_agf *agf = XFS_BUF_TO_AGF(cur->bc_private.a.agbp);
178 ASSERT(cur->bc_private.a.agno == be32_to_cpu(agf->agf_seqno));
180 ptr->s = agf->agf_refcount_root;
184 xfs_refcountbt_key_diff(
185 struct xfs_btree_cur *cur,
186 union xfs_btree_key *key)
188 struct xfs_refcount_irec *rec = &cur->bc_rec.rc;
189 struct xfs_refcount_key *kp = &key->refc;
191 return (int64_t)be32_to_cpu(kp->rc_startblock) - rec->rc_startblock;
195 xfs_refcountbt_diff_two_keys(
196 struct xfs_btree_cur *cur,
197 union xfs_btree_key *k1,
198 union xfs_btree_key *k2)
200 return (int64_t)be32_to_cpu(k1->refc.rc_startblock) -
201 be32_to_cpu(k2->refc.rc_startblock);
204 STATIC xfs_failaddr_t
205 xfs_refcountbt_verify(
208 struct xfs_mount *mp = bp->b_target->bt_mount;
209 struct xfs_btree_block *block = XFS_BUF_TO_BLOCK(bp);
210 struct xfs_perag *pag = bp->b_pag;
214 if (block->bb_magic != cpu_to_be32(XFS_REFC_CRC_MAGIC))
215 return __this_address;
217 if (!xfs_sb_version_hasreflink(&mp->m_sb))
218 return __this_address;
219 fa = xfs_btree_sblock_v5hdr_verify(bp);
223 level = be16_to_cpu(block->bb_level);
224 if (pag && pag->pagf_init) {
225 if (level >= pag->pagf_refcount_level)
226 return __this_address;
227 } else if (level >= mp->m_refc_maxlevels)
228 return __this_address;
230 return xfs_btree_sblock_verify(bp, mp->m_refc_mxr[level != 0]);
234 xfs_refcountbt_read_verify(
239 if (!xfs_btree_sblock_verify_crc(bp))
240 xfs_verifier_error(bp, -EFSBADCRC, __this_address);
242 fa = xfs_refcountbt_verify(bp);
244 xfs_verifier_error(bp, -EFSCORRUPTED, fa);
248 trace_xfs_btree_corrupt(bp, _RET_IP_);
252 xfs_refcountbt_write_verify(
257 fa = xfs_refcountbt_verify(bp);
259 trace_xfs_btree_corrupt(bp, _RET_IP_);
260 xfs_verifier_error(bp, -EFSCORRUPTED, fa);
263 xfs_btree_sblock_calc_crc(bp);
267 const struct xfs_buf_ops xfs_refcountbt_buf_ops = {
268 .name = "xfs_refcountbt",
269 .verify_read = xfs_refcountbt_read_verify,
270 .verify_write = xfs_refcountbt_write_verify,
271 .verify_struct = xfs_refcountbt_verify,
275 xfs_refcountbt_keys_inorder(
276 struct xfs_btree_cur *cur,
277 union xfs_btree_key *k1,
278 union xfs_btree_key *k2)
280 return be32_to_cpu(k1->refc.rc_startblock) <
281 be32_to_cpu(k2->refc.rc_startblock);
285 xfs_refcountbt_recs_inorder(
286 struct xfs_btree_cur *cur,
287 union xfs_btree_rec *r1,
288 union xfs_btree_rec *r2)
290 return be32_to_cpu(r1->refc.rc_startblock) +
291 be32_to_cpu(r1->refc.rc_blockcount) <=
292 be32_to_cpu(r2->refc.rc_startblock);
295 static const struct xfs_btree_ops xfs_refcountbt_ops = {
296 .rec_len = sizeof(struct xfs_refcount_rec),
297 .key_len = sizeof(struct xfs_refcount_key),
299 .dup_cursor = xfs_refcountbt_dup_cursor,
300 .set_root = xfs_refcountbt_set_root,
301 .alloc_block = xfs_refcountbt_alloc_block,
302 .free_block = xfs_refcountbt_free_block,
303 .get_minrecs = xfs_refcountbt_get_minrecs,
304 .get_maxrecs = xfs_refcountbt_get_maxrecs,
305 .init_key_from_rec = xfs_refcountbt_init_key_from_rec,
306 .init_high_key_from_rec = xfs_refcountbt_init_high_key_from_rec,
307 .init_rec_from_cur = xfs_refcountbt_init_rec_from_cur,
308 .init_ptr_from_cur = xfs_refcountbt_init_ptr_from_cur,
309 .key_diff = xfs_refcountbt_key_diff,
310 .buf_ops = &xfs_refcountbt_buf_ops,
311 .diff_two_keys = xfs_refcountbt_diff_two_keys,
312 .keys_inorder = xfs_refcountbt_keys_inorder,
313 .recs_inorder = xfs_refcountbt_recs_inorder,
317 * Allocate a new refcount btree cursor.
319 struct xfs_btree_cur *
320 xfs_refcountbt_init_cursor(
321 struct xfs_mount *mp,
322 struct xfs_trans *tp,
323 struct xfs_buf *agbp,
326 struct xfs_agf *agf = XFS_BUF_TO_AGF(agbp);
327 struct xfs_btree_cur *cur;
329 ASSERT(agno != NULLAGNUMBER);
330 ASSERT(agno < mp->m_sb.sb_agcount);
331 cur = kmem_zone_zalloc(xfs_btree_cur_zone, KM_NOFS);
335 cur->bc_btnum = XFS_BTNUM_REFC;
336 cur->bc_blocklog = mp->m_sb.sb_blocklog;
337 cur->bc_ops = &xfs_refcountbt_ops;
338 cur->bc_statoff = XFS_STATS_CALC_INDEX(xs_refcbt_2);
340 cur->bc_nlevels = be32_to_cpu(agf->agf_refcount_level);
342 cur->bc_private.a.agbp = agbp;
343 cur->bc_private.a.agno = agno;
344 cur->bc_flags |= XFS_BTREE_CRC_BLOCKS;
346 cur->bc_private.a.priv.refc.nr_ops = 0;
347 cur->bc_private.a.priv.refc.shape_changes = 0;
353 * Calculate the number of records in a refcount btree block.
356 xfs_refcountbt_maxrecs(
360 blocklen -= XFS_REFCOUNT_BLOCK_LEN;
363 return blocklen / sizeof(struct xfs_refcount_rec);
364 return blocklen / (sizeof(struct xfs_refcount_key) +
365 sizeof(xfs_refcount_ptr_t));
368 /* Compute the maximum height of a refcount btree. */
370 xfs_refcountbt_compute_maxlevels(
371 struct xfs_mount *mp)
373 mp->m_refc_maxlevels = xfs_btree_compute_maxlevels(
374 mp->m_refc_mnr, mp->m_sb.sb_agblocks);
377 /* Calculate the refcount btree size for some records. */
379 xfs_refcountbt_calc_size(
380 struct xfs_mount *mp,
381 unsigned long long len)
383 return xfs_btree_calc_size(mp->m_refc_mnr, len);
387 * Calculate the maximum refcount btree size.
390 xfs_refcountbt_max_size(
391 struct xfs_mount *mp,
392 xfs_agblock_t agblocks)
394 /* Bail out if we're uninitialized, which can happen in mkfs. */
395 if (mp->m_refc_mxr[0] == 0)
398 return xfs_refcountbt_calc_size(mp, agblocks);
402 * Figure out how many blocks to reserve and how many are used by this btree.
405 xfs_refcountbt_calc_reserves(
406 struct xfs_mount *mp,
407 struct xfs_trans *tp,
412 struct xfs_buf *agbp;
414 xfs_agblock_t agblocks;
415 xfs_extlen_t tree_len;
418 if (!xfs_sb_version_hasreflink(&mp->m_sb))
422 error = xfs_alloc_read_agf(mp, tp, agno, 0, &agbp);
426 agf = XFS_BUF_TO_AGF(agbp);
427 agblocks = be32_to_cpu(agf->agf_length);
428 tree_len = be32_to_cpu(agf->agf_refcount_blocks);
429 xfs_trans_brelse(tp, agbp);
431 *ask += xfs_refcountbt_max_size(mp, agblocks);