xfs: define the on-disk refcount btree format (1946b91c) · Commits · e / devices / android_kernel_fairphone_FP3

fs/xfs/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -55,6 +55,7 @@ xfs-y += $(addprefix libxfs/, \
		xfs_ag_resv.o \
		xfs_rmap.o \
		xfs_rmap_btree.o \
		xfs_refcount_btree.o \
		xfs_sb.o \
		xfs_symlink_remote.o \
		xfs_trans_resv.o \

fs/xfs/libxfs/xfs_btree.c

+3 −0

Original line number	Diff line number	Diff line
		@@ -1217,6 +1217,9 @@ xfs_btree_set_refs(
		case XFS_BTNUM_RMAP:
		xfs_buf_set_ref(bp, XFS_RMAP_BTREE_REF);
		break;
		case XFS_BTNUM_REFC:
		xfs_buf_set_ref(bp, XFS_REFC_BTREE_REF);
		break;
		default:
		ASSERT(0);
		}

fs/xfs/libxfs/xfs_btree.h

+12 −0

Original line number	Diff line number	Diff line
		@@ -49,6 +49,7 @@ union xfs_btree_key {
		struct xfs_inobt_key inobt;
		struct xfs_rmap_key rmap;
		struct xfs_rmap_key __rmap_bigkey[2];
		struct xfs_refcount_key refc;
		};

		union xfs_btree_rec {
		@@ -57,6 +58,7 @@ union xfs_btree_rec {
		struct xfs_alloc_rec alloc;
		struct xfs_inobt_rec inobt;
		struct xfs_rmap_rec rmap;
		struct xfs_refcount_rec refc;
		};

		/*
		@@ -221,6 +223,15 @@ union xfs_btree_irec {
		struct xfs_bmbt_irec b;
		struct xfs_inobt_rec_incore i;
		struct xfs_rmap_irec r;
		struct xfs_refcount_irec rc;
		};

		/* Per-AG btree private information. */
		union xfs_btree_cur_private {
		struct {
		unsigned long nr_ops; /* # record updates */
		int shape_changes; /* # of extent splits */
		} refc;
		};

		/*
		@@ -247,6 +258,7 @@ typedef struct xfs_btree_cur
		struct xfs_buf agbp; / agf/agi buffer pointer */
		struct xfs_defer_ops dfops; / deferred updates */
		xfs_agnumber_t agno; /* ag number */
		union xfs_btree_cur_private priv;
		} a;
		struct { /* needed for BMAP */
		struct xfs_inode ip; / pointer to our inode */

fs/xfs/libxfs/xfs_format.h

+36 −0

Original line number	Diff line number	Diff line
		@@ -1457,6 +1457,42 @@ typedef __be32 xfs_rmap_ptr_t;

		unsigned int xfs_refc_block(struct xfs_mount *mp);

		/*
		* Data record/key structure
		*
		* Each record associates a range of physical blocks (starting at
		* rc_startblock and ending rc_blockcount blocks later) with a reference
		* count (rc_refcount). Extents that are being used to stage a copy on
		* write (CoW) operation are recorded in the refcount btree with a
		* refcount of 1. All other records must have a refcount > 1 and must
		* track an extent mapped only by file data forks.
		*
		* Extents with a single owner (attributes, metadata, non-shared file
		* data) are not tracked here. Free space is also not tracked here.
		* This is consistent with pre-reflink XFS.
		*/
		struct xfs_refcount_rec {
		__be32 rc_startblock; /* starting block number */
		__be32 rc_blockcount; /* count of blocks */
		__be32 rc_refcount; /* number of inodes linked here */
		};

		struct xfs_refcount_key {
		__be32 rc_startblock; /* starting block number */
		};

		struct xfs_refcount_irec {
		xfs_agblock_t rc_startblock; /* starting block number */
		xfs_extlen_t rc_blockcount; /* count of free blocks */
		xfs_nlink_t rc_refcount; /* number of inodes linked here */
		};

		#define MAXREFCOUNT ((xfs_nlink_t)~0U)
		#define MAXREFCEXTLEN ((xfs_extlen_t)~0U)

		/* btree pointer type */
		typedef __be32 xfs_refcount_ptr_t;


		/*
		* BMAP Btree format definitions

fs/xfs/libxfs/xfs_refcount_btree.c

0 → 100644

+178 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 Oracle. All Rights Reserved.
		*
		* Author: Darrick J. Wong <darrick.wong@oracle.com>
		*
		* This program is free software; you can redistribute it and/or
		* modify it under the terms of the GNU General Public License
		* as published by the Free Software Foundation; either version 2
		* of the License, or (at your option) any later version.
		*
		* This program is distributed in the hope that it would be useful,
		* but WITHOUT ANY WARRANTY; without even the implied warranty of
		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		* GNU General Public License for more details.
		*
		* You should have received a copy of the GNU General Public License
		* along with this program; if not, write the Free Software Foundation,
		* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
		*/
		#include "xfs.h"
		#include "xfs_fs.h"
		#include "xfs_shared.h"
		#include "xfs_format.h"
		#include "xfs_log_format.h"
		#include "xfs_trans_resv.h"
		#include "xfs_sb.h"
		#include "xfs_mount.h"
		#include "xfs_btree.h"
		#include "xfs_bmap.h"
		#include "xfs_refcount_btree.h"
		#include "xfs_alloc.h"
		#include "xfs_error.h"
		#include "xfs_trace.h"
		#include "xfs_cksum.h"
		#include "xfs_trans.h"
		#include "xfs_bit.h"

		static struct xfs_btree_cur *
		xfs_refcountbt_dup_cursor(
		struct xfs_btree_cur *cur)
		{
		return xfs_refcountbt_init_cursor(cur->bc_mp, cur->bc_tp,
		cur->bc_private.a.agbp, cur->bc_private.a.agno,
		cur->bc_private.a.dfops);
		}

		STATIC bool
		xfs_refcountbt_verify(
		struct xfs_buf *bp)
		{
		struct xfs_mount *mp = bp->b_target->bt_mount;
		struct xfs_btree_block *block = XFS_BUF_TO_BLOCK(bp);
		struct xfs_perag *pag = bp->b_pag;
		unsigned int level;

		if (block->bb_magic != cpu_to_be32(XFS_REFC_CRC_MAGIC))
		return false;

		if (!xfs_sb_version_hasreflink(&mp->m_sb))
		return false;
		if (!xfs_btree_sblock_v5hdr_verify(bp))
		return false;

		level = be16_to_cpu(block->bb_level);
		if (pag && pag->pagf_init) {
		if (level >= pag->pagf_refcount_level)
		return false;
		} else if (level >= mp->m_refc_maxlevels)
		return false;

		return xfs_btree_sblock_verify(bp, mp->m_refc_mxr[level != 0]);
		}

		STATIC void
		xfs_refcountbt_read_verify(
		struct xfs_buf *bp)
		{
		if (!xfs_btree_sblock_verify_crc(bp))
		xfs_buf_ioerror(bp, -EFSBADCRC);
		else if (!xfs_refcountbt_verify(bp))
		xfs_buf_ioerror(bp, -EFSCORRUPTED);

		if (bp->b_error) {
		trace_xfs_btree_corrupt(bp, _RET_IP_);
		xfs_verifier_error(bp);
		}
		}

		STATIC void
		xfs_refcountbt_write_verify(
		struct xfs_buf *bp)
		{
		if (!xfs_refcountbt_verify(bp)) {
		trace_xfs_btree_corrupt(bp, _RET_IP_);
		xfs_buf_ioerror(bp, -EFSCORRUPTED);
		xfs_verifier_error(bp);
		return;
		}
		xfs_btree_sblock_calc_crc(bp);

		}

		const struct xfs_buf_ops xfs_refcountbt_buf_ops = {
		.name = "xfs_refcountbt",
		.verify_read = xfs_refcountbt_read_verify,
		.verify_write = xfs_refcountbt_write_verify,
		};

		static const struct xfs_btree_ops xfs_refcountbt_ops = {
		.rec_len = sizeof(struct xfs_refcount_rec),
		.key_len = sizeof(struct xfs_refcount_key),

		.dup_cursor = xfs_refcountbt_dup_cursor,
		.buf_ops = &xfs_refcountbt_buf_ops,
		};

		/*
		* Allocate a new refcount btree cursor.
		*/
		struct xfs_btree_cur *
		xfs_refcountbt_init_cursor(
		struct xfs_mount *mp,
		struct xfs_trans *tp,
		struct xfs_buf *agbp,
		xfs_agnumber_t agno,
		struct xfs_defer_ops *dfops)
		{
		struct xfs_agf *agf = XFS_BUF_TO_AGF(agbp);
		struct xfs_btree_cur *cur;

		ASSERT(agno != NULLAGNUMBER);
		ASSERT(agno < mp->m_sb.sb_agcount);
		cur = kmem_zone_zalloc(xfs_btree_cur_zone, KM_NOFS);

		cur->bc_tp = tp;
		cur->bc_mp = mp;
		cur->bc_btnum = XFS_BTNUM_REFC;
		cur->bc_blocklog = mp->m_sb.sb_blocklog;
		cur->bc_ops = &xfs_refcountbt_ops;

		cur->bc_nlevels = be32_to_cpu(agf->agf_refcount_level);

		cur->bc_private.a.agbp = agbp;
		cur->bc_private.a.agno = agno;
		cur->bc_private.a.dfops = dfops;
		cur->bc_flags \|= XFS_BTREE_CRC_BLOCKS;

		cur->bc_private.a.priv.refc.nr_ops = 0;
		cur->bc_private.a.priv.refc.shape_changes = 0;

		return cur;
		}

		/*
		* Calculate the number of records in a refcount btree block.
		*/
		int
		xfs_refcountbt_maxrecs(
		struct xfs_mount *mp,
		int blocklen,
		bool leaf)
		{
		blocklen -= XFS_REFCOUNT_BLOCK_LEN;

		if (leaf)
		return blocklen / sizeof(struct xfs_refcount_rec);
		return blocklen / (sizeof(struct xfs_refcount_key) +
		sizeof(xfs_refcount_ptr_t));
		}

		/* Compute the maximum height of a refcount btree. */
		void
		xfs_refcountbt_compute_maxlevels(
		struct xfs_mount *mp)
		{
		mp->m_refc_maxlevels = xfs_btree_compute_maxlevels(mp,
		mp->m_refc_mnr, mp->m_sb.sb_agblocks);
		}