Commit 87fe4c34 authored by Darrick J. Wong's avatar Darrick J. Wong
Browse files

xfs: create incore realtime group structures 



Create an incore object that will contain information about a realtime
allocation group.  This will eventually enable us to shard the realtime
section in a similar manner to how we shard the data section, but for
now just a single object for the entire RT subvolume is created.

Signed-off-by: default avatarDarrick J. Wong <djwong@kernel.org>
Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
parent dcfc65be

fs/xfs/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -61,6 +61,7 @@ xfs-y += $(addprefix libxfs/, \ 
# xfs_rtbitmap is shared with libxfs

xfs-$(CONFIG_XFS_RT)		+= $(addprefix libxfs/, \

				   xfs_rtbitmap.o \

				   xfs_rtgroup.o \

				   )



# highlevel code

fs/xfs/libxfs/xfs_format.h

+3 −0
Original line number Diff line number Diff line
@@ -176,6 +176,9 @@ typedef struct xfs_sb { 


	xfs_ino_t	sb_metadirino;	/* metadata directory tree root */



	xfs_rgnumber_t	sb_rgcount;	/* number of realtime groups */

	xfs_rtxlen_t	sb_rgextents;	/* size of a realtime group in rtx */



	/* must be padded to 64 bit alignment */

} xfs_sb_t;

fs/xfs/libxfs/xfs_rtgroup.c

0 → 100644
+151 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * Copyright (c) 2022-2024 Oracle.  All Rights Reserved.

 * Author: Darrick J. Wong <djwong@kernel.org>

 */

#include "xfs.h"

#include "xfs_fs.h"

#include "xfs_shared.h"

#include "xfs_format.h"

#include "xfs_trans_resv.h"

#include "xfs_bit.h"

#include "xfs_sb.h"

#include "xfs_mount.h"

#include "xfs_btree.h"

#include "xfs_alloc_btree.h"

#include "xfs_rmap_btree.h"

#include "xfs_alloc.h"

#include "xfs_ialloc.h"

#include "xfs_rmap.h"

#include "xfs_ag.h"

#include "xfs_ag_resv.h"

#include "xfs_health.h"

#include "xfs_error.h"

#include "xfs_bmap.h"

#include "xfs_defer.h"

#include "xfs_log_format.h"

#include "xfs_trans.h"

#include "xfs_trace.h"

#include "xfs_inode.h"

#include "xfs_icache.h"

#include "xfs_rtgroup.h"

#include "xfs_rtbitmap.h"



int

xfs_rtgroup_alloc(

	struct xfs_mount	*mp,

	xfs_rgnumber_t		rgno,

	xfs_rgnumber_t		rgcount,

	xfs_rtbxlen_t		rextents)

{

	struct xfs_rtgroup	*rtg;

	int			error;



	rtg = kzalloc(sizeof(struct xfs_rtgroup), GFP_KERNEL);

	if (!rtg)

		return -ENOMEM;



	error = xfs_group_insert(mp, rtg_group(rtg), rgno, XG_TYPE_RTG);

	if (error)

		goto out_free_rtg;

	return 0;



out_free_rtg:

	kfree(rtg);

	return error;

}



void

xfs_rtgroup_free(

	struct xfs_mount	*mp,

	xfs_rgnumber_t		rgno)

{

	xfs_group_free(mp, rgno, XG_TYPE_RTG, NULL);

}



/* Free a range of incore rtgroup objects. */

void

xfs_free_rtgroups(

	struct xfs_mount	*mp,

	xfs_rgnumber_t		first_rgno,

	xfs_rgnumber_t		end_rgno)

{

	xfs_rgnumber_t		rgno;



	for (rgno = first_rgno; rgno < end_rgno; rgno++)

		xfs_rtgroup_free(mp, rgno);

}



/* Initialize some range of incore rtgroup objects. */

int

xfs_initialize_rtgroups(

	struct xfs_mount	*mp,

	xfs_rgnumber_t		first_rgno,

	xfs_rgnumber_t		end_rgno,

	xfs_rtbxlen_t		rextents)

{

	xfs_rgnumber_t		index;

	int			error;



	if (first_rgno >= end_rgno)

		return 0;



	for (index = first_rgno; index < end_rgno; index++) {

		error = xfs_rtgroup_alloc(mp, index, end_rgno, rextents);

		if (error)

			goto out_unwind_new_rtgs;

	}



	return 0;



out_unwind_new_rtgs:

	xfs_free_rtgroups(mp, first_rgno, index);

	return error;

}



/* Compute the number of rt extents in this realtime group. */

xfs_rtxnum_t

__xfs_rtgroup_extents(

	struct xfs_mount	*mp,

	xfs_rgnumber_t		rgno,

	xfs_rgnumber_t		rgcount,

	xfs_rtbxlen_t		rextents)

{

	ASSERT(rgno < rgcount);

	if (rgno == rgcount - 1)

		return rextents - ((xfs_rtxnum_t)rgno * mp->m_sb.sb_rgextents);



	ASSERT(xfs_has_rtgroups(mp));

	return mp->m_sb.sb_rgextents;

}



xfs_rtxnum_t

xfs_rtgroup_extents(

	struct xfs_mount	*mp,

	xfs_rgnumber_t		rgno)

{

	return __xfs_rtgroup_extents(mp, rgno, mp->m_sb.sb_rgcount,

			mp->m_sb.sb_rextents);

}



/*

 * Update the rt extent count of the previous tail rtgroup if it changed during

 * recovery (i.e. recovery of a growfs).

 */

int

xfs_update_last_rtgroup_size(

	struct xfs_mount	*mp,

	xfs_rgnumber_t		prev_rgcount)

{

	struct xfs_rtgroup	*rtg;



	ASSERT(prev_rgcount > 0);



	rtg = xfs_rtgroup_grab(mp, prev_rgcount - 1);

	if (!rtg)

		return -EFSCORRUPTED;

	rtg->rtg_extents = __xfs_rtgroup_extents(mp, prev_rgcount - 1,

			mp->m_sb.sb_rgcount, mp->m_sb.sb_rextents);

	xfs_rtgroup_rele(rtg);

	return 0;

}

fs/xfs/libxfs/xfs_rtgroup.h

0 → 100644
+217 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0-or-later */

/*

 * Copyright (c) 2022-2024 Oracle.  All Rights Reserved.

 * Author: Darrick J. Wong <djwong@kernel.org>

 */

#ifndef __LIBXFS_RTGROUP_H

#define __LIBXFS_RTGROUP_H 1



#include "xfs_group.h"



struct xfs_mount;

struct xfs_trans;



/*

 * Realtime group incore structure, similar to the per-AG structure.

 */

struct xfs_rtgroup {

	struct xfs_group	rtg_group;



	/* Number of blocks in this group */

	xfs_rtxnum_t		rtg_extents;

};



static inline struct xfs_rtgroup *to_rtg(struct xfs_group *xg)

{

	return container_of(xg, struct xfs_rtgroup, rtg_group);

}



static inline struct xfs_group *rtg_group(struct xfs_rtgroup *rtg)

{

	return &rtg->rtg_group;

}



static inline struct xfs_mount *rtg_mount(const struct xfs_rtgroup *rtg)

{

	return rtg->rtg_group.xg_mount;

}



static inline xfs_rgnumber_t rtg_rgno(const struct xfs_rtgroup *rtg)

{

	return rtg->rtg_group.xg_gno;

}



/* Passive rtgroup references */

static inline struct xfs_rtgroup *

xfs_rtgroup_get(

	struct xfs_mount	*mp,

	xfs_rgnumber_t		rgno)

{

	return to_rtg(xfs_group_get(mp, rgno, XG_TYPE_RTG));

}



static inline struct xfs_rtgroup *

xfs_rtgroup_hold(

	struct xfs_rtgroup	*rtg)

{

	return to_rtg(xfs_group_hold(rtg_group(rtg)));

}



static inline void

xfs_rtgroup_put(

	struct xfs_rtgroup	*rtg)

{

	xfs_group_put(rtg_group(rtg));

}



/* Active rtgroup references */

static inline struct xfs_rtgroup *

xfs_rtgroup_grab(

	struct xfs_mount	*mp,

	xfs_rgnumber_t		rgno)

{

	return to_rtg(xfs_group_grab(mp, rgno, XG_TYPE_RTG));

}



static inline void

xfs_rtgroup_rele(

	struct xfs_rtgroup	*rtg)

{

	xfs_group_rele(rtg_group(rtg));

}



static inline struct xfs_rtgroup *

xfs_rtgroup_next_range(

	struct xfs_mount	*mp,

	struct xfs_rtgroup	*rtg,

	xfs_rgnumber_t		start_rgno,

	xfs_rgnumber_t		end_rgno)

{

	return to_rtg(xfs_group_next_range(mp, rtg ? rtg_group(rtg) : NULL,

			start_rgno, end_rgno, XG_TYPE_RTG));

}



static inline struct xfs_rtgroup *

xfs_rtgroup_next(

	struct xfs_mount	*mp,

	struct xfs_rtgroup	*rtg)

{

	return xfs_rtgroup_next_range(mp, rtg, 0, mp->m_sb.sb_rgcount - 1);

}



static inline xfs_rtblock_t

xfs_rgno_start_rtb(

	struct xfs_mount	*mp,

	xfs_rgnumber_t		rgno)

{

	if (mp->m_rgblklog >= 0)

		return ((xfs_rtblock_t)rgno << mp->m_rgblklog);

	return ((xfs_rtblock_t)rgno * mp->m_rgblocks);

}



static inline xfs_rtblock_t

__xfs_rgbno_to_rtb(

	struct xfs_mount	*mp,

	xfs_rgnumber_t		rgno,

	xfs_rgblock_t		rgbno)

{

	return xfs_rgno_start_rtb(mp, rgno) + rgbno;

}



static inline xfs_rtblock_t

xfs_rgbno_to_rtb(

	struct xfs_rtgroup	*rtg,

	xfs_rgblock_t		rgbno)

{

	return __xfs_rgbno_to_rtb(rtg_mount(rtg), rtg_rgno(rtg), rgbno);

}



static inline xfs_rgnumber_t

xfs_rtb_to_rgno(

	struct xfs_mount	*mp,

	xfs_rtblock_t		rtbno)

{

	if (!xfs_has_rtgroups(mp))

		return 0;



	if (mp->m_rgblklog >= 0)

		return rtbno >> mp->m_rgblklog;



	return div_u64(rtbno, mp->m_rgblocks);

}



static inline uint64_t

__xfs_rtb_to_rgbno(

	struct xfs_mount	*mp,

	xfs_rtblock_t		rtbno)

{

	uint32_t		rem;



	if (!xfs_has_rtgroups(mp))

		return rtbno;



	if (mp->m_rgblklog >= 0)

		return rtbno & mp->m_rgblkmask;



	div_u64_rem(rtbno, mp->m_rgblocks, &rem);

	return rem;

}



static inline xfs_rgblock_t

xfs_rtb_to_rgbno(

	struct xfs_mount	*mp,

	xfs_rtblock_t		rtbno)

{

	return __xfs_rtb_to_rgbno(mp, rtbno);

}



static inline xfs_daddr_t

xfs_rtb_to_daddr(

	struct xfs_mount	*mp,

	xfs_rtblock_t		rtbno)

{

	return rtbno << mp->m_blkbb_log;

}



static inline xfs_rtblock_t

xfs_daddr_to_rtb(

	struct xfs_mount	*mp,

	xfs_daddr_t		daddr)

{

	return daddr >> mp->m_blkbb_log;

}



#ifdef CONFIG_XFS_RT

int xfs_rtgroup_alloc(struct xfs_mount *mp, xfs_rgnumber_t rgno,

		xfs_rgnumber_t rgcount, xfs_rtbxlen_t rextents);

void xfs_rtgroup_free(struct xfs_mount *mp, xfs_rgnumber_t rgno);



void xfs_free_rtgroups(struct xfs_mount *mp, xfs_rgnumber_t first_rgno,

		xfs_rgnumber_t end_rgno);

int xfs_initialize_rtgroups(struct xfs_mount *mp, xfs_rgnumber_t first_rgno,

		xfs_rgnumber_t end_rgno, xfs_rtbxlen_t rextents);



xfs_rtxnum_t __xfs_rtgroup_extents(struct xfs_mount *mp, xfs_rgnumber_t rgno,

		xfs_rgnumber_t rgcount, xfs_rtbxlen_t rextents);

xfs_rtxnum_t xfs_rtgroup_extents(struct xfs_mount *mp, xfs_rgnumber_t rgno);



int xfs_update_last_rtgroup_size(struct xfs_mount *mp,

		xfs_rgnumber_t prev_rgcount);

#else

static inline void xfs_free_rtgroups(struct xfs_mount *mp,

		xfs_rgnumber_t first_rgno, xfs_rgnumber_t end_rgno)

{

}



static inline int xfs_initialize_rtgroups(struct xfs_mount *mp,

		xfs_rgnumber_t first_rgno, xfs_rgnumber_t end_rgno,

		xfs_rtbxlen_t rextents)

{

	return 0;

}



# define xfs_rtgroup_extents(mp, rgno)		(0)

# define xfs_update_last_rtgroup_size(mp, rgno)	(-EOPNOTSUPP)

#endif /* CONFIG_XFS_RT */



#endif /* __LIBXFS_RTGROUP_H */

fs/xfs/libxfs/xfs_sb.c

+13 −0
Original line number Diff line number Diff line
@@ -696,6 +696,9 @@ __xfs_sb_from_disk( 
		to->sb_metadirino = be64_to_cpu(from->sb_metadirino);

	else

		to->sb_metadirino = NULLFSINO;



	to->sb_rgcount = 1;

	to->sb_rgextents = 0;

}



void
@@ -980,8 +983,18 @@ xfs_mount_sb_set_rextsize( 
	struct xfs_mount	*mp,

	struct xfs_sb		*sbp)

{

	struct xfs_groups	*rgs = &mp->m_groups[XG_TYPE_RTG];



	mp->m_rtxblklog = log2_if_power2(sbp->sb_rextsize);

	mp->m_rtxblkmask = mask64_if_power2(sbp->sb_rextsize);



	mp->m_rgblocks = 0;

	mp->m_rgblklog = 0;

	mp->m_rgblkmask = (uint64_t)-1;



	rgs->blocks = 0;

	rgs->blklog = 0;

	rgs->blkmask = (uint64_t)-1;

}



/*