xref: /linux/fs/xfs/libxfs/xfs_ag.h (revision 4b660dbd9ee2059850fd30e0df420ca7a38a1856)
1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3  * Copyright (c) 2018 Red Hat, Inc.
4  * All rights reserved.
5  */
6 
7 #ifndef __LIBXFS_AG_H
8 #define __LIBXFS_AG_H 1
9 
10 struct xfs_mount;
11 struct xfs_trans;
12 struct xfs_perag;
13 
14 /*
15  * Per-ag infrastructure
16  */
17 
18 /* per-AG block reservation data structures*/
19 struct xfs_ag_resv {
20 	/* number of blocks originally reserved here */
21 	xfs_extlen_t			ar_orig_reserved;
22 	/* number of blocks reserved here */
23 	xfs_extlen_t			ar_reserved;
24 	/* number of blocks originally asked for */
25 	xfs_extlen_t			ar_asked;
26 };
27 
28 /*
29  * Per-ag incore structure, copies of information in agf and agi, to improve the
30  * performance of allocation group selection.
31  */
32 struct xfs_perag {
33 	struct xfs_mount *pag_mount;	/* owner filesystem */
34 	xfs_agnumber_t	pag_agno;	/* AG this structure belongs to */
35 	atomic_t	pag_ref;	/* passive reference count */
36 	atomic_t	pag_active_ref;	/* active reference count */
37 	wait_queue_head_t pag_active_wq;/* woken active_ref falls to zero */
38 	unsigned long	pag_opstate;
39 	uint8_t		pagf_bno_level;	/* # of levels in bno btree */
40 	uint8_t		pagf_cnt_level;	/* # of levels in cnt btree */
41 	uint8_t		pagf_rmap_level;/* # of levels in rmap btree */
42 	uint32_t	pagf_flcount;	/* count of blocks in freelist */
43 	xfs_extlen_t	pagf_freeblks;	/* total free blocks */
44 	xfs_extlen_t	pagf_longest;	/* longest free space */
45 	uint32_t	pagf_btreeblks;	/* # of blocks held in AGF btrees */
46 	xfs_agino_t	pagi_freecount;	/* number of free inodes */
47 	xfs_agino_t	pagi_count;	/* number of allocated inodes */
48 
49 	/*
50 	 * Inode allocation search lookup optimisation.
51 	 * If the pagino matches, the search for new inodes
52 	 * doesn't need to search the near ones again straight away
53 	 */
54 	xfs_agino_t	pagl_pagino;
55 	xfs_agino_t	pagl_leftrec;
56 	xfs_agino_t	pagl_rightrec;
57 
58 	int		pagb_count;	/* pagb slots in use */
59 	uint8_t		pagf_refcount_level; /* recount btree height */
60 
61 	/* Blocks reserved for all kinds of metadata. */
62 	struct xfs_ag_resv	pag_meta_resv;
63 	/* Blocks reserved for the reverse mapping btree. */
64 	struct xfs_ag_resv	pag_rmapbt_resv;
65 
66 	/* for rcu-safe freeing */
67 	struct rcu_head	rcu_head;
68 
69 	/* Precalculated geometry info */
70 	xfs_agblock_t		block_count;
71 	xfs_agblock_t		min_block;
72 	xfs_agino_t		agino_min;
73 	xfs_agino_t		agino_max;
74 
75 #ifdef __KERNEL__
76 	/* -- kernel only structures below this line -- */
77 
78 	/*
79 	 * Bitsets of per-ag metadata that have been checked and/or are sick.
80 	 * Callers should hold pag_state_lock before accessing this field.
81 	 */
82 	uint16_t	pag_checked;
83 	uint16_t	pag_sick;
84 
85 #ifdef CONFIG_XFS_ONLINE_REPAIR
86 	/*
87 	 * Alternate btree heights so that online repair won't trip the write
88 	 * verifiers while rebuilding the AG btrees.
89 	 */
90 	uint8_t		pagf_repair_bno_level;
91 	uint8_t		pagf_repair_cnt_level;
92 	uint8_t		pagf_repair_refcount_level;
93 	uint8_t		pagf_repair_rmap_level;
94 #endif
95 
96 	spinlock_t	pag_state_lock;
97 
98 	spinlock_t	pagb_lock;	/* lock for pagb_tree */
99 	struct rb_root	pagb_tree;	/* ordered tree of busy extents */
100 	unsigned int	pagb_gen;	/* generation count for pagb_tree */
101 	wait_queue_head_t pagb_wait;	/* woken when pagb_gen changes */
102 
103 	atomic_t        pagf_fstrms;    /* # of filestreams active in this AG */
104 
105 	spinlock_t	pag_ici_lock;	/* incore inode cache lock */
106 	struct radix_tree_root pag_ici_root;	/* incore inode cache root */
107 	int		pag_ici_reclaimable;	/* reclaimable inodes */
108 	unsigned long	pag_ici_reclaim_cursor;	/* reclaim restart point */
109 
110 	struct xfs_buf_cache	pag_bcache;
111 
112 	/* background prealloc block trimming */
113 	struct delayed_work	pag_blockgc_work;
114 
115 	/*
116 	 * We use xfs_drain to track the number of deferred log intent items
117 	 * that have been queued (but not yet processed) so that waiters (e.g.
118 	 * scrub) will not lock resources when other threads are in the middle
119 	 * of processing a chain of intent items only to find momentary
120 	 * inconsistencies.
121 	 */
122 	struct xfs_defer_drain	pag_intents_drain;
123 
124 	/* Hook to feed rmapbt updates to an active online repair. */
125 	struct xfs_hooks	pag_rmap_update_hooks;
126 #endif /* __KERNEL__ */
127 };
128 
129 /*
130  * Per-AG operational state. These are atomic flag bits.
131  */
132 #define XFS_AGSTATE_AGF_INIT		0
133 #define XFS_AGSTATE_AGI_INIT		1
134 #define XFS_AGSTATE_PREFERS_METADATA	2
135 #define XFS_AGSTATE_ALLOWS_INODES	3
136 #define XFS_AGSTATE_AGFL_NEEDS_RESET	4
137 
138 #define __XFS_AG_OPSTATE(name, NAME) \
139 static inline bool xfs_perag_ ## name (struct xfs_perag *pag) \
140 { \
141 	return test_bit(XFS_AGSTATE_ ## NAME, &pag->pag_opstate); \
142 }
143 
144 __XFS_AG_OPSTATE(initialised_agf, AGF_INIT)
145 __XFS_AG_OPSTATE(initialised_agi, AGI_INIT)
146 __XFS_AG_OPSTATE(prefers_metadata, PREFERS_METADATA)
147 __XFS_AG_OPSTATE(allows_inodes, ALLOWS_INODES)
148 __XFS_AG_OPSTATE(agfl_needs_reset, AGFL_NEEDS_RESET)
149 
150 void xfs_free_unused_perag_range(struct xfs_mount *mp, xfs_agnumber_t agstart,
151 			xfs_agnumber_t agend);
152 int xfs_initialize_perag(struct xfs_mount *mp, xfs_agnumber_t agcount,
153 			xfs_rfsblock_t dcount, xfs_agnumber_t *maxagi);
154 int xfs_initialize_perag_data(struct xfs_mount *mp, xfs_agnumber_t agno);
155 void xfs_free_perag(struct xfs_mount *mp);
156 
157 /* Passive AG references */
158 struct xfs_perag *xfs_perag_get(struct xfs_mount *mp, xfs_agnumber_t agno);
159 struct xfs_perag *xfs_perag_get_tag(struct xfs_mount *mp, xfs_agnumber_t agno,
160 		unsigned int tag);
161 struct xfs_perag *xfs_perag_hold(struct xfs_perag *pag);
162 void xfs_perag_put(struct xfs_perag *pag);
163 
164 /* Active AG references */
165 struct xfs_perag *xfs_perag_grab(struct xfs_mount *, xfs_agnumber_t);
166 struct xfs_perag *xfs_perag_grab_tag(struct xfs_mount *, xfs_agnumber_t,
167 				   int tag);
168 void xfs_perag_rele(struct xfs_perag *pag);
169 
170 /*
171  * Per-ag geometry infomation and validation
172  */
173 xfs_agblock_t xfs_ag_block_count(struct xfs_mount *mp, xfs_agnumber_t agno);
174 void xfs_agino_range(struct xfs_mount *mp, xfs_agnumber_t agno,
175 		xfs_agino_t *first, xfs_agino_t *last);
176 
177 static inline bool
178 xfs_verify_agbno(struct xfs_perag *pag, xfs_agblock_t agbno)
179 {
180 	if (agbno >= pag->block_count)
181 		return false;
182 	if (agbno <= pag->min_block)
183 		return false;
184 	return true;
185 }
186 
187 static inline bool
188 xfs_verify_agbext(
189 	struct xfs_perag	*pag,
190 	xfs_agblock_t		agbno,
191 	xfs_agblock_t		len)
192 {
193 	if (agbno + len <= agbno)
194 		return false;
195 
196 	if (!xfs_verify_agbno(pag, agbno))
197 		return false;
198 
199 	return xfs_verify_agbno(pag, agbno + len - 1);
200 }
201 
202 /*
203  * Verify that an AG inode number pointer neither points outside the AG
204  * nor points at static metadata.
205  */
206 static inline bool
207 xfs_verify_agino(struct xfs_perag *pag, xfs_agino_t agino)
208 {
209 	if (agino < pag->agino_min)
210 		return false;
211 	if (agino > pag->agino_max)
212 		return false;
213 	return true;
214 }
215 
216 /*
217  * Verify that an AG inode number pointer neither points outside the AG
218  * nor points at static metadata, or is NULLAGINO.
219  */
220 static inline bool
221 xfs_verify_agino_or_null(struct xfs_perag *pag, xfs_agino_t agino)
222 {
223 	if (agino == NULLAGINO)
224 		return true;
225 	return xfs_verify_agino(pag, agino);
226 }
227 
228 static inline bool
229 xfs_ag_contains_log(struct xfs_mount *mp, xfs_agnumber_t agno)
230 {
231 	return mp->m_sb.sb_logstart > 0 &&
232 	       agno == XFS_FSB_TO_AGNO(mp, mp->m_sb.sb_logstart);
233 }
234 
235 /*
236  * Perag iteration APIs
237  */
238 static inline struct xfs_perag *
239 xfs_perag_next(
240 	struct xfs_perag	*pag,
241 	xfs_agnumber_t		*agno,
242 	xfs_agnumber_t		end_agno)
243 {
244 	struct xfs_mount	*mp = pag->pag_mount;
245 
246 	*agno = pag->pag_agno + 1;
247 	xfs_perag_rele(pag);
248 	while (*agno <= end_agno) {
249 		pag = xfs_perag_grab(mp, *agno);
250 		if (pag)
251 			return pag;
252 		(*agno)++;
253 	}
254 	return NULL;
255 }
256 
257 #define for_each_perag_range(mp, agno, end_agno, pag) \
258 	for ((pag) = xfs_perag_grab((mp), (agno)); \
259 		(pag) != NULL; \
260 		(pag) = xfs_perag_next((pag), &(agno), (end_agno)))
261 
262 #define for_each_perag_from(mp, agno, pag) \
263 	for_each_perag_range((mp), (agno), (mp)->m_sb.sb_agcount - 1, (pag))
264 
265 #define for_each_perag(mp, agno, pag) \
266 	(agno) = 0; \
267 	for_each_perag_from((mp), (agno), (pag))
268 
269 #define for_each_perag_tag(mp, agno, pag, tag) \
270 	for ((agno) = 0, (pag) = xfs_perag_grab_tag((mp), 0, (tag)); \
271 		(pag) != NULL; \
272 		(agno) = (pag)->pag_agno + 1, \
273 		xfs_perag_rele(pag), \
274 		(pag) = xfs_perag_grab_tag((mp), (agno), (tag)))
275 
276 static inline struct xfs_perag *
277 xfs_perag_next_wrap(
278 	struct xfs_perag	*pag,
279 	xfs_agnumber_t		*agno,
280 	xfs_agnumber_t		stop_agno,
281 	xfs_agnumber_t		restart_agno,
282 	xfs_agnumber_t		wrap_agno)
283 {
284 	struct xfs_mount	*mp = pag->pag_mount;
285 
286 	*agno = pag->pag_agno + 1;
287 	xfs_perag_rele(pag);
288 	while (*agno != stop_agno) {
289 		if (*agno >= wrap_agno) {
290 			if (restart_agno >= stop_agno)
291 				break;
292 			*agno = restart_agno;
293 		}
294 
295 		pag = xfs_perag_grab(mp, *agno);
296 		if (pag)
297 			return pag;
298 		(*agno)++;
299 	}
300 	return NULL;
301 }
302 
303 /*
304  * Iterate all AGs from start_agno through wrap_agno, then restart_agno through
305  * (start_agno - 1).
306  */
307 #define for_each_perag_wrap_range(mp, start_agno, restart_agno, wrap_agno, agno, pag) \
308 	for ((agno) = (start_agno), (pag) = xfs_perag_grab((mp), (agno)); \
309 		(pag) != NULL; \
310 		(pag) = xfs_perag_next_wrap((pag), &(agno), (start_agno), \
311 				(restart_agno), (wrap_agno)))
312 /*
313  * Iterate all AGs from start_agno through wrap_agno, then 0 through
314  * (start_agno - 1).
315  */
316 #define for_each_perag_wrap_at(mp, start_agno, wrap_agno, agno, pag) \
317 	for_each_perag_wrap_range((mp), (start_agno), 0, (wrap_agno), (agno), (pag))
318 
319 /*
320  * Iterate all AGs from start_agno through to the end of the filesystem, then 0
321  * through (start_agno - 1).
322  */
323 #define for_each_perag_wrap(mp, start_agno, agno, pag) \
324 	for_each_perag_wrap_at((mp), (start_agno), (mp)->m_sb.sb_agcount, \
325 				(agno), (pag))
326 
327 
328 struct aghdr_init_data {
329 	/* per ag data */
330 	xfs_agblock_t		agno;		/* ag to init */
331 	xfs_extlen_t		agsize;		/* new AG size */
332 	struct list_head	buffer_list;	/* buffer writeback list */
333 	xfs_rfsblock_t		nfree;		/* cumulative new free space */
334 
335 	/* per header data */
336 	xfs_daddr_t		daddr;		/* header location */
337 	size_t			numblks;	/* size of header */
338 	const struct xfs_btree_ops *bc_ops;	/* btree ops */
339 };
340 
341 int xfs_ag_init_headers(struct xfs_mount *mp, struct aghdr_init_data *id);
342 int xfs_ag_shrink_space(struct xfs_perag *pag, struct xfs_trans **tpp,
343 			xfs_extlen_t delta);
344 int xfs_ag_extend_space(struct xfs_perag *pag, struct xfs_trans *tp,
345 			xfs_extlen_t len);
346 int xfs_ag_get_geometry(struct xfs_perag *pag, struct xfs_ag_geometry *ageo);
347 
348 #endif /* __LIBXFS_AG_H */
349