xfs_rtgroup.h

  1/* SPDX-License-Identifier: GPL-2.0-or-later */
  2/*
  3 * Copyright (c) 2022-2024 Oracle.  All Rights Reserved.
  4 * Author: Darrick J. Wong <djwong@kernel.org>
  5 */
  6#ifndef __LIBXFS_RTGROUP_H
  7#define __LIBXFS_RTGROUP_H 1
  8
  9#include "xfs_group.h"
 10
 11struct xfs_mount;
 12struct xfs_trans;
 13
 14enum xfs_rtg_inodes {
 15	XFS_RTGI_BITMAP,	/* allocation bitmap */
 16	XFS_RTGI_SUMMARY,	/* allocation summary */
 17	XFS_RTGI_RMAP,		/* rmap btree inode */
 18	XFS_RTGI_REFCOUNT,	/* refcount btree inode */
 19
 20	XFS_RTGI_MAX,
 21};
 22
 23#ifdef MAX_LOCKDEP_SUBCLASSES
 24static_assert(XFS_RTGI_MAX <= MAX_LOCKDEP_SUBCLASSES);
 25#endif
 26
 27/*
 28 * Realtime group incore structure, similar to the per-AG structure.
 29 */
 30struct xfs_rtgroup {
 31	struct xfs_group	rtg_group;
 32
 33	/* per-rtgroup metadata inodes */
 34	struct xfs_inode	*rtg_inodes[XFS_RTGI_MAX];
 35
 36	/* Number of blocks in this group */
 37	xfs_rtxnum_t		rtg_extents;
 38
 39	/*
 40	 * For bitmap based RT devices this points to a cache of rt summary
 41	 * level per bitmap block with the invariant that rtg_rsum_cache[bbno]
 42	 * > the maximum i for which rsum[i][bbno] != 0, or 0 if
 43	 * rsum[i][bbno] == 0 for all i.
 44	 * Reads and writes are serialized by the rsumip inode lock.
 45	 *
 46	 * For zoned RT devices this points to the open zone structure for
 47	 * a group that is open for writers, or is NULL.
 48	 */
 49	union {
 50		uint8_t			*rtg_rsum_cache;
 51		struct xfs_open_zone	*rtg_open_zone;
 52	};
 53
 54	/*
 55	 * Count of outstanding GC operations for zoned XFS.  Any RTG with a
 56	 * non-zero rtg_gccount will not be picked as new GC victim.
 57	 */
 58	atomic_t		rtg_gccount;
 59};
 60
 61/*
 62 * For zoned RT devices this is set on groups that have no written blocks
 63 * and can be picked by the allocator for opening.
 64 */
 65#define XFS_RTG_FREE			XA_MARK_0
 66
 67static inline struct xfs_rtgroup *to_rtg(struct xfs_group *xg)
 68{
 69	return container_of(xg, struct xfs_rtgroup, rtg_group);
 70}
 71
 72static inline struct xfs_group *rtg_group(struct xfs_rtgroup *rtg)
 73{
 74	return &rtg->rtg_group;
 75}
 76
 77static inline struct xfs_mount *rtg_mount(const struct xfs_rtgroup *rtg)
 78{
 79	return rtg->rtg_group.xg_mount;
 80}
 81
 82static inline xfs_rgnumber_t rtg_rgno(const struct xfs_rtgroup *rtg)
 83{
 84	return rtg->rtg_group.xg_gno;
 85}
 86
 87static inline xfs_rgblock_t rtg_blocks(const struct xfs_rtgroup *rtg)
 88{
 89	return rtg->rtg_group.xg_block_count;
 90}
 91
 92static inline struct xfs_inode *rtg_bitmap(const struct xfs_rtgroup *rtg)
 93{
 94	return rtg->rtg_inodes[XFS_RTGI_BITMAP];
 95}
 96
 97static inline struct xfs_inode *rtg_summary(const struct xfs_rtgroup *rtg)
 98{
 99	return rtg->rtg_inodes[XFS_RTGI_SUMMARY];
100}
101
102static inline struct xfs_inode *rtg_rmap(const struct xfs_rtgroup *rtg)
103{
104	return rtg->rtg_inodes[XFS_RTGI_RMAP];
105}
106
107static inline struct xfs_inode *rtg_refcount(const struct xfs_rtgroup *rtg)
108{
109	return rtg->rtg_inodes[XFS_RTGI_REFCOUNT];
110}
111
112/* Passive rtgroup references */
113static inline struct xfs_rtgroup *
114xfs_rtgroup_get(
115	struct xfs_mount	*mp,
116	xfs_rgnumber_t		rgno)
117{
118	return to_rtg(xfs_group_get(mp, rgno, XG_TYPE_RTG));
119}
120
121static inline struct xfs_rtgroup *
122xfs_rtgroup_hold(
123	struct xfs_rtgroup	*rtg)
124{
125	return to_rtg(xfs_group_hold(rtg_group(rtg)));
126}
127
128static inline void
129xfs_rtgroup_put(
130	struct xfs_rtgroup	*rtg)
131{
132	xfs_group_put(rtg_group(rtg));
133}
134
135/* Active rtgroup references */
136static inline struct xfs_rtgroup *
137xfs_rtgroup_grab(
138	struct xfs_mount	*mp,
139	xfs_rgnumber_t		rgno)
140{
141	return to_rtg(xfs_group_grab(mp, rgno, XG_TYPE_RTG));
142}
143
144static inline void
145xfs_rtgroup_rele(
146	struct xfs_rtgroup	*rtg)
147{
148	xfs_group_rele(rtg_group(rtg));
149}
150
151static inline struct xfs_rtgroup *
152xfs_rtgroup_next_range(
153	struct xfs_mount	*mp,
154	struct xfs_rtgroup	*rtg,
155	xfs_rgnumber_t		start_rgno,
156	xfs_rgnumber_t		end_rgno)
157{
158	return to_rtg(xfs_group_next_range(mp, rtg ? rtg_group(rtg) : NULL,
159			start_rgno, end_rgno, XG_TYPE_RTG));
160}
161
162static inline struct xfs_rtgroup *
163xfs_rtgroup_next(
164	struct xfs_mount	*mp,
165	struct xfs_rtgroup	*rtg)
166{
167	return xfs_rtgroup_next_range(mp, rtg, 0, mp->m_sb.sb_rgcount - 1);
168}
169
170static inline bool
171xfs_verify_rgbno(
172	struct xfs_rtgroup	*rtg,
173	xfs_rgblock_t		rgbno)
174{
175	ASSERT(xfs_has_rtgroups(rtg_mount(rtg)));
176
177	return xfs_verify_gbno(rtg_group(rtg), rgbno);
178}
179
180/*
181 * Check that [@rgbno,@len] is a valid extent range in @rtg.
182 *
183 * Must only be used for RTG-enabled file systems.
184 */
185static inline bool
186xfs_verify_rgbext(
187	struct xfs_rtgroup	*rtg,
188	xfs_rgblock_t		rgbno,
189	xfs_extlen_t		len)
190{
191	ASSERT(xfs_has_rtgroups(rtg_mount(rtg)));
192
193	return xfs_verify_gbext(rtg_group(rtg), rgbno, len);
194}
195
196static inline xfs_rtblock_t
197xfs_rgbno_to_rtb(
198	struct xfs_rtgroup	*rtg,
199	xfs_rgblock_t		rgbno)
200{
201	return xfs_gbno_to_fsb(rtg_group(rtg), rgbno);
202}
203
204static inline xfs_rgnumber_t
205xfs_rtb_to_rgno(
206	struct xfs_mount	*mp,
207	xfs_rtblock_t		rtbno)
208{
209	return xfs_fsb_to_gno(mp, rtbno, XG_TYPE_RTG);
210}
211
212static inline xfs_rgblock_t
213xfs_rtb_to_rgbno(
214	struct xfs_mount	*mp,
215	xfs_rtblock_t		rtbno)
216{
217	return xfs_fsb_to_gbno(mp, rtbno, XG_TYPE_RTG);
218}
219
220/* Is rtbno the start of a RT group? */
221static inline bool
222xfs_rtbno_is_group_start(
223	struct xfs_mount	*mp,
224	xfs_rtblock_t		rtbno)
225{
226	return (rtbno & mp->m_groups[XG_TYPE_RTG].blkmask) == 0;
227}
228
229/* Convert an rtgroups rt extent number into an rgbno. */
230static inline xfs_rgblock_t
231xfs_rtx_to_rgbno(
232	struct xfs_rtgroup	*rtg,
233	xfs_rtxnum_t		rtx)
234{
235	struct xfs_mount	*mp = rtg_mount(rtg);
236
237	if (likely(mp->m_rtxblklog >= 0))
238		return rtx << mp->m_rtxblklog;
239	return rtx * mp->m_sb.sb_rextsize;
240}
241
242static inline xfs_daddr_t
243xfs_rtb_to_daddr(
244	struct xfs_mount	*mp,
245	xfs_rtblock_t		rtbno)
246{
247	struct xfs_groups	*g = &mp->m_groups[XG_TYPE_RTG];
248
249	if (xfs_has_rtgroups(mp) && !g->has_daddr_gaps) {
250		xfs_rgnumber_t	rgno = xfs_rtb_to_rgno(mp, rtbno);
251
252		rtbno = (xfs_rtblock_t)rgno * g->blocks + (rtbno & g->blkmask);
253	}
254
255	return XFS_FSB_TO_BB(mp, g->start_fsb + rtbno);
256}
257
258static inline xfs_rtblock_t
259xfs_daddr_to_rtb(
260	struct xfs_mount	*mp,
261	xfs_daddr_t		daddr)
262{
263	struct xfs_groups	*g = &mp->m_groups[XG_TYPE_RTG];
264	xfs_rfsblock_t		bno;
265
266	bno = XFS_BB_TO_FSBT(mp, daddr) - g->start_fsb;
267	if (xfs_has_rtgroups(mp) && !g->has_daddr_gaps) {
268		xfs_rgnumber_t	rgno;
269		uint32_t	rgbno;
270
271		rgno = div_u64_rem(bno, g->blocks, &rgbno);
272		return ((xfs_rtblock_t)rgno << g->blklog) + rgbno;
273	}
274
275	return bno;
276}
277
278#ifdef CONFIG_XFS_RT
279int xfs_rtgroup_alloc(struct xfs_mount *mp, xfs_rgnumber_t rgno,
280		xfs_rgnumber_t rgcount, xfs_rtbxlen_t rextents);
281void xfs_rtgroup_free(struct xfs_mount *mp, xfs_rgnumber_t rgno);
282
283void xfs_free_rtgroups(struct xfs_mount *mp, xfs_rgnumber_t first_rgno,
284		xfs_rgnumber_t end_rgno);
285int xfs_initialize_rtgroups(struct xfs_mount *mp, xfs_rgnumber_t first_rgno,
286		xfs_rgnumber_t end_rgno, xfs_rtbxlen_t rextents);
287
288xfs_rtxnum_t xfs_rtgroup_extents(struct xfs_mount *mp, xfs_rgnumber_t rgno);
289void xfs_rtgroup_calc_geometry(struct xfs_mount *mp, struct xfs_rtgroup *rtg,
290		xfs_rgnumber_t rgno, xfs_rgnumber_t rgcount,
291		xfs_rtbxlen_t rextents);
292
293int xfs_update_last_rtgroup_size(struct xfs_mount *mp,
294		xfs_rgnumber_t prev_rgcount);
295
296/* Lock the rt bitmap inode in exclusive mode */
297#define XFS_RTGLOCK_BITMAP		(1U << 0)
298/* Lock the rt bitmap inode in shared mode */
299#define XFS_RTGLOCK_BITMAP_SHARED	(1U << 1)
300/* Lock the rt rmap inode in exclusive mode */
301#define XFS_RTGLOCK_RMAP		(1U << 2)
302/* Lock the rt refcount inode in exclusive mode */
303#define XFS_RTGLOCK_REFCOUNT		(1U << 3)
304
305#define XFS_RTGLOCK_ALL_FLAGS	(XFS_RTGLOCK_BITMAP | \
306				 XFS_RTGLOCK_BITMAP_SHARED | \
307				 XFS_RTGLOCK_RMAP | \
308				 XFS_RTGLOCK_REFCOUNT)
309
310void xfs_rtgroup_lock(struct xfs_rtgroup *rtg, unsigned int rtglock_flags);
311void xfs_rtgroup_unlock(struct xfs_rtgroup *rtg, unsigned int rtglock_flags);
312void xfs_rtgroup_trans_join(struct xfs_trans *tp, struct xfs_rtgroup *rtg,
313		unsigned int rtglock_flags);
314
315int xfs_rtgroup_get_geometry(struct xfs_rtgroup *rtg,
316		struct xfs_rtgroup_geometry *rgeo);
317
318int xfs_rtginode_mkdir_parent(struct xfs_mount *mp);
319int xfs_rtginode_load_parent(struct xfs_trans *tp);
320
321const char *xfs_rtginode_name(enum xfs_rtg_inodes type);
322enum xfs_metafile_type xfs_rtginode_metafile_type(enum xfs_rtg_inodes type);
323bool xfs_rtginode_enabled(struct xfs_rtgroup *rtg, enum xfs_rtg_inodes type);
324void xfs_rtginode_mark_sick(struct xfs_rtgroup *rtg, enum xfs_rtg_inodes type);
325int xfs_rtginode_load(struct xfs_rtgroup *rtg, enum xfs_rtg_inodes type,
326		struct xfs_trans *tp);
327int xfs_rtginode_create(struct xfs_rtgroup *rtg, enum xfs_rtg_inodes type,
328		bool init);
329void xfs_rtginode_irele(struct xfs_inode **ipp);
330
331void xfs_rtginode_irele(struct xfs_inode **ipp);
332
333static inline const char *xfs_rtginode_path(xfs_rgnumber_t rgno,
334		enum xfs_rtg_inodes type)
335{
336	return kasprintf(GFP_KERNEL, "%u.%s", rgno, xfs_rtginode_name(type));
337}
338
339void xfs_update_rtsb(struct xfs_buf *rtsb_bp,
340		const struct xfs_buf *sb_bp);
341struct xfs_buf *xfs_log_rtsb(struct xfs_trans *tp,
342		const struct xfs_buf *sb_bp);
343#else
344static inline void xfs_free_rtgroups(struct xfs_mount *mp,
345		xfs_rgnumber_t first_rgno, xfs_rgnumber_t end_rgno)
346{
347}
348
349static inline int xfs_initialize_rtgroups(struct xfs_mount *mp,
350		xfs_rgnumber_t first_rgno, xfs_rgnumber_t end_rgno,
351		xfs_rtbxlen_t rextents)
352{
353	return 0;
354}
355
356# define xfs_rtgroup_extents(mp, rgno)		(0)
357# define xfs_update_last_rtgroup_size(mp, rgno)	(0)
358# define xfs_rtgroup_lock(rtg, gf)		((void)0)
359# define xfs_rtgroup_unlock(rtg, gf)		((void)0)
360# define xfs_rtgroup_trans_join(tp, rtg, gf)	((void)0)
361# define xfs_update_rtsb(bp, sb_bp)	((void)0)
362# define xfs_log_rtsb(tp, sb_bp)	(NULL)
363# define xfs_rtgroup_get_geometry(rtg, rgeo)	(-EOPNOTSUPP)
364#endif /* CONFIG_XFS_RT */
365
366static inline xfs_rfsblock_t
367xfs_rtgs_to_rfsbs(
368	struct xfs_mount	*mp,
369	uint32_t		nr_groups)
370{
371	return xfs_groups_to_rfsbs(mp, nr_groups, XG_TYPE_RTG);
372}
373
374#endif /* __LIBXFS_RTGROUP_H */