Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
4 * All Rights Reserved.
5 */
6#ifndef __XFS_RTBITMAP_H__
7#define __XFS_RTBITMAP_H__
8
9struct xfs_rtalloc_args {
10 struct xfs_mount *mp;
11 struct xfs_trans *tp;
12
13 struct xfs_buf *rbmbp; /* bitmap block buffer */
14 struct xfs_buf *sumbp; /* summary block buffer */
15
16 xfs_fileoff_t rbmoff; /* bitmap block number */
17 xfs_fileoff_t sumoff; /* summary block number */
18};
19
20static inline xfs_rtblock_t
21xfs_rtx_to_rtb(
22 struct xfs_mount *mp,
23 xfs_rtxnum_t rtx)
24{
25 if (mp->m_rtxblklog >= 0)
26 return rtx << mp->m_rtxblklog;
27
28 return rtx * mp->m_sb.sb_rextsize;
29}
30
31static inline xfs_extlen_t
32xfs_rtxlen_to_extlen(
33 struct xfs_mount *mp,
34 xfs_rtxlen_t rtxlen)
35{
36 if (mp->m_rtxblklog >= 0)
37 return rtxlen << mp->m_rtxblklog;
38
39 return rtxlen * mp->m_sb.sb_rextsize;
40}
41
42/* Compute the misalignment between an extent length and a realtime extent .*/
43static inline unsigned int
44xfs_extlen_to_rtxmod(
45 struct xfs_mount *mp,
46 xfs_extlen_t len)
47{
48 if (mp->m_rtxblklog >= 0)
49 return len & mp->m_rtxblkmask;
50
51 return len % mp->m_sb.sb_rextsize;
52}
53
54static inline xfs_rtxlen_t
55xfs_extlen_to_rtxlen(
56 struct xfs_mount *mp,
57 xfs_extlen_t len)
58{
59 if (mp->m_rtxblklog >= 0)
60 return len >> mp->m_rtxblklog;
61
62 return len / mp->m_sb.sb_rextsize;
63}
64
65/* Convert an rt block number into an rt extent number. */
66static inline xfs_rtxnum_t
67xfs_rtb_to_rtx(
68 struct xfs_mount *mp,
69 xfs_rtblock_t rtbno)
70{
71 if (likely(mp->m_rtxblklog >= 0))
72 return rtbno >> mp->m_rtxblklog;
73
74 return div_u64(rtbno, mp->m_sb.sb_rextsize);
75}
76
77/* Return the offset of an rt block number within an rt extent. */
78static inline xfs_extlen_t
79xfs_rtb_to_rtxoff(
80 struct xfs_mount *mp,
81 xfs_rtblock_t rtbno)
82{
83 if (likely(mp->m_rtxblklog >= 0))
84 return rtbno & mp->m_rtxblkmask;
85
86 return do_div(rtbno, mp->m_sb.sb_rextsize);
87}
88
89/*
90 * Crack an rt block number into an rt extent number and an offset within that
91 * rt extent. Returns the rt extent number directly and the offset in @off.
92 */
93static inline xfs_rtxnum_t
94xfs_rtb_to_rtxrem(
95 struct xfs_mount *mp,
96 xfs_rtblock_t rtbno,
97 xfs_extlen_t *off)
98{
99 if (likely(mp->m_rtxblklog >= 0)) {
100 *off = rtbno & mp->m_rtxblkmask;
101 return rtbno >> mp->m_rtxblklog;
102 }
103
104 return div_u64_rem(rtbno, mp->m_sb.sb_rextsize, off);
105}
106
107/*
108 * Convert an rt block number into an rt extent number, rounding up to the next
109 * rt extent if the rt block is not aligned to an rt extent boundary.
110 */
111static inline xfs_rtxnum_t
112xfs_rtb_to_rtxup(
113 struct xfs_mount *mp,
114 xfs_rtblock_t rtbno)
115{
116 if (likely(mp->m_rtxblklog >= 0)) {
117 if (rtbno & mp->m_rtxblkmask)
118 return (rtbno >> mp->m_rtxblklog) + 1;
119 return rtbno >> mp->m_rtxblklog;
120 }
121
122 if (do_div(rtbno, mp->m_sb.sb_rextsize))
123 rtbno++;
124 return rtbno;
125}
126
127/* Round this rtblock up to the nearest rt extent size. */
128static inline xfs_rtblock_t
129xfs_rtb_roundup_rtx(
130 struct xfs_mount *mp,
131 xfs_rtblock_t rtbno)
132{
133 return roundup_64(rtbno, mp->m_sb.sb_rextsize);
134}
135
136/* Round this rtblock down to the nearest rt extent size. */
137static inline xfs_rtblock_t
138xfs_rtb_rounddown_rtx(
139 struct xfs_mount *mp,
140 xfs_rtblock_t rtbno)
141{
142 return rounddown_64(rtbno, mp->m_sb.sb_rextsize);
143}
144
145/* Convert an rt extent number to a file block offset in the rt bitmap file. */
146static inline xfs_fileoff_t
147xfs_rtx_to_rbmblock(
148 struct xfs_mount *mp,
149 xfs_rtxnum_t rtx)
150{
151 return rtx >> mp->m_blkbit_log;
152}
153
154/* Convert an rt extent number to a word offset within an rt bitmap block. */
155static inline unsigned int
156xfs_rtx_to_rbmword(
157 struct xfs_mount *mp,
158 xfs_rtxnum_t rtx)
159{
160 return (rtx >> XFS_NBWORDLOG) & (mp->m_blockwsize - 1);
161}
162
163/* Convert a file block offset in the rt bitmap file to an rt extent number. */
164static inline xfs_rtxnum_t
165xfs_rbmblock_to_rtx(
166 struct xfs_mount *mp,
167 xfs_fileoff_t rbmoff)
168{
169 return rbmoff << mp->m_blkbit_log;
170}
171
172/* Return a pointer to a bitmap word within a rt bitmap block. */
173static inline union xfs_rtword_raw *
174xfs_rbmblock_wordptr(
175 struct xfs_rtalloc_args *args,
176 unsigned int index)
177{
178 union xfs_rtword_raw *words = args->rbmbp->b_addr;
179
180 return words + index;
181}
182
183/* Convert an ondisk bitmap word to its incore representation. */
184static inline xfs_rtword_t
185xfs_rtbitmap_getword(
186 struct xfs_rtalloc_args *args,
187 unsigned int index)
188{
189 union xfs_rtword_raw *word = xfs_rbmblock_wordptr(args, index);
190
191 return word->old;
192}
193
194/* Set an ondisk bitmap word from an incore representation. */
195static inline void
196xfs_rtbitmap_setword(
197 struct xfs_rtalloc_args *args,
198 unsigned int index,
199 xfs_rtword_t value)
200{
201 union xfs_rtword_raw *word = xfs_rbmblock_wordptr(args, index);
202
203 word->old = value;
204}
205
206/*
207 * Convert a rt extent length and rt bitmap block number to a xfs_suminfo_t
208 * offset within the rt summary file.
209 */
210static inline xfs_rtsumoff_t
211xfs_rtsumoffs(
212 struct xfs_mount *mp,
213 int log2_len,
214 xfs_fileoff_t rbmoff)
215{
216 return log2_len * mp->m_sb.sb_rbmblocks + rbmoff;
217}
218
219/*
220 * Convert an xfs_suminfo_t offset to a file block offset within the rt summary
221 * file.
222 */
223static inline xfs_fileoff_t
224xfs_rtsumoffs_to_block(
225 struct xfs_mount *mp,
226 xfs_rtsumoff_t rsumoff)
227{
228 return XFS_B_TO_FSBT(mp, rsumoff * sizeof(xfs_suminfo_t));
229}
230
231/*
232 * Convert an xfs_suminfo_t offset to an info word offset within an rt summary
233 * block.
234 */
235static inline unsigned int
236xfs_rtsumoffs_to_infoword(
237 struct xfs_mount *mp,
238 xfs_rtsumoff_t rsumoff)
239{
240 unsigned int mask = mp->m_blockmask >> XFS_SUMINFOLOG;
241
242 return rsumoff & mask;
243}
244
245/* Return a pointer to a summary info word within a rt summary block. */
246static inline union xfs_suminfo_raw *
247xfs_rsumblock_infoptr(
248 struct xfs_rtalloc_args *args,
249 unsigned int index)
250{
251 union xfs_suminfo_raw *info = args->sumbp->b_addr;
252
253 return info + index;
254}
255
256/* Get the current value of a summary counter. */
257static inline xfs_suminfo_t
258xfs_suminfo_get(
259 struct xfs_rtalloc_args *args,
260 unsigned int index)
261{
262 union xfs_suminfo_raw *info = xfs_rsumblock_infoptr(args, index);
263
264 return info->old;
265}
266
267/* Add to the current value of a summary counter and return the new value. */
268static inline xfs_suminfo_t
269xfs_suminfo_add(
270 struct xfs_rtalloc_args *args,
271 unsigned int index,
272 int delta)
273{
274 union xfs_suminfo_raw *info = xfs_rsumblock_infoptr(args, index);
275
276 info->old += delta;
277 return info->old;
278}
279
280/*
281 * Functions for walking free space rtextents in the realtime bitmap.
282 */
283struct xfs_rtalloc_rec {
284 xfs_rtxnum_t ar_startext;
285 xfs_rtbxlen_t ar_extcount;
286};
287
288typedef int (*xfs_rtalloc_query_range_fn)(
289 struct xfs_mount *mp,
290 struct xfs_trans *tp,
291 const struct xfs_rtalloc_rec *rec,
292 void *priv);
293
294#ifdef CONFIG_XFS_RT
295void xfs_rtbuf_cache_relse(struct xfs_rtalloc_args *args);
296
297int xfs_rtbuf_get(struct xfs_rtalloc_args *args, xfs_fileoff_t block,
298 int issum);
299
300static inline int
301xfs_rtbitmap_read_buf(
302 struct xfs_rtalloc_args *args,
303 xfs_fileoff_t block)
304{
305 return xfs_rtbuf_get(args, block, 0);
306}
307
308static inline int
309xfs_rtsummary_read_buf(
310 struct xfs_rtalloc_args *args,
311 xfs_fileoff_t block)
312{
313 return xfs_rtbuf_get(args, block, 1);
314}
315
316int xfs_rtcheck_range(struct xfs_rtalloc_args *args, xfs_rtxnum_t start,
317 xfs_rtxlen_t len, int val, xfs_rtxnum_t *new, int *stat);
318int xfs_rtfind_back(struct xfs_rtalloc_args *args, xfs_rtxnum_t start,
319 xfs_rtxnum_t limit, xfs_rtxnum_t *rtblock);
320int xfs_rtfind_forw(struct xfs_rtalloc_args *args, xfs_rtxnum_t start,
321 xfs_rtxnum_t limit, xfs_rtxnum_t *rtblock);
322int xfs_rtmodify_range(struct xfs_rtalloc_args *args, xfs_rtxnum_t start,
323 xfs_rtxlen_t len, int val);
324int xfs_rtget_summary(struct xfs_rtalloc_args *args, int log,
325 xfs_fileoff_t bbno, xfs_suminfo_t *sum);
326int xfs_rtmodify_summary(struct xfs_rtalloc_args *args, int log,
327 xfs_fileoff_t bbno, int delta);
328int xfs_rtfree_range(struct xfs_rtalloc_args *args, xfs_rtxnum_t start,
329 xfs_rtxlen_t len);
330int xfs_rtalloc_query_range(struct xfs_mount *mp, struct xfs_trans *tp,
331 const struct xfs_rtalloc_rec *low_rec,
332 const struct xfs_rtalloc_rec *high_rec,
333 xfs_rtalloc_query_range_fn fn, void *priv);
334int xfs_rtalloc_query_all(struct xfs_mount *mp, struct xfs_trans *tp,
335 xfs_rtalloc_query_range_fn fn,
336 void *priv);
337int xfs_rtalloc_extent_is_free(struct xfs_mount *mp, struct xfs_trans *tp,
338 xfs_rtxnum_t start, xfs_rtxlen_t len,
339 bool *is_free);
340/*
341 * Free an extent in the realtime subvolume. Length is expressed in
342 * realtime extents, as is the block number.
343 */
344int /* error */
345xfs_rtfree_extent(
346 struct xfs_trans *tp, /* transaction pointer */
347 xfs_rtxnum_t start, /* starting rtext number to free */
348 xfs_rtxlen_t len); /* length of extent freed */
349
350/* Same as above, but in units of rt blocks. */
351int xfs_rtfree_blocks(struct xfs_trans *tp, xfs_fsblock_t rtbno,
352 xfs_filblks_t rtlen);
353
354xfs_filblks_t xfs_rtbitmap_blockcount(struct xfs_mount *mp, xfs_rtbxlen_t
355 rtextents);
356unsigned long long xfs_rtbitmap_wordcount(struct xfs_mount *mp,
357 xfs_rtbxlen_t rtextents);
358
359xfs_filblks_t xfs_rtsummary_blockcount(struct xfs_mount *mp,
360 unsigned int rsumlevels, xfs_extlen_t rbmblocks);
361unsigned long long xfs_rtsummary_wordcount(struct xfs_mount *mp,
362 unsigned int rsumlevels, xfs_extlen_t rbmblocks);
363#else /* CONFIG_XFS_RT */
364# define xfs_rtfree_extent(t,b,l) (-ENOSYS)
365# define xfs_rtfree_blocks(t,rb,rl) (-ENOSYS)
366# define xfs_rtalloc_query_range(m,t,l,h,f,p) (-ENOSYS)
367# define xfs_rtalloc_query_all(m,t,f,p) (-ENOSYS)
368# define xfs_rtbitmap_read_buf(a,b) (-ENOSYS)
369# define xfs_rtsummary_read_buf(a,b) (-ENOSYS)
370# define xfs_rtbuf_cache_relse(a) (0)
371# define xfs_rtalloc_extent_is_free(m,t,s,l,i) (-ENOSYS)
372static inline xfs_filblks_t
373xfs_rtbitmap_blockcount(struct xfs_mount *mp, xfs_rtbxlen_t rtextents)
374{
375 /* shut up gcc */
376 return 0;
377}
378# define xfs_rtbitmap_wordcount(mp, r) (0)
379# define xfs_rtsummary_blockcount(mp, l, b) (0)
380# define xfs_rtsummary_wordcount(mp, l, b) (0)
381#endif /* CONFIG_XFS_RT */
382
383#endif /* __XFS_RTBITMAP_H__ */
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
4 * All Rights Reserved.
5 */
6#ifndef __XFS_RTBITMAP_H__
7#define __XFS_RTBITMAP_H__
8
9#include "xfs_rtgroup.h"
10
11struct xfs_rtalloc_args {
12 struct xfs_rtgroup *rtg;
13 struct xfs_mount *mp;
14 struct xfs_trans *tp;
15
16 struct xfs_buf *rbmbp; /* bitmap block buffer */
17 struct xfs_buf *sumbp; /* summary block buffer */
18
19 xfs_fileoff_t rbmoff; /* bitmap block number */
20 xfs_fileoff_t sumoff; /* summary block number */
21};
22
23static inline xfs_rtblock_t
24xfs_rtx_to_rtb(
25 struct xfs_rtgroup *rtg,
26 xfs_rtxnum_t rtx)
27{
28 struct xfs_mount *mp = rtg_mount(rtg);
29 xfs_rtblock_t start = xfs_group_start_fsb(rtg_group(rtg));
30
31 if (mp->m_rtxblklog >= 0)
32 return start + (rtx << mp->m_rtxblklog);
33 return start + (rtx * mp->m_sb.sb_rextsize);
34}
35
36/* Convert an rgbno into an rt extent number. */
37static inline xfs_rtxnum_t
38xfs_rgbno_to_rtx(
39 struct xfs_mount *mp,
40 xfs_rgblock_t rgbno)
41{
42 if (likely(mp->m_rtxblklog >= 0))
43 return rgbno >> mp->m_rtxblklog;
44 return rgbno / mp->m_sb.sb_rextsize;
45}
46
47static inline uint64_t
48xfs_rtbxlen_to_blen(
49 struct xfs_mount *mp,
50 xfs_rtbxlen_t rtbxlen)
51{
52 if (mp->m_rtxblklog >= 0)
53 return rtbxlen << mp->m_rtxblklog;
54
55 return rtbxlen * mp->m_sb.sb_rextsize;
56}
57
58static inline xfs_extlen_t
59xfs_rtxlen_to_extlen(
60 struct xfs_mount *mp,
61 xfs_rtxlen_t rtxlen)
62{
63 if (mp->m_rtxblklog >= 0)
64 return rtxlen << mp->m_rtxblklog;
65
66 return rtxlen * mp->m_sb.sb_rextsize;
67}
68
69/* Compute the misalignment between an extent length and a realtime extent .*/
70static inline unsigned int
71xfs_extlen_to_rtxmod(
72 struct xfs_mount *mp,
73 xfs_extlen_t len)
74{
75 if (mp->m_rtxblklog >= 0)
76 return len & mp->m_rtxblkmask;
77
78 return len % mp->m_sb.sb_rextsize;
79}
80
81static inline xfs_rtxlen_t
82xfs_extlen_to_rtxlen(
83 struct xfs_mount *mp,
84 xfs_extlen_t len)
85{
86 if (mp->m_rtxblklog >= 0)
87 return len >> mp->m_rtxblklog;
88
89 return len / mp->m_sb.sb_rextsize;
90}
91
92/* Convert an rt block count into an rt extent count. */
93static inline xfs_rtbxlen_t
94xfs_blen_to_rtbxlen(
95 struct xfs_mount *mp,
96 uint64_t blen)
97{
98 if (likely(mp->m_rtxblklog >= 0))
99 return blen >> mp->m_rtxblklog;
100
101 return div_u64(blen, mp->m_sb.sb_rextsize);
102}
103
104/* Return the offset of a file block length within an rt extent. */
105static inline xfs_extlen_t
106xfs_blen_to_rtxoff(
107 struct xfs_mount *mp,
108 xfs_filblks_t blen)
109{
110 if (likely(mp->m_rtxblklog >= 0))
111 return blen & mp->m_rtxblkmask;
112
113 return do_div(blen, mp->m_sb.sb_rextsize);
114}
115
116/* Round this block count up to the nearest rt extent size. */
117static inline xfs_filblks_t
118xfs_blen_roundup_rtx(
119 struct xfs_mount *mp,
120 xfs_filblks_t blen)
121{
122 return roundup_64(blen, mp->m_sb.sb_rextsize);
123}
124
125/* Convert an rt block number into an rt extent number. */
126static inline xfs_rtxnum_t
127xfs_rtb_to_rtx(
128 struct xfs_mount *mp,
129 xfs_rtblock_t rtbno)
130{
131 /* open-coded 64-bit masking operation */
132 rtbno &= mp->m_groups[XG_TYPE_RTG].blkmask;
133 if (likely(mp->m_rtxblklog >= 0))
134 return rtbno >> mp->m_rtxblklog;
135 return div_u64(rtbno, mp->m_sb.sb_rextsize);
136}
137
138/* Return the offset of an rt block number within an rt extent. */
139static inline xfs_extlen_t
140xfs_rtb_to_rtxoff(
141 struct xfs_mount *mp,
142 xfs_rtblock_t rtbno)
143{
144 /* open-coded 64-bit masking operation */
145 rtbno &= mp->m_groups[XG_TYPE_RTG].blkmask;
146 if (likely(mp->m_rtxblklog >= 0))
147 return rtbno & mp->m_rtxblkmask;
148 return do_div(rtbno, mp->m_sb.sb_rextsize);
149}
150
151/* Round this file block offset up to the nearest rt extent size. */
152static inline xfs_rtblock_t
153xfs_fileoff_roundup_rtx(
154 struct xfs_mount *mp,
155 xfs_fileoff_t off)
156{
157 return roundup_64(off, mp->m_sb.sb_rextsize);
158}
159
160/* Round this file block offset down to the nearest rt extent size. */
161static inline xfs_rtblock_t
162xfs_fileoff_rounddown_rtx(
163 struct xfs_mount *mp,
164 xfs_fileoff_t off)
165{
166 return rounddown_64(off, mp->m_sb.sb_rextsize);
167}
168
169/* Convert an rt extent number to a file block offset in the rt bitmap file. */
170static inline xfs_fileoff_t
171xfs_rtx_to_rbmblock(
172 struct xfs_mount *mp,
173 xfs_rtxnum_t rtx)
174{
175 if (xfs_has_rtgroups(mp))
176 return div_u64(rtx, mp->m_rtx_per_rbmblock);
177
178 return rtx >> mp->m_blkbit_log;
179}
180
181/* Convert an rt extent number to a word offset within an rt bitmap block. */
182static inline unsigned int
183xfs_rtx_to_rbmword(
184 struct xfs_mount *mp,
185 xfs_rtxnum_t rtx)
186{
187 if (xfs_has_rtgroups(mp)) {
188 unsigned int mod;
189
190 div_u64_rem(rtx >> XFS_NBWORDLOG, mp->m_blockwsize, &mod);
191 return mod;
192 }
193
194 return (rtx >> XFS_NBWORDLOG) & (mp->m_blockwsize - 1);
195}
196
197/* Convert a file block offset in the rt bitmap file to an rt extent number. */
198static inline xfs_rtxnum_t
199xfs_rbmblock_to_rtx(
200 struct xfs_mount *mp,
201 xfs_fileoff_t rbmoff)
202{
203 if (xfs_has_rtgroups(mp))
204 return rbmoff * mp->m_rtx_per_rbmblock;
205
206 return rbmoff << mp->m_blkbit_log;
207}
208
209/* Return a pointer to a bitmap word within a rt bitmap block. */
210static inline union xfs_rtword_raw *
211xfs_rbmblock_wordptr(
212 struct xfs_rtalloc_args *args,
213 unsigned int index)
214{
215 struct xfs_mount *mp = args->mp;
216 union xfs_rtword_raw *words;
217 struct xfs_rtbuf_blkinfo *hdr = args->rbmbp->b_addr;
218
219 if (xfs_has_rtgroups(mp))
220 words = (union xfs_rtword_raw *)(hdr + 1);
221 else
222 words = args->rbmbp->b_addr;
223
224 return words + index;
225}
226
227/* Convert an ondisk bitmap word to its incore representation. */
228static inline xfs_rtword_t
229xfs_rtbitmap_getword(
230 struct xfs_rtalloc_args *args,
231 unsigned int index)
232{
233 union xfs_rtword_raw *word = xfs_rbmblock_wordptr(args, index);
234
235 if (xfs_has_rtgroups(args->mp))
236 return be32_to_cpu(word->rtg);
237 return word->old;
238}
239
240/* Set an ondisk bitmap word from an incore representation. */
241static inline void
242xfs_rtbitmap_setword(
243 struct xfs_rtalloc_args *args,
244 unsigned int index,
245 xfs_rtword_t value)
246{
247 union xfs_rtword_raw *word = xfs_rbmblock_wordptr(args, index);
248
249 if (xfs_has_rtgroups(args->mp))
250 word->rtg = cpu_to_be32(value);
251 else
252 word->old = value;
253}
254
255/*
256 * Convert a rt extent length and rt bitmap block number to a xfs_suminfo_t
257 * offset within the rt summary file.
258 */
259static inline xfs_rtsumoff_t
260xfs_rtsumoffs(
261 struct xfs_mount *mp,
262 int log2_len,
263 xfs_fileoff_t rbmoff)
264{
265 return log2_len * mp->m_sb.sb_rbmblocks + rbmoff;
266}
267
268/*
269 * Convert an xfs_suminfo_t offset to a file block offset within the rt summary
270 * file.
271 */
272static inline xfs_fileoff_t
273xfs_rtsumoffs_to_block(
274 struct xfs_mount *mp,
275 xfs_rtsumoff_t rsumoff)
276{
277 if (xfs_has_rtgroups(mp))
278 return rsumoff / mp->m_blockwsize;
279
280 return XFS_B_TO_FSBT(mp, rsumoff * sizeof(xfs_suminfo_t));
281}
282
283/*
284 * Convert an xfs_suminfo_t offset to an info word offset within an rt summary
285 * block.
286 */
287static inline unsigned int
288xfs_rtsumoffs_to_infoword(
289 struct xfs_mount *mp,
290 xfs_rtsumoff_t rsumoff)
291{
292 unsigned int mask = mp->m_blockmask >> XFS_SUMINFOLOG;
293
294 if (xfs_has_rtgroups(mp))
295 return rsumoff % mp->m_blockwsize;
296
297 return rsumoff & mask;
298}
299
300/* Return a pointer to a summary info word within a rt summary block. */
301static inline union xfs_suminfo_raw *
302xfs_rsumblock_infoptr(
303 struct xfs_rtalloc_args *args,
304 unsigned int index)
305{
306 union xfs_suminfo_raw *info;
307 struct xfs_rtbuf_blkinfo *hdr = args->sumbp->b_addr;
308
309 if (xfs_has_rtgroups(args->mp))
310 info = (union xfs_suminfo_raw *)(hdr + 1);
311 else
312 info = args->sumbp->b_addr;
313
314 return info + index;
315}
316
317/* Get the current value of a summary counter. */
318static inline xfs_suminfo_t
319xfs_suminfo_get(
320 struct xfs_rtalloc_args *args,
321 unsigned int index)
322{
323 union xfs_suminfo_raw *info = xfs_rsumblock_infoptr(args, index);
324
325 if (xfs_has_rtgroups(args->mp))
326 return be32_to_cpu(info->rtg);
327 return info->old;
328}
329
330/* Add to the current value of a summary counter and return the new value. */
331static inline xfs_suminfo_t
332xfs_suminfo_add(
333 struct xfs_rtalloc_args *args,
334 unsigned int index,
335 int delta)
336{
337 union xfs_suminfo_raw *info = xfs_rsumblock_infoptr(args, index);
338
339 if (xfs_has_rtgroups(args->mp)) {
340 be32_add_cpu(&info->rtg, delta);
341 return be32_to_cpu(info->rtg);
342 }
343
344 info->old += delta;
345 return info->old;
346}
347
348static inline const struct xfs_buf_ops *
349xfs_rtblock_ops(
350 struct xfs_mount *mp,
351 enum xfs_rtg_inodes type)
352{
353 if (xfs_has_rtgroups(mp)) {
354 if (type == XFS_RTGI_SUMMARY)
355 return &xfs_rtsummary_buf_ops;
356 return &xfs_rtbitmap_buf_ops;
357 }
358 return &xfs_rtbuf_ops;
359}
360
361/*
362 * Functions for walking free space rtextents in the realtime bitmap.
363 */
364struct xfs_rtalloc_rec {
365 xfs_rtxnum_t ar_startext;
366 xfs_rtbxlen_t ar_extcount;
367};
368
369typedef int (*xfs_rtalloc_query_range_fn)(
370 struct xfs_rtgroup *rtg,
371 struct xfs_trans *tp,
372 const struct xfs_rtalloc_rec *rec,
373 void *priv);
374
375#ifdef CONFIG_XFS_RT
376void xfs_rtbuf_cache_relse(struct xfs_rtalloc_args *args);
377int xfs_rtbitmap_read_buf(struct xfs_rtalloc_args *args, xfs_fileoff_t block);
378int xfs_rtsummary_read_buf(struct xfs_rtalloc_args *args, xfs_fileoff_t block);
379int xfs_rtcheck_range(struct xfs_rtalloc_args *args, xfs_rtxnum_t start,
380 xfs_rtxlen_t len, int val, xfs_rtxnum_t *new, int *stat);
381int xfs_rtfind_back(struct xfs_rtalloc_args *args, xfs_rtxnum_t start,
382 xfs_rtxnum_t *rtblock);
383int xfs_rtfind_forw(struct xfs_rtalloc_args *args, xfs_rtxnum_t start,
384 xfs_rtxnum_t limit, xfs_rtxnum_t *rtblock);
385int xfs_rtmodify_range(struct xfs_rtalloc_args *args, xfs_rtxnum_t start,
386 xfs_rtxlen_t len, int val);
387int xfs_rtget_summary(struct xfs_rtalloc_args *args, int log,
388 xfs_fileoff_t bbno, xfs_suminfo_t *sum);
389int xfs_rtmodify_summary(struct xfs_rtalloc_args *args, int log,
390 xfs_fileoff_t bbno, int delta);
391int xfs_rtfree_range(struct xfs_rtalloc_args *args, xfs_rtxnum_t start,
392 xfs_rtxlen_t len);
393int xfs_rtalloc_query_range(struct xfs_rtgroup *rtg, struct xfs_trans *tp,
394 xfs_rtxnum_t start, xfs_rtxnum_t end,
395 xfs_rtalloc_query_range_fn fn, void *priv);
396int xfs_rtalloc_query_all(struct xfs_rtgroup *rtg, struct xfs_trans *tp,
397 xfs_rtalloc_query_range_fn fn, void *priv);
398int xfs_rtalloc_extent_is_free(struct xfs_rtgroup *rtg, struct xfs_trans *tp,
399 xfs_rtxnum_t start, xfs_rtxlen_t len, bool *is_free);
400int xfs_rtfree_extent(struct xfs_trans *tp, struct xfs_rtgroup *rtg,
401 xfs_rtxnum_t start, xfs_rtxlen_t len);
402/* Same as above, but in units of rt blocks. */
403int xfs_rtfree_blocks(struct xfs_trans *tp, struct xfs_rtgroup *rtg,
404 xfs_fsblock_t rtbno, xfs_filblks_t rtlen);
405
406xfs_rtxnum_t xfs_rtbitmap_rtx_per_rbmblock(struct xfs_mount *mp);
407xfs_filblks_t xfs_rtbitmap_blockcount(struct xfs_mount *mp);
408xfs_filblks_t xfs_rtbitmap_blockcount_len(struct xfs_mount *mp,
409 xfs_rtbxlen_t rtextents);
410xfs_filblks_t xfs_rtsummary_blockcount(struct xfs_mount *mp,
411 unsigned int *rsumlevels);
412
413int xfs_rtfile_initialize_blocks(struct xfs_rtgroup *rtg,
414 enum xfs_rtg_inodes type, xfs_fileoff_t offset_fsb,
415 xfs_fileoff_t end_fsb, void *data);
416int xfs_rtbitmap_create(struct xfs_rtgroup *rtg, struct xfs_inode *ip,
417 struct xfs_trans *tp, bool init);
418int xfs_rtsummary_create(struct xfs_rtgroup *rtg, struct xfs_inode *ip,
419 struct xfs_trans *tp, bool init);
420
421#else /* CONFIG_XFS_RT */
422# define xfs_rtfree_extent(t,b,l) (-ENOSYS)
423
424static inline int xfs_rtfree_blocks(struct xfs_trans *tp,
425 struct xfs_rtgroup *rtg, xfs_fsblock_t rtbno,
426 xfs_filblks_t rtlen)
427{
428 return -ENOSYS;
429}
430# define xfs_rtalloc_query_range(m,t,l,h,f,p) (-ENOSYS)
431# define xfs_rtalloc_query_all(m,t,f,p) (-ENOSYS)
432# define xfs_rtbitmap_read_buf(a,b) (-ENOSYS)
433# define xfs_rtsummary_read_buf(a,b) (-ENOSYS)
434# define xfs_rtbuf_cache_relse(a) (0)
435# define xfs_rtalloc_extent_is_free(m,t,s,l,i) (-ENOSYS)
436static inline xfs_filblks_t
437xfs_rtbitmap_blockcount_len(struct xfs_mount *mp, xfs_rtbxlen_t rtextents)
438{
439 /* shut up gcc */
440 return 0;
441}
442#endif /* CONFIG_XFS_RT */
443
444#endif /* __XFS_RTBITMAP_H__ */