Commit | Line | Data |
---|---|---|
0b61f8a4 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 | 2 | /* |
7b718769 NS |
3 | * Copyright (c) 2000-2005 Silicon Graphics, Inc. |
4 | * All Rights Reserved. | |
1da177e4 | 5 | */ |
1da177e4 | 6 | #include "xfs.h" |
a844f451 | 7 | #include "xfs_fs.h" |
70a9883c | 8 | #include "xfs_shared.h" |
239880ef DC |
9 | #include "xfs_format.h" |
10 | #include "xfs_log_format.h" | |
11 | #include "xfs_trans_resv.h" | |
a844f451 | 12 | #include "xfs_bit.h" |
1da177e4 | 13 | #include "xfs_mount.h" |
1da177e4 | 14 | #include "xfs_inode.h" |
1da177e4 | 15 | #include "xfs_bmap.h" |
a4fbe6ab | 16 | #include "xfs_bmap_btree.h" |
152e2123 | 17 | #include "xfs_bmap_util.h" |
239880ef | 18 | #include "xfs_trans.h" |
1da177e4 | 19 | #include "xfs_trans_space.h" |
33479e05 | 20 | #include "xfs_icache.h" |
c963c619 | 21 | #include "xfs_rtalloc.h" |
7249c95a | 22 | #include "xfs_sb.h" |
13928113 | 23 | #include "xfs_rtbitmap.h" |
152e2123 | 24 | #include "xfs_quota.h" |
1da177e4 | 25 | |
1da177e4 | 26 | /* |
c963c619 DC |
27 | * Return whether there are any free extents in the size range given |
28 | * by low and high, for the bitmap block bbno. | |
1da177e4 | 29 | */ |
41f33d82 | 30 | STATIC int |
c963c619 | 31 | xfs_rtany_summary( |
41f33d82 DC |
32 | struct xfs_rtalloc_args *args, |
33 | int low, /* low log2 extent size */ | |
34 | int high, /* high log2 extent size */ | |
35 | xfs_fileoff_t bbno, /* bitmap block number */ | |
1b5d6396 | 36 | int *maxlog) /* out: max log2 extent size free */ |
1da177e4 | 37 | { |
41f33d82 DC |
38 | struct xfs_mount *mp = args->mp; |
39 | int error; | |
40 | int log; /* loop counter, log2 of ext. size */ | |
41 | xfs_suminfo_t sum; /* summary data */ | |
1da177e4 | 42 | |
e23aaf45 OS |
43 | /* There are no extents at levels >= m_rsum_cache[bbno]. */ |
44 | if (mp->m_rsum_cache) { | |
45 | high = min(high, mp->m_rsum_cache[bbno] - 1); | |
46 | if (low > high) { | |
1b5d6396 | 47 | *maxlog = -1; |
e23aaf45 OS |
48 | return 0; |
49 | } | |
50 | } | |
355e3532 | 51 | |
1da177e4 | 52 | /* |
355e3532 | 53 | * Loop over logs of extent sizes. |
1da177e4 | 54 | */ |
e23aaf45 | 55 | for (log = high; log >= low; log--) { |
1da177e4 | 56 | /* |
c963c619 | 57 | * Get one summary datum. |
1da177e4 | 58 | */ |
e94b53ff | 59 | error = xfs_rtget_summary(args, log, bbno, &sum); |
1da177e4 LT |
60 | if (error) { |
61 | return error; | |
62 | } | |
1da177e4 | 63 | /* |
c963c619 | 64 | * If there are any, return success. |
1da177e4 | 65 | */ |
c963c619 | 66 | if (sum) { |
1b5d6396 | 67 | *maxlog = log; |
355e3532 | 68 | goto out; |
1da177e4 | 69 | } |
1da177e4 LT |
70 | } |
71 | /* | |
c963c619 | 72 | * Found nothing, return failure. |
1da177e4 | 73 | */ |
1b5d6396 | 74 | *maxlog = -1; |
355e3532 | 75 | out: |
e23aaf45 OS |
76 | /* There were no extents at levels > log. */ |
77 | if (mp->m_rsum_cache && log + 1 < mp->m_rsum_cache[bbno]) | |
78 | mp->m_rsum_cache[bbno] = log + 1; | |
c963c619 DC |
79 | return 0; |
80 | } | |
1da177e4 | 81 | |
c963c619 DC |
82 | |
83 | /* | |
84 | * Copy and transform the summary file, given the old and new | |
85 | * parameters in the mount structures. | |
86 | */ | |
41f33d82 | 87 | STATIC int |
c963c619 | 88 | xfs_rtcopy_summary( |
41f33d82 DC |
89 | struct xfs_rtalloc_args *oargs, |
90 | struct xfs_rtalloc_args *nargs) | |
c963c619 | 91 | { |
41f33d82 | 92 | xfs_fileoff_t bbno; /* bitmap block number */ |
41f33d82 DC |
93 | int error; |
94 | int log; /* summary level number (log length) */ | |
95 | xfs_suminfo_t sum; /* summary data */ | |
c963c619 | 96 | |
41f33d82 DC |
97 | for (log = oargs->mp->m_rsumlevels - 1; log >= 0; log--) { |
98 | for (bbno = oargs->mp->m_sb.sb_rbmblocks - 1; | |
c963c619 DC |
99 | (xfs_srtblock_t)bbno >= 0; |
100 | bbno--) { | |
e94b53ff | 101 | error = xfs_rtget_summary(oargs, log, bbno, &sum); |
c963c619 | 102 | if (error) |
e94b53ff | 103 | goto out; |
c963c619 DC |
104 | if (sum == 0) |
105 | continue; | |
e94b53ff | 106 | error = xfs_rtmodify_summary(oargs, log, bbno, -sum); |
c963c619 | 107 | if (error) |
e94b53ff OS |
108 | goto out; |
109 | error = xfs_rtmodify_summary(nargs, log, bbno, sum); | |
c963c619 | 110 | if (error) |
e94b53ff | 111 | goto out; |
c963c619 DC |
112 | ASSERT(sum > 0); |
113 | } | |
114 | } | |
e94b53ff OS |
115 | error = 0; |
116 | out: | |
117 | xfs_rtbuf_cache_relse(oargs); | |
c963c619 DC |
118 | return 0; |
119 | } | |
120 | /* | |
121 | * Mark an extent specified by start and len allocated. | |
122 | * Updates all the summary information as well as the bitmap. | |
123 | */ | |
41f33d82 | 124 | STATIC int |
c963c619 | 125 | xfs_rtallocate_range( |
41f33d82 DC |
126 | struct xfs_rtalloc_args *args, |
127 | xfs_rtxnum_t start, /* start rtext to allocate */ | |
e94b53ff | 128 | xfs_rtxlen_t len) /* in/out: summary block number */ |
c963c619 | 129 | { |
41f33d82 DC |
130 | struct xfs_mount *mp = args->mp; |
131 | xfs_rtxnum_t end; /* end of the allocated rtext */ | |
132 | int error; | |
133 | xfs_rtxnum_t postblock = 0; /* first rtext allocated > end */ | |
134 | xfs_rtxnum_t preblock = 0; /* first rtext allocated < start */ | |
c963c619 DC |
135 | |
136 | end = start + len - 1; | |
137 | /* | |
138 | * Assume we're allocating out of the middle of a free extent. | |
139 | * We need to find the beginning and end of the extent so we can | |
140 | * properly update the summary. | |
141 | */ | |
41f33d82 | 142 | error = xfs_rtfind_back(args, start, 0, &preblock); |
ce42b5d3 | 143 | if (error) |
c963c619 | 144 | return error; |
ce42b5d3 | 145 | |
c963c619 DC |
146 | /* |
147 | * Find the next allocated block (end of free extent). | |
148 | */ | |
41f33d82 | 149 | error = xfs_rtfind_forw(args, end, mp->m_sb.sb_rextents - 1, |
e94b53ff | 150 | &postblock); |
ce42b5d3 | 151 | if (error) |
c963c619 | 152 | return error; |
ce42b5d3 | 153 | |
c963c619 DC |
154 | /* |
155 | * Decrement the summary information corresponding to the entire | |
156 | * (old) free extent. | |
157 | */ | |
41f33d82 | 158 | error = xfs_rtmodify_summary(args, |
3abfe6c2 | 159 | xfs_highbit64(postblock + 1 - preblock), |
e94b53ff | 160 | xfs_rtx_to_rbmblock(mp, preblock), -1); |
ce42b5d3 | 161 | if (error) |
c963c619 | 162 | return error; |
ce42b5d3 | 163 | |
c963c619 DC |
164 | /* |
165 | * If there are blocks not being allocated at the front of the | |
166 | * old extent, add summary data for them to be free. | |
167 | */ | |
168 | if (preblock < start) { | |
41f33d82 | 169 | error = xfs_rtmodify_summary(args, |
3abfe6c2 | 170 | xfs_highbit64(start - preblock), |
e94b53ff | 171 | xfs_rtx_to_rbmblock(mp, preblock), 1); |
ce42b5d3 | 172 | if (error) |
c963c619 | 173 | return error; |
c963c619 | 174 | } |
ce42b5d3 | 175 | |
c963c619 DC |
176 | /* |
177 | * If there are blocks not being allocated at the end of the | |
178 | * old extent, add summary data for them to be free. | |
179 | */ | |
180 | if (postblock > end) { | |
41f33d82 | 181 | error = xfs_rtmodify_summary(args, |
3abfe6c2 | 182 | xfs_highbit64(postblock - end), |
e94b53ff | 183 | xfs_rtx_to_rbmblock(mp, end + 1), 1); |
ce42b5d3 | 184 | if (error) |
c963c619 | 185 | return error; |
c963c619 | 186 | } |
ce42b5d3 | 187 | |
c963c619 DC |
188 | /* |
189 | * Modify the bitmap to mark this extent allocated. | |
190 | */ | |
ce42b5d3 | 191 | return xfs_rtmodify_range(args, start, len, 0); |
c963c619 DC |
192 | } |
193 | ||
f6a2dae2 DW |
194 | /* |
195 | * Make sure we don't run off the end of the rt volume. Be careful that | |
196 | * adjusting maxlen downwards doesn't cause us to fail the alignment checks. | |
197 | */ | |
a684c538 | 198 | static inline xfs_rtxlen_t |
f6a2dae2 DW |
199 | xfs_rtallocate_clamp_len( |
200 | struct xfs_mount *mp, | |
2d5f216b | 201 | xfs_rtxnum_t startrtx, |
a684c538 DW |
202 | xfs_rtxlen_t rtxlen, |
203 | xfs_rtxlen_t prod) | |
f6a2dae2 | 204 | { |
a684c538 | 205 | xfs_rtxlen_t ret; |
f6a2dae2 DW |
206 | |
207 | ret = min(mp->m_sb.sb_rextents, startrtx + rtxlen) - startrtx; | |
208 | return rounddown(ret, prod); | |
209 | } | |
210 | ||
c963c619 DC |
211 | /* |
212 | * Attempt to allocate an extent minlen<=len<=maxlen starting from | |
213 | * bitmap block bbno. If we don't get maxlen then use prod to trim | |
2d5f216b | 214 | * the length, if given. Returns error; returns starting block in *rtx. |
c963c619 DC |
215 | * The lengths are all in rtextents. |
216 | */ | |
41f33d82 | 217 | STATIC int |
c963c619 | 218 | xfs_rtallocate_extent_block( |
41f33d82 DC |
219 | struct xfs_rtalloc_args *args, |
220 | xfs_fileoff_t bbno, /* bitmap block number */ | |
221 | xfs_rtxlen_t minlen, /* minimum length to allocate */ | |
222 | xfs_rtxlen_t maxlen, /* maximum length to allocate */ | |
223 | xfs_rtxlen_t *len, /* out: actual length allocated */ | |
224 | xfs_rtxnum_t *nextp, /* out: next rtext to try */ | |
41f33d82 DC |
225 | xfs_rtxlen_t prod, /* extent product factor */ |
226 | xfs_rtxnum_t *rtx) /* out: start rtext allocated */ | |
c963c619 | 227 | { |
41f33d82 DC |
228 | struct xfs_mount *mp = args->mp; |
229 | xfs_rtxnum_t besti; /* best rtext found so far */ | |
230 | xfs_rtxnum_t bestlen;/* best length found so far */ | |
231 | xfs_rtxnum_t end; /* last rtext in chunk */ | |
232 | int error; | |
233 | xfs_rtxnum_t i; /* current rtext trying */ | |
234 | xfs_rtxnum_t next; /* next rtext to try */ | |
235 | int stat; /* status from internal calls */ | |
c963c619 DC |
236 | |
237 | /* | |
238 | * Loop over all the extents starting in this bitmap block, | |
239 | * looking for one that's long enough. | |
240 | */ | |
90d98a6a DW |
241 | for (i = xfs_rbmblock_to_rtx(mp, bbno), besti = -1, bestlen = 0, |
242 | end = xfs_rbmblock_to_rtx(mp, bbno + 1) - 1; | |
c963c619 DC |
243 | i <= end; |
244 | i++) { | |
2a6ca4ba | 245 | /* Make sure we don't scan off the end of the rt volume. */ |
f6a2dae2 | 246 | maxlen = xfs_rtallocate_clamp_len(mp, i, maxlen, prod); |
2a6ca4ba | 247 | |
c963c619 DC |
248 | /* |
249 | * See if there's a free extent of maxlen starting at i. | |
250 | * If it's not so then next will contain the first non-free. | |
251 | */ | |
41f33d82 | 252 | error = xfs_rtcheck_range(args, i, maxlen, 1, &next, &stat); |
ce42b5d3 | 253 | if (error) |
c963c619 | 254 | return error; |
c963c619 DC |
255 | if (stat) { |
256 | /* | |
257 | * i for maxlen is all free, allocate and return that. | |
258 | */ | |
d9498fa8 CH |
259 | bestlen = maxlen; |
260 | besti = i; | |
261 | goto allocate; | |
c963c619 | 262 | } |
d9498fa8 | 263 | |
c963c619 DC |
264 | /* |
265 | * In the case where we have a variable-sized allocation | |
266 | * request, figure out how big this free piece is, | |
267 | * and if it's big enough for the minimum, and the best | |
268 | * so far, remember it. | |
269 | */ | |
270 | if (minlen < maxlen) { | |
2d5f216b | 271 | xfs_rtxnum_t thislen; /* this extent size */ |
c963c619 DC |
272 | |
273 | thislen = next - i; | |
274 | if (thislen >= minlen && thislen > bestlen) { | |
275 | besti = i; | |
276 | bestlen = thislen; | |
277 | } | |
278 | } | |
279 | /* | |
280 | * If not done yet, find the start of the next free space. | |
281 | */ | |
f3e509dd | 282 | if (next >= end) |
c963c619 | 283 | break; |
f3e509dd CH |
284 | error = xfs_rtfind_forw(args, next, end, &i); |
285 | if (error) | |
286 | return error; | |
c963c619 | 287 | } |
9ade45b0 | 288 | |
c963c619 DC |
289 | /* |
290 | * Searched the whole thing & didn't find a maxlen free extent. | |
291 | */ | |
9ade45b0 | 292 | if (minlen > maxlen || besti == -1) { |
c963c619 | 293 | /* |
9ade45b0 | 294 | * Allocation failed. Set *nextp to the next block to try. |
c963c619 | 295 | */ |
9ade45b0 CH |
296 | *nextp = next; |
297 | return -ENOSPC; | |
298 | } | |
0703a8e1 | 299 | |
9ade45b0 CH |
300 | /* |
301 | * If size should be a multiple of prod, make that so. | |
302 | */ | |
303 | if (prod > 1) { | |
304 | xfs_rtxlen_t p; /* amount to trim length by */ | |
305 | ||
306 | div_u64_rem(bestlen, prod, &p); | |
307 | if (p) | |
308 | bestlen -= p; | |
1da177e4 | 309 | } |
9ade45b0 | 310 | |
1da177e4 | 311 | /* |
9ade45b0 | 312 | * Allocate besti for bestlen & return that. |
1da177e4 | 313 | */ |
d9498fa8 | 314 | allocate: |
9ade45b0 CH |
315 | error = xfs_rtallocate_range(args, besti, bestlen); |
316 | if (error) | |
317 | return error; | |
318 | *len = bestlen; | |
319 | *rtx = besti; | |
320 | return 0; | |
1da177e4 LT |
321 | } |
322 | ||
323 | /* | |
324 | * Allocate an extent of length minlen<=len<=maxlen, starting at block | |
325 | * bno. If we don't get maxlen then use prod to trim the length, if given. | |
2d5f216b | 326 | * Returns error; returns starting block in *rtx. |
1da177e4 LT |
327 | * The lengths are all in rtextents. |
328 | */ | |
41f33d82 | 329 | STATIC int |
1da177e4 | 330 | xfs_rtallocate_extent_exact( |
41f33d82 DC |
331 | struct xfs_rtalloc_args *args, |
332 | xfs_rtxnum_t start, /* starting rtext number to allocate */ | |
333 | xfs_rtxlen_t minlen, /* minimum length to allocate */ | |
334 | xfs_rtxlen_t maxlen, /* maximum length to allocate */ | |
335 | xfs_rtxlen_t *len, /* out: actual length allocated */ | |
41f33d82 DC |
336 | xfs_rtxlen_t prod, /* extent product factor */ |
337 | xfs_rtxnum_t *rtx) /* out: start rtext allocated */ | |
1da177e4 | 338 | { |
41f33d82 DC |
339 | int error; |
340 | xfs_rtxlen_t i; /* extent length trimmed due to prod */ | |
341 | int isfree; /* extent is free */ | |
342 | xfs_rtxnum_t next; /* next rtext to try (dummy) */ | |
1da177e4 | 343 | |
f6a2dae2 DW |
344 | ASSERT(minlen % prod == 0); |
345 | ASSERT(maxlen % prod == 0); | |
1da177e4 LT |
346 | /* |
347 | * Check if the range in question (for maxlen) is free. | |
348 | */ | |
41f33d82 | 349 | error = xfs_rtcheck_range(args, start, maxlen, 1, &next, &isfree); |
ce42b5d3 | 350 | if (error) |
1da177e4 | 351 | return error; |
ce42b5d3 | 352 | |
3c97c9f7 | 353 | if (!isfree) { |
1da177e4 | 354 | /* |
3c97c9f7 | 355 | * If not, allocate what there is, if it's at least minlen. |
1da177e4 | 356 | */ |
3c97c9f7 | 357 | maxlen = next - start; |
ce42b5d3 CH |
358 | if (maxlen < minlen) |
359 | return -ENOSPC; | |
3c97c9f7 CH |
360 | |
361 | /* | |
362 | * Trim off tail of extent, if prod is specified. | |
363 | */ | |
364 | if (prod > 1 && (i = maxlen % prod)) { | |
365 | maxlen -= i; | |
366 | if (maxlen < minlen) | |
367 | return -ENOSPC; | |
368 | } | |
1da177e4 | 369 | } |
3c97c9f7 | 370 | |
1da177e4 LT |
371 | /* |
372 | * Allocate what we can and return it. | |
373 | */ | |
e94b53ff | 374 | error = xfs_rtallocate_range(args, start, maxlen); |
ce42b5d3 | 375 | if (error) |
1da177e4 | 376 | return error; |
1da177e4 | 377 | *len = maxlen; |
2d5f216b | 378 | *rtx = start; |
1da177e4 LT |
379 | return 0; |
380 | } | |
381 | ||
382 | /* | |
383 | * Allocate an extent of length minlen<=len<=maxlen, starting as near | |
2d5f216b | 384 | * to start as possible. If we don't get maxlen then use prod to trim |
1da177e4 LT |
385 | * the length, if given. The lengths are all in rtextents. |
386 | */ | |
41f33d82 | 387 | STATIC int |
1da177e4 | 388 | xfs_rtallocate_extent_near( |
41f33d82 DC |
389 | struct xfs_rtalloc_args *args, |
390 | xfs_rtxnum_t start, /* starting rtext number to allocate */ | |
391 | xfs_rtxlen_t minlen, /* minimum length to allocate */ | |
392 | xfs_rtxlen_t maxlen, /* maximum length to allocate */ | |
393 | xfs_rtxlen_t *len, /* out: actual length allocated */ | |
41f33d82 DC |
394 | xfs_rtxlen_t prod, /* extent product factor */ |
395 | xfs_rtxnum_t *rtx) /* out: start rtext allocated */ | |
1da177e4 | 396 | { |
41f33d82 | 397 | struct xfs_mount *mp = args->mp; |
1b5d6396 | 398 | int maxlog; /* max useful extent from summary */ |
41f33d82 DC |
399 | xfs_fileoff_t bbno; /* bitmap block number */ |
400 | int error; | |
401 | int i; /* bitmap block offset (loop control) */ | |
402 | int j; /* secondary loop control */ | |
403 | int log2len; /* log2 of minlen */ | |
404 | xfs_rtxnum_t n; /* next rtext to try */ | |
1da177e4 | 405 | |
f6a2dae2 DW |
406 | ASSERT(minlen % prod == 0); |
407 | ASSERT(maxlen % prod == 0); | |
408 | ||
1da177e4 LT |
409 | /* |
410 | * If the block number given is off the end, silently set it to | |
411 | * the last block. | |
412 | */ | |
2d5f216b DW |
413 | if (start >= mp->m_sb.sb_rextents) |
414 | start = mp->m_sb.sb_rextents - 1; | |
2a6ca4ba DW |
415 | |
416 | /* Make sure we don't run off the end of the rt volume. */ | |
2d5f216b | 417 | maxlen = xfs_rtallocate_clamp_len(mp, start, maxlen, prod); |
ce42b5d3 CH |
418 | if (maxlen < minlen) |
419 | return -ENOSPC; | |
2a6ca4ba | 420 | |
1da177e4 LT |
421 | /* |
422 | * Try the exact allocation first. | |
423 | */ | |
41f33d82 | 424 | error = xfs_rtallocate_extent_exact(args, start, minlen, maxlen, len, |
ce42b5d3 CH |
425 | prod, rtx); |
426 | if (error != -ENOSPC) | |
1da177e4 | 427 | return error; |
ce42b5d3 CH |
428 | |
429 | ||
90d98a6a | 430 | bbno = xfs_rtx_to_rbmblock(mp, start); |
1da177e4 | 431 | i = 0; |
85fa2c77 | 432 | j = -1; |
79071eb0 | 433 | ASSERT(minlen != 0); |
1da177e4 LT |
434 | log2len = xfs_highbit32(minlen); |
435 | /* | |
436 | * Loop over all bitmap blocks (bbno + i is current block). | |
437 | */ | |
438 | for (;;) { | |
439 | /* | |
440 | * Get summary information of extents of all useful levels | |
441 | * starting in this bitmap block. | |
442 | */ | |
41f33d82 | 443 | error = xfs_rtany_summary(args, log2len, mp->m_rsumlevels - 1, |
1b5d6396 | 444 | bbno + i, &maxlog); |
ce42b5d3 | 445 | if (error) |
1da177e4 | 446 | return error; |
ce42b5d3 | 447 | |
1da177e4 LT |
448 | /* |
449 | * If there are any useful extents starting here, try | |
450 | * allocating one. | |
451 | */ | |
1b5d6396 | 452 | if (maxlog >= 0) { |
ec5857bf OS |
453 | xfs_extlen_t maxavail = |
454 | min_t(xfs_rtblock_t, maxlen, | |
455 | (1ULL << (maxlog + 1)) - 1); | |
1da177e4 LT |
456 | /* |
457 | * On the positive side of the starting location. | |
458 | */ | |
459 | if (i >= 0) { | |
460 | /* | |
461 | * Try to allocate an extent starting in | |
462 | * this block. | |
463 | */ | |
41f33d82 | 464 | error = xfs_rtallocate_extent_block(args, |
ec5857bf | 465 | bbno + i, minlen, maxavail, len, |
ce42b5d3 CH |
466 | &n, prod, rtx); |
467 | if (error != -ENOSPC) | |
1da177e4 | 468 | return error; |
1da177e4 LT |
469 | } |
470 | /* | |
471 | * On the negative side of the starting location. | |
472 | */ | |
473 | else { /* i < 0 */ | |
e0f7422f OS |
474 | int maxblocks; |
475 | ||
1da177e4 | 476 | /* |
e0f7422f OS |
477 | * Loop backwards to find the end of the extent |
478 | * we found in the realtime summary. | |
479 | * | |
480 | * maxblocks is the maximum possible number of | |
481 | * bitmap blocks from the start of the extent | |
482 | * to the end of the extent. | |
1da177e4 | 483 | */ |
e0f7422f OS |
484 | if (maxlog == 0) |
485 | maxblocks = 0; | |
486 | else if (maxlog < mp->m_blkbit_log) | |
487 | maxblocks = 1; | |
488 | else | |
489 | maxblocks = 2 << (maxlog - mp->m_blkbit_log); | |
490 | ||
1da177e4 | 491 | /* |
e0f7422f OS |
492 | * We need to check bbno + i + maxblocks down to |
493 | * bbno + i. We already checked bbno down to | |
494 | * bbno + j + 1, so we don't need to check those | |
495 | * again. | |
1da177e4 | 496 | */ |
e0f7422f | 497 | j = min(i + maxblocks, j); |
85fa2c77 | 498 | for (; j >= i; j--) { |
41f33d82 | 499 | error = xfs_rtallocate_extent_block(args, |
e94b53ff | 500 | bbno + j, minlen, |
ec5857bf | 501 | maxavail, len, &n, prod, |
ce42b5d3 CH |
502 | rtx); |
503 | if (error != -ENOSPC) | |
1da177e4 | 504 | return error; |
1da177e4 | 505 | } |
1da177e4 LT |
506 | } |
507 | } | |
508 | /* | |
509 | * Loop control. If we were on the positive side, and there's | |
510 | * still more blocks on the negative side, go there. | |
511 | */ | |
512 | if (i > 0 && (int)bbno - i >= 0) | |
513 | i = -i; | |
514 | /* | |
515 | * If positive, and no more negative, but there are more | |
516 | * positive, go there. | |
517 | */ | |
518 | else if (i > 0 && (int)bbno + i < mp->m_sb.sb_rbmblocks - 1) | |
519 | i++; | |
520 | /* | |
521 | * If negative or 0 (just started), and there are positive | |
522 | * blocks to go, go there. The 0 case moves to block 1. | |
523 | */ | |
524 | else if (i <= 0 && (int)bbno - i < mp->m_sb.sb_rbmblocks - 1) | |
525 | i = 1 - i; | |
526 | /* | |
527 | * If negative or 0 and there are more negative blocks, | |
528 | * go there. | |
529 | */ | |
530 | else if (i <= 0 && (int)bbno + i > 0) | |
531 | i--; | |
532 | /* | |
533 | * Must be done. Return failure. | |
534 | */ | |
535 | else | |
536 | break; | |
537 | } | |
ce42b5d3 | 538 | return -ENOSPC; |
1da177e4 LT |
539 | } |
540 | ||
8ceee72f CH |
541 | static int |
542 | xfs_rtalloc_sumlevel( | |
543 | struct xfs_rtalloc_args *args, | |
544 | int l, /* level number */ | |
545 | xfs_rtxlen_t minlen, /* minimum length to allocate */ | |
546 | xfs_rtxlen_t maxlen, /* maximum length to allocate */ | |
547 | xfs_rtxlen_t prod, /* extent product factor */ | |
548 | xfs_rtxlen_t *len, /* out: actual length allocated */ | |
549 | xfs_rtxnum_t *rtx) /* out: start rtext allocated */ | |
550 | { | |
551 | xfs_fileoff_t i; /* bitmap block number */ | |
552 | ||
553 | for (i = 0; i < args->mp->m_sb.sb_rbmblocks; i++) { | |
554 | xfs_suminfo_t sum; /* summary information for extents */ | |
555 | xfs_rtxnum_t n; /* next rtext to be tried */ | |
556 | int error; | |
557 | ||
558 | error = xfs_rtget_summary(args, l, i, &sum); | |
559 | if (error) | |
560 | return error; | |
561 | ||
562 | /* | |
563 | * Nothing there, on to the next block. | |
564 | */ | |
565 | if (!sum) | |
566 | continue; | |
567 | ||
568 | /* | |
569 | * Try allocating the extent. | |
570 | */ | |
571 | error = xfs_rtallocate_extent_block(args, i, minlen, maxlen, | |
572 | len, &n, prod, rtx); | |
573 | if (error != -ENOSPC) | |
574 | return error; | |
575 | ||
576 | /* | |
577 | * If the "next block to try" returned from the allocator is | |
578 | * beyond the next bitmap block, skip to that bitmap block. | |
579 | */ | |
580 | if (xfs_rtx_to_rbmblock(args->mp, n) > i + 1) | |
581 | i = xfs_rtx_to_rbmblock(args->mp, n) - 1; | |
582 | } | |
583 | ||
584 | return -ENOSPC; | |
585 | } | |
586 | ||
1da177e4 LT |
587 | /* |
588 | * Allocate an extent of length minlen<=len<=maxlen, with no position | |
589 | * specified. If we don't get maxlen then use prod to trim | |
590 | * the length, if given. The lengths are all in rtextents. | |
591 | */ | |
41f33d82 | 592 | STATIC int |
1da177e4 | 593 | xfs_rtallocate_extent_size( |
41f33d82 DC |
594 | struct xfs_rtalloc_args *args, |
595 | xfs_rtxlen_t minlen, /* minimum length to allocate */ | |
596 | xfs_rtxlen_t maxlen, /* maximum length to allocate */ | |
597 | xfs_rtxlen_t *len, /* out: actual length allocated */ | |
41f33d82 DC |
598 | xfs_rtxlen_t prod, /* extent product factor */ |
599 | xfs_rtxnum_t *rtx) /* out: start rtext allocated */ | |
1da177e4 | 600 | { |
41f33d82 | 601 | int error; |
41f33d82 | 602 | int l; /* level number (loop control) */ |
1da177e4 | 603 | |
f6a2dae2 DW |
604 | ASSERT(minlen % prod == 0); |
605 | ASSERT(maxlen % prod == 0); | |
79071eb0 DC |
606 | ASSERT(maxlen != 0); |
607 | ||
1da177e4 LT |
608 | /* |
609 | * Loop over all the levels starting with maxlen. | |
8ceee72f CH |
610 | * |
611 | * At each level, look at all the bitmap blocks, to see if there are | |
612 | * extents starting there that are long enough (>= maxlen). | |
613 | * | |
614 | * Note, only on the initial level can the allocation fail if the | |
615 | * summary says there's an extent. | |
1da177e4 | 616 | */ |
8ceee72f CH |
617 | for (l = xfs_highbit32(maxlen); l < args->mp->m_rsumlevels; l++) { |
618 | error = xfs_rtalloc_sumlevel(args, l, minlen, maxlen, prod, len, | |
619 | rtx); | |
620 | if (error != -ENOSPC) | |
621 | return error; | |
1da177e4 | 622 | } |
8ceee72f | 623 | |
1da177e4 | 624 | /* |
8ceee72f CH |
625 | * Didn't find any maxlen blocks. Try smaller ones, unless we are |
626 | * looking for a fixed size extent. | |
1da177e4 | 627 | */ |
ce42b5d3 CH |
628 | if (minlen > --maxlen) |
629 | return -ENOSPC; | |
c963c619 DC |
630 | ASSERT(minlen != 0); |
631 | ASSERT(maxlen != 0); | |
632 | ||
1da177e4 | 633 | /* |
c963c619 | 634 | * Loop over sizes, from maxlen down to minlen. |
8ceee72f CH |
635 | * |
636 | * This time, when we do the allocations, allow smaller ones to succeed, | |
637 | * but make sure the specified minlen/maxlen are in the possible range | |
638 | * for this summary level. | |
1da177e4 | 639 | */ |
c963c619 | 640 | for (l = xfs_highbit32(maxlen); l >= xfs_highbit32(minlen); l--) { |
a39f5ccc CH |
641 | error = xfs_rtalloc_sumlevel(args, l, |
642 | max_t(xfs_rtxlen_t, minlen, 1 << l), | |
643 | min_t(xfs_rtxlen_t, maxlen, (1 << (l + 1)) - 1), | |
644 | prod, len, rtx); | |
8ceee72f CH |
645 | if (error != -ENOSPC) |
646 | return error; | |
1da177e4 | 647 | } |
8ceee72f | 648 | |
ce42b5d3 | 649 | return -ENOSPC; |
1da177e4 LT |
650 | } |
651 | ||
652 | /* | |
c963c619 | 653 | * Allocate space to the bitmap or summary file, and zero it, for growfs. |
1da177e4 | 654 | */ |
d4a97a04 | 655 | STATIC int |
c963c619 | 656 | xfs_growfs_rt_alloc( |
d4a97a04 BF |
657 | struct xfs_mount *mp, /* file system mount point */ |
658 | xfs_extlen_t oblocks, /* old count of blocks */ | |
659 | xfs_extlen_t nblocks, /* new count of blocks */ | |
660 | struct xfs_inode *ip) /* inode (bitmap/summary) */ | |
1da177e4 | 661 | { |
d4a97a04 BF |
662 | xfs_fileoff_t bno; /* block number in file */ |
663 | struct xfs_buf *bp; /* temporary buffer for zeroing */ | |
d4a97a04 BF |
664 | xfs_daddr_t d; /* disk block address */ |
665 | int error; /* error return value */ | |
d4a97a04 BF |
666 | xfs_fsblock_t fsbno; /* filesystem block for bno */ |
667 | struct xfs_bmbt_irec map; /* block map output */ | |
668 | int nmap; /* number of block maps */ | |
669 | int resblks; /* space reservation */ | |
72cc9513 | 670 | enum xfs_blft buf_type; |
d4a97a04 | 671 | struct xfs_trans *tp; |
1da177e4 | 672 | |
72cc9513 CB |
673 | if (ip == mp->m_rsumip) |
674 | buf_type = XFS_BLFT_RTSUMMARY_BUF; | |
675 | else | |
676 | buf_type = XFS_BLFT_RTBITMAP_BUF; | |
677 | ||
1da177e4 | 678 | /* |
c963c619 | 679 | * Allocate space to the file, as necessary. |
1da177e4 | 680 | */ |
c963c619 | 681 | while (oblocks < nblocks) { |
c963c619 | 682 | resblks = XFS_GROWFSRT_SPACE_RES(mp, nblocks - oblocks); |
1da177e4 | 683 | /* |
c963c619 | 684 | * Reserve space & log for one extent added to the file. |
1da177e4 | 685 | */ |
253f4911 CH |
686 | error = xfs_trans_alloc(mp, &M_RES(mp)->tr_growrtalloc, resblks, |
687 | 0, 0, &tp); | |
c963c619 | 688 | if (error) |
253f4911 | 689 | return error; |
1da177e4 | 690 | /* |
c963c619 | 691 | * Lock the inode. |
1da177e4 | 692 | */ |
c963c619 DC |
693 | xfs_ilock(ip, XFS_ILOCK_EXCL); |
694 | xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL); | |
695 | ||
727e1acd CB |
696 | error = xfs_iext_count_may_overflow(ip, XFS_DATA_FORK, |
697 | XFS_IEXT_ADD_NOSPLIT_CNT); | |
4f86bb4b CB |
698 | if (error == -EFBIG) |
699 | error = xfs_iext_count_upgrade(tp, ip, | |
700 | XFS_IEXT_ADD_NOSPLIT_CNT); | |
727e1acd CB |
701 | if (error) |
702 | goto out_trans_cancel; | |
703 | ||
c963c619 DC |
704 | /* |
705 | * Allocate blocks to the bitmap file. | |
706 | */ | |
707 | nmap = 1; | |
c963c619 | 708 | error = xfs_bmapi_write(tp, ip, oblocks, nblocks - oblocks, |
da781e64 | 709 | XFS_BMAPI_METADATA, 0, &map, &nmap); |
c963c619 | 710 | if (!error && nmap < 1) |
2451337d | 711 | error = -ENOSPC; |
c963c619 | 712 | if (error) |
c8eac49e | 713 | goto out_trans_cancel; |
c963c619 DC |
714 | /* |
715 | * Free any blocks freed up in the transaction, then commit. | |
716 | */ | |
70393313 | 717 | error = xfs_trans_commit(tp); |
c963c619 | 718 | if (error) |
d4a97a04 | 719 | return error; |
c963c619 DC |
720 | /* |
721 | * Now we need to clear the allocated blocks. | |
722 | * Do this one block per transaction, to keep it simple. | |
723 | */ | |
c963c619 DC |
724 | for (bno = map.br_startoff, fsbno = map.br_startblock; |
725 | bno < map.br_startoff + map.br_blockcount; | |
726 | bno++, fsbno++) { | |
c963c619 DC |
727 | /* |
728 | * Reserve log for one block zeroing. | |
729 | */ | |
253f4911 CH |
730 | error = xfs_trans_alloc(mp, &M_RES(mp)->tr_growrtzero, |
731 | 0, 0, 0, &tp); | |
c963c619 | 732 | if (error) |
253f4911 | 733 | return error; |
c963c619 DC |
734 | /* |
735 | * Lock the bitmap inode. | |
736 | */ | |
737 | xfs_ilock(ip, XFS_ILOCK_EXCL); | |
738 | xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL); | |
739 | /* | |
740 | * Get a buffer for the block. | |
741 | */ | |
742 | d = XFS_FSB_TO_DADDR(mp, fsbno); | |
ce92464c DW |
743 | error = xfs_trans_get_buf(tp, mp->m_ddev_targp, d, |
744 | mp->m_bsize, 0, &bp); | |
745 | if (error) | |
d4a97a04 | 746 | goto out_trans_cancel; |
72cc9513 CB |
747 | |
748 | xfs_trans_buf_set_type(tp, bp, buf_type); | |
c54e14d1 | 749 | bp->b_ops = &xfs_rtbuf_ops; |
c963c619 DC |
750 | memset(bp->b_addr, 0, mp->m_sb.sb_blocksize); |
751 | xfs_trans_log_buf(tp, bp, 0, mp->m_sb.sb_blocksize - 1); | |
752 | /* | |
753 | * Commit the transaction. | |
754 | */ | |
70393313 | 755 | error = xfs_trans_commit(tp); |
c963c619 | 756 | if (error) |
d4a97a04 | 757 | return error; |
1da177e4 | 758 | } |
c963c619 DC |
759 | /* |
760 | * Go on to the next extent, if any. | |
761 | */ | |
762 | oblocks = map.br_startoff + map.br_blockcount; | |
1da177e4 | 763 | } |
d4a97a04 | 764 | |
1da177e4 | 765 | return 0; |
c963c619 | 766 | |
d4a97a04 BF |
767 | out_trans_cancel: |
768 | xfs_trans_cancel(tp); | |
c963c619 | 769 | return error; |
1da177e4 LT |
770 | } |
771 | ||
65eed012 OS |
772 | static void |
773 | xfs_alloc_rsum_cache( | |
774 | xfs_mount_t *mp, /* file system mount structure */ | |
775 | xfs_extlen_t rbmblocks) /* number of rt bitmap blocks */ | |
776 | { | |
777 | /* | |
e23aaf45 OS |
778 | * The rsum cache is initialized to the maximum value, which is |
779 | * trivially an upper bound on the maximum level with any free extents. | |
780 | * We can continue without the cache if it couldn't be allocated. | |
65eed012 | 781 | */ |
e23aaf45 OS |
782 | mp->m_rsum_cache = kvmalloc(rbmblocks, GFP_KERNEL); |
783 | if (mp->m_rsum_cache) | |
784 | memset(mp->m_rsum_cache, -1, rbmblocks); | |
785 | else | |
65eed012 OS |
786 | xfs_warn(mp, "could not allocate realtime summary cache"); |
787 | } | |
788 | ||
1da177e4 LT |
789 | /* |
790 | * Visible (exported) functions. | |
791 | */ | |
792 | ||
793 | /* | |
794 | * Grow the realtime area of the filesystem. | |
795 | */ | |
796 | int | |
797 | xfs_growfs_rt( | |
798 | xfs_mount_t *mp, /* mount point for filesystem */ | |
799 | xfs_growfs_rt_t *in) /* growfs rt input struct */ | |
800 | { | |
03f4de33 | 801 | xfs_fileoff_t bmbno; /* bitmap block number */ |
e8222613 | 802 | struct xfs_buf *bp; /* temporary buffer */ |
1da177e4 | 803 | int error; /* error return value */ |
1da177e4 | 804 | xfs_mount_t *nmp; /* new (fake) mount structure */ |
d5cf09ba | 805 | xfs_rfsblock_t nrblocks; /* new number of realtime blocks */ |
1da177e4 | 806 | xfs_extlen_t nrbmblocks; /* new number of rt bitmap blocks */ |
2d5f216b | 807 | xfs_rtxnum_t nrextents; /* new number of realtime extents */ |
1da177e4 LT |
808 | uint8_t nrextslog; /* new log2 of sb_rextents */ |
809 | xfs_extlen_t nrsumblocks; /* new number of summary blocks */ | |
810 | uint nrsumlevels; /* new rt summary levels */ | |
811 | uint nrsumsize; /* new size of rt summary, bytes */ | |
812 | xfs_sb_t *nsbp; /* new superblock */ | |
813 | xfs_extlen_t rbmblocks; /* current number of rt bitmap blocks */ | |
814 | xfs_extlen_t rsumblocks; /* current number of rt summary blks */ | |
815 | xfs_sb_t *sbp; /* old superblock */ | |
65eed012 | 816 | uint8_t *rsum_cache; /* old summary cache */ |
1da177e4 LT |
817 | |
818 | sbp = &mp->m_sb; | |
0e2af929 | 819 | |
743bb465 | 820 | if (!capable(CAP_SYS_ADMIN)) |
2451337d | 821 | return -EPERM; |
0e2af929 DW |
822 | |
823 | /* Needs to have been mounted with an rt device. */ | |
824 | if (!XFS_IS_REALTIME_MOUNT(mp)) | |
825 | return -EINVAL; | |
826 | /* | |
827 | * Mount should fail if the rt bitmap/summary files don't load, but | |
828 | * we'll check anyway. | |
829 | */ | |
830 | if (!mp->m_rbmip || !mp->m_rsumip) | |
831 | return -EINVAL; | |
832 | ||
833 | /* Shrink not supported. */ | |
834 | if (in->newblocks <= sbp->sb_rblocks) | |
835 | return -EINVAL; | |
836 | ||
837 | /* Can only change rt extent size when adding rt volume. */ | |
838 | if (sbp->sb_rblocks > 0 && in->extsize != sbp->sb_rextsize) | |
839 | return -EINVAL; | |
840 | ||
841 | /* Range check the extent size. */ | |
842 | if (XFS_FSB_TO_B(mp, in->extsize) > XFS_MAX_RTEXTSIZE || | |
843 | XFS_FSB_TO_B(mp, in->extsize) < XFS_MIN_RTEXTSIZE) | |
2451337d | 844 | return -EINVAL; |
0e2af929 DW |
845 | |
846 | /* Unsupported realtime features. */ | |
b73494fa | 847 | if (xfs_has_rmapbt(mp) || xfs_has_reflink(mp) || xfs_has_quota(mp)) |
0e2af929 DW |
848 | return -EOPNOTSUPP; |
849 | ||
850 | nrblocks = in->newblocks; | |
851 | error = xfs_sb_validate_fsb_count(sbp, nrblocks); | |
852 | if (error) | |
4cc929ee | 853 | return error; |
1da177e4 LT |
854 | /* |
855 | * Read in the last block of the device, make sure it exists. | |
856 | */ | |
ba372674 | 857 | error = xfs_buf_read_uncached(mp->m_rtdev_targp, |
1922c949 | 858 | XFS_FSB_TO_BB(mp, nrblocks - 1), |
ba372674 DC |
859 | XFS_FSB_TO_BB(mp, 1), 0, &bp, NULL); |
860 | if (error) | |
eab4e633 | 861 | return error; |
1da177e4 | 862 | xfs_buf_relse(bp); |
1922c949 | 863 | |
1da177e4 LT |
864 | /* |
865 | * Calculate new parameters. These are the final values to be reached. | |
866 | */ | |
867 | nrextents = nrblocks; | |
868 | do_div(nrextents, in->extsize); | |
e1429380 DW |
869 | if (!xfs_validate_rtextents(nrextents)) |
870 | return -EINVAL; | |
d0448fe7 | 871 | nrbmblocks = xfs_rtbitmap_blockcount(mp, nrextents); |
a6a38f30 | 872 | nrextslog = xfs_compute_rextslog(nrextents); |
1da177e4 | 873 | nrsumlevels = nrextslog + 1; |
bd85af28 | 874 | nrsumblocks = xfs_rtsummary_blockcount(mp, nrsumlevels, nrbmblocks); |
1da177e4 LT |
875 | nrsumsize = XFS_FSB_TO_B(mp, nrsumblocks); |
876 | /* | |
877 | * New summary size can't be more than half the size of | |
878 | * the log. This prevents us from getting a log overflow, | |
879 | * since we'll log basically the whole summary file at once. | |
880 | */ | |
881 | if (nrsumblocks > (mp->m_sb.sb_logblocks >> 1)) | |
2451337d | 882 | return -EINVAL; |
1da177e4 LT |
883 | /* |
884 | * Get the old block counts for bitmap and summary inodes. | |
885 | * These can't change since other growfs callers are locked out. | |
886 | */ | |
13d2c10b CH |
887 | rbmblocks = XFS_B_TO_FSB(mp, mp->m_rbmip->i_disk_size); |
888 | rsumblocks = XFS_B_TO_FSB(mp, mp->m_rsumip->i_disk_size); | |
1da177e4 LT |
889 | /* |
890 | * Allocate space to the bitmap and summary files, as necessary. | |
891 | */ | |
1050c71e CH |
892 | error = xfs_growfs_rt_alloc(mp, rbmblocks, nrbmblocks, mp->m_rbmip); |
893 | if (error) | |
1da177e4 | 894 | return error; |
1050c71e CH |
895 | error = xfs_growfs_rt_alloc(mp, rsumblocks, nrsumblocks, mp->m_rsumip); |
896 | if (error) | |
1da177e4 | 897 | return error; |
65eed012 OS |
898 | |
899 | rsum_cache = mp->m_rsum_cache; | |
900 | if (nrbmblocks != sbp->sb_rbmblocks) | |
901 | xfs_alloc_rsum_cache(mp, nrbmblocks); | |
902 | ||
d432c80e NS |
903 | /* |
904 | * Allocate a new (fake) mount/sb. | |
905 | */ | |
707e0dda | 906 | nmp = kmem_alloc(sizeof(*nmp), 0); |
1da177e4 LT |
907 | /* |
908 | * Loop over the bitmap blocks. | |
909 | * We will do everything one bitmap block at a time. | |
910 | * Skip the current block if it is exactly full. | |
911 | * This also deals with the case where there were no rtextents before. | |
912 | */ | |
913 | for (bmbno = sbp->sb_rbmblocks - | |
914 | ((sbp->sb_rextents & ((1 << mp->m_blkbit_log) - 1)) != 0); | |
915 | bmbno < nrbmblocks; | |
916 | bmbno++) { | |
41f33d82 DC |
917 | struct xfs_rtalloc_args args = { |
918 | .mp = mp, | |
919 | }; | |
920 | struct xfs_rtalloc_args nargs = { | |
921 | .mp = nmp, | |
922 | }; | |
0925fecc DW |
923 | struct xfs_trans *tp; |
924 | xfs_rfsblock_t nrblocks_step; | |
0924b585 | 925 | |
1da177e4 LT |
926 | *nmp = *mp; |
927 | nsbp = &nmp->m_sb; | |
928 | /* | |
929 | * Calculate new sb and mount fields for this round. | |
930 | */ | |
931 | nsbp->sb_rextsize = in->extsize; | |
ef5a83b7 | 932 | nmp->m_rtxblklog = -1; /* don't use shift or masking */ |
1da177e4 | 933 | nsbp->sb_rbmblocks = bmbno + 1; |
0925fecc DW |
934 | nrblocks_step = (bmbno + 1) * NBBY * nsbp->sb_blocksize * |
935 | nsbp->sb_rextsize; | |
936 | nsbp->sb_rblocks = min(nrblocks, nrblocks_step); | |
05564124 | 937 | nsbp->sb_rextents = xfs_rtb_to_rtx(nmp, nsbp->sb_rblocks); |
79071eb0 | 938 | ASSERT(nsbp->sb_rextents != 0); |
a6a38f30 | 939 | nsbp->sb_rextslog = xfs_compute_rextslog(nsbp->sb_rextents); |
1da177e4 | 940 | nrsumlevels = nmp->m_rsumlevels = nsbp->sb_rextslog + 1; |
bd85af28 DW |
941 | nrsumblocks = xfs_rtsummary_blockcount(mp, nrsumlevels, |
942 | nsbp->sb_rbmblocks); | |
1da177e4 | 943 | nmp->m_rsumsize = nrsumsize = XFS_FSB_TO_B(mp, nrsumblocks); |
578bd4ce DW |
944 | /* recompute growfsrt reservation from new rsumsize */ |
945 | xfs_trans_resv_calc(nmp, &nmp->m_resv); | |
946 | ||
1da177e4 LT |
947 | /* |
948 | * Start a transaction, get the log reservation. | |
949 | */ | |
253f4911 CH |
950 | error = xfs_trans_alloc(mp, &M_RES(mp)->tr_growrtfree, 0, 0, 0, |
951 | &tp); | |
3d3c8b52 | 952 | if (error) |
253f4911 | 953 | break; |
41f33d82 DC |
954 | args.tp = tp; |
955 | nargs.tp = tp; | |
956 | ||
1da177e4 LT |
957 | /* |
958 | * Lock out other callers by grabbing the bitmap inode lock. | |
959 | */ | |
ace74e79 | 960 | xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL | XFS_ILOCK_RTBITMAP); |
ddc3415a | 961 | xfs_trans_ijoin(tp, mp->m_rbmip, XFS_ILOCK_EXCL); |
1da177e4 | 962 | /* |
f4c32e87 DW |
963 | * Update the bitmap inode's size ondisk and incore. We need |
964 | * to update the incore size so that inode inactivation won't | |
965 | * punch what it thinks are "posteof" blocks. | |
1da177e4 | 966 | */ |
13d2c10b | 967 | mp->m_rbmip->i_disk_size = |
1da177e4 | 968 | nsbp->sb_rbmblocks * nsbp->sb_blocksize; |
13d2c10b | 969 | i_size_write(VFS_I(mp->m_rbmip), mp->m_rbmip->i_disk_size); |
1da177e4 | 970 | xfs_trans_log_inode(tp, mp->m_rbmip, XFS_ILOG_CORE); |
1da177e4 LT |
971 | /* |
972 | * Get the summary inode into the transaction. | |
973 | */ | |
ace74e79 | 974 | xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL | XFS_ILOCK_RTSUM); |
ddc3415a | 975 | xfs_trans_ijoin(tp, mp->m_rsumip, XFS_ILOCK_EXCL); |
1da177e4 | 976 | /* |
f4c32e87 DW |
977 | * Update the summary inode's size. We need to update the |
978 | * incore size so that inode inactivation won't punch what it | |
979 | * thinks are "posteof" blocks. | |
1da177e4 | 980 | */ |
13d2c10b CH |
981 | mp->m_rsumip->i_disk_size = nmp->m_rsumsize; |
982 | i_size_write(VFS_I(mp->m_rsumip), mp->m_rsumip->i_disk_size); | |
1da177e4 LT |
983 | xfs_trans_log_inode(tp, mp->m_rsumip, XFS_ILOG_CORE); |
984 | /* | |
985 | * Copy summary data from old to new sizes. | |
986 | * Do this when the real size (not block-aligned) changes. | |
987 | */ | |
988 | if (sbp->sb_rbmblocks != nsbp->sb_rbmblocks || | |
989 | mp->m_rsumlevels != nmp->m_rsumlevels) { | |
41f33d82 | 990 | error = xfs_rtcopy_summary(&args, &nargs); |
1da177e4 | 991 | if (error) |
0924b585 | 992 | goto error_cancel; |
1da177e4 LT |
993 | } |
994 | /* | |
995 | * Update superblock fields. | |
996 | */ | |
997 | if (nsbp->sb_rextsize != sbp->sb_rextsize) | |
998 | xfs_trans_mod_sb(tp, XFS_TRANS_SB_REXTSIZE, | |
999 | nsbp->sb_rextsize - sbp->sb_rextsize); | |
1000 | if (nsbp->sb_rbmblocks != sbp->sb_rbmblocks) | |
1001 | xfs_trans_mod_sb(tp, XFS_TRANS_SB_RBMBLOCKS, | |
1002 | nsbp->sb_rbmblocks - sbp->sb_rbmblocks); | |
1003 | if (nsbp->sb_rblocks != sbp->sb_rblocks) | |
1004 | xfs_trans_mod_sb(tp, XFS_TRANS_SB_RBLOCKS, | |
1005 | nsbp->sb_rblocks - sbp->sb_rblocks); | |
1006 | if (nsbp->sb_rextents != sbp->sb_rextents) | |
1007 | xfs_trans_mod_sb(tp, XFS_TRANS_SB_REXTENTS, | |
1008 | nsbp->sb_rextents - sbp->sb_rextents); | |
1009 | if (nsbp->sb_rextslog != sbp->sb_rextslog) | |
1010 | xfs_trans_mod_sb(tp, XFS_TRANS_SB_REXTSLOG, | |
1011 | nsbp->sb_rextslog - sbp->sb_rextslog); | |
1012 | /* | |
1013 | * Free new extent. | |
1014 | */ | |
41f33d82 | 1015 | error = xfs_rtfree_range(&nargs, sbp->sb_rextents, |
e94b53ff OS |
1016 | nsbp->sb_rextents - sbp->sb_rextents); |
1017 | xfs_rtbuf_cache_relse(&nargs); | |
0924b585 DC |
1018 | if (error) { |
1019 | error_cancel: | |
4906e215 | 1020 | xfs_trans_cancel(tp); |
d432c80e | 1021 | break; |
0924b585 | 1022 | } |
1da177e4 LT |
1023 | /* |
1024 | * Mark more blocks free in the superblock. | |
1025 | */ | |
1026 | xfs_trans_mod_sb(tp, XFS_TRANS_SB_FREXTENTS, | |
1027 | nsbp->sb_rextents - sbp->sb_rextents); | |
1da177e4 LT |
1028 | /* |
1029 | * Update mp values into the real mp structure. | |
1030 | */ | |
1031 | mp->m_rsumlevels = nrsumlevels; | |
1032 | mp->m_rsumsize = nrsumsize; | |
578bd4ce DW |
1033 | /* recompute growfsrt reservation from new rsumsize */ |
1034 | xfs_trans_resv_calc(mp, &mp->m_resv); | |
e5720eec | 1035 | |
70393313 | 1036 | error = xfs_trans_commit(tp); |
0924b585 | 1037 | if (error) |
e5720eec | 1038 | break; |
a1d86e8d DC |
1039 | |
1040 | /* Ensure the mount RT feature flag is now set. */ | |
1041 | mp->m_features |= XFS_FEAT_REALTIME; | |
1da177e4 | 1042 | } |
7249c95a DW |
1043 | if (error) |
1044 | goto out_free; | |
1045 | ||
1046 | /* Update secondary superblocks now the physical grow has completed */ | |
1047 | error = xfs_update_secondary_sbs(mp); | |
d432c80e | 1048 | |
7249c95a | 1049 | out_free: |
1da177e4 | 1050 | /* |
d432c80e | 1051 | * Free the fake mp structure. |
1da177e4 | 1052 | */ |
f0e2d93c | 1053 | kmem_free(nmp); |
d432c80e | 1054 | |
65eed012 OS |
1055 | /* |
1056 | * If we had to allocate a new rsum_cache, we either need to free the | |
1057 | * old one (if we succeeded) or free the new one and restore the old one | |
1058 | * (if there was an error). | |
1059 | */ | |
1060 | if (rsum_cache != mp->m_rsum_cache) { | |
1061 | if (error) { | |
1062 | kmem_free(mp->m_rsum_cache); | |
1063 | mp->m_rsum_cache = rsum_cache; | |
1064 | } else { | |
1065 | kmem_free(rsum_cache); | |
1066 | } | |
1067 | } | |
1068 | ||
1da177e4 LT |
1069 | return error; |
1070 | } | |
1071 | ||
1da177e4 LT |
1072 | /* |
1073 | * Initialize realtime fields in the mount structure. | |
1074 | */ | |
1075 | int /* error */ | |
1076 | xfs_rtmount_init( | |
ba372674 | 1077 | struct xfs_mount *mp) /* file system mount structure */ |
1da177e4 | 1078 | { |
ba372674 DC |
1079 | struct xfs_buf *bp; /* buffer for last block of subvolume */ |
1080 | struct xfs_sb *sbp; /* filesystem superblock copy in mount */ | |
1081 | xfs_daddr_t d; /* address of last block of subvolume */ | |
bd85af28 | 1082 | unsigned int rsumblocks; |
ba372674 | 1083 | int error; |
1da177e4 LT |
1084 | |
1085 | sbp = &mp->m_sb; | |
1086 | if (sbp->sb_rblocks == 0) | |
1087 | return 0; | |
1088 | if (mp->m_rtdev_targp == NULL) { | |
0b932ccc DC |
1089 | xfs_warn(mp, |
1090 | "Filesystem has a realtime volume, use rtdev=device option"); | |
2451337d | 1091 | return -ENODEV; |
1da177e4 LT |
1092 | } |
1093 | mp->m_rsumlevels = sbp->sb_rextslog + 1; | |
bd85af28 DW |
1094 | rsumblocks = xfs_rtsummary_blockcount(mp, mp->m_rsumlevels, |
1095 | mp->m_sb.sb_rbmblocks); | |
1096 | mp->m_rsumsize = XFS_FSB_TO_B(mp, rsumblocks); | |
1da177e4 LT |
1097 | mp->m_rbmip = mp->m_rsumip = NULL; |
1098 | /* | |
1099 | * Check that the realtime section is an ok size. | |
1100 | */ | |
1101 | d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_rblocks); | |
1102 | if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_rblocks) { | |
0b932ccc | 1103 | xfs_warn(mp, "realtime mount -- %llu != %llu", |
1da177e4 LT |
1104 | (unsigned long long) XFS_BB_TO_FSB(mp, d), |
1105 | (unsigned long long) mp->m_sb.sb_rblocks); | |
2451337d | 1106 | return -EFBIG; |
1da177e4 | 1107 | } |
ba372674 | 1108 | error = xfs_buf_read_uncached(mp->m_rtdev_targp, |
1922c949 | 1109 | d - XFS_FSB_TO_BB(mp, 1), |
ba372674 DC |
1110 | XFS_FSB_TO_BB(mp, 1), 0, &bp, NULL); |
1111 | if (error) { | |
0b932ccc | 1112 | xfs_warn(mp, "realtime device size check failed"); |
ba372674 | 1113 | return error; |
1da177e4 LT |
1114 | } |
1115 | xfs_buf_relse(bp); | |
1116 | return 0; | |
1117 | } | |
1118 | ||
5a605fd6 DW |
1119 | static int |
1120 | xfs_rtalloc_count_frextent( | |
1121 | struct xfs_mount *mp, | |
1122 | struct xfs_trans *tp, | |
1123 | const struct xfs_rtalloc_rec *rec, | |
1124 | void *priv) | |
1125 | { | |
1126 | uint64_t *valp = priv; | |
1127 | ||
1128 | *valp += rec->ar_extcount; | |
1129 | return 0; | |
1130 | } | |
1131 | ||
1132 | /* | |
1133 | * Reinitialize the number of free realtime extents from the realtime bitmap. | |
1134 | * Callers must ensure that there is no other activity in the filesystem. | |
1135 | */ | |
1136 | int | |
1137 | xfs_rtalloc_reinit_frextents( | |
1138 | struct xfs_mount *mp) | |
1139 | { | |
1140 | uint64_t val = 0; | |
1141 | int error; | |
1142 | ||
5f369dc5 | 1143 | xfs_ilock(mp->m_rbmip, XFS_ILOCK_SHARED | XFS_ILOCK_RTBITMAP); |
5a605fd6 DW |
1144 | error = xfs_rtalloc_query_all(mp, NULL, xfs_rtalloc_count_frextent, |
1145 | &val); | |
5f369dc5 | 1146 | xfs_iunlock(mp->m_rbmip, XFS_ILOCK_SHARED | XFS_ILOCK_RTBITMAP); |
5a605fd6 DW |
1147 | if (error) |
1148 | return error; | |
1149 | ||
1150 | spin_lock(&mp->m_sb_lock); | |
1151 | mp->m_sb.sb_frextents = val; | |
1152 | spin_unlock(&mp->m_sb_lock); | |
2229276c | 1153 | percpu_counter_set(&mp->m_frextents, mp->m_sb.sb_frextents); |
5a605fd6 DW |
1154 | return 0; |
1155 | } | |
1156 | ||
9e13975b DW |
1157 | /* |
1158 | * Read in the bmbt of an rt metadata inode so that we never have to load them | |
1159 | * at runtime. This enables the use of shared ILOCKs for rtbitmap scans. Use | |
1160 | * an empty transaction to avoid deadlocking on loops in the bmbt. | |
1161 | */ | |
1162 | static inline int | |
1163 | xfs_rtmount_iread_extents( | |
1164 | struct xfs_inode *ip, | |
1165 | unsigned int lock_class) | |
1166 | { | |
1167 | struct xfs_trans *tp; | |
1168 | int error; | |
1169 | ||
1170 | error = xfs_trans_alloc_empty(ip->i_mount, &tp); | |
1171 | if (error) | |
1172 | return error; | |
1173 | ||
1174 | xfs_ilock(ip, XFS_ILOCK_EXCL | lock_class); | |
1175 | ||
1176 | error = xfs_iread_extents(tp, ip, XFS_DATA_FORK); | |
1177 | if (error) | |
1178 | goto out_unlock; | |
1179 | ||
1180 | if (xfs_inode_has_attr_fork(ip)) { | |
1181 | error = xfs_iread_extents(tp, ip, XFS_ATTR_FORK); | |
1182 | if (error) | |
1183 | goto out_unlock; | |
1184 | } | |
1185 | ||
1186 | out_unlock: | |
1187 | xfs_iunlock(ip, XFS_ILOCK_EXCL | lock_class); | |
1188 | xfs_trans_cancel(tp); | |
1189 | return error; | |
1190 | } | |
1191 | ||
1da177e4 | 1192 | /* |
355e3532 OS |
1193 | * Get the bitmap and summary inodes and the summary cache into the mount |
1194 | * structure at mount time. | |
1da177e4 LT |
1195 | */ |
1196 | int /* error */ | |
1197 | xfs_rtmount_inodes( | |
1198 | xfs_mount_t *mp) /* file system mount structure */ | |
1199 | { | |
1200 | int error; /* error return value */ | |
1201 | xfs_sb_t *sbp; | |
1202 | ||
1203 | sbp = &mp->m_sb; | |
7b6259e7 | 1204 | error = xfs_iget(mp, NULL, sbp->sb_rbmino, 0, 0, &mp->m_rbmip); |
1da177e4 LT |
1205 | if (error) |
1206 | return error; | |
1207 | ASSERT(mp->m_rbmip != NULL); | |
64bafd2f | 1208 | |
9e13975b DW |
1209 | error = xfs_rtmount_iread_extents(mp->m_rbmip, XFS_ILOCK_RTBITMAP); |
1210 | if (error) | |
1211 | goto out_rele_bitmap; | |
1212 | ||
7b6259e7 | 1213 | error = xfs_iget(mp, NULL, sbp->sb_rsumino, 0, 0, &mp->m_rsumip); |
9e13975b DW |
1214 | if (error) |
1215 | goto out_rele_bitmap; | |
1da177e4 | 1216 | ASSERT(mp->m_rsumip != NULL); |
9e13975b DW |
1217 | |
1218 | error = xfs_rtmount_iread_extents(mp->m_rsumip, XFS_ILOCK_RTSUM); | |
1219 | if (error) | |
1220 | goto out_rele_summary; | |
1221 | ||
65eed012 | 1222 | xfs_alloc_rsum_cache(mp, sbp->sb_rbmblocks); |
1da177e4 | 1223 | return 0; |
9e13975b DW |
1224 | |
1225 | out_rele_summary: | |
1226 | xfs_irele(mp->m_rsumip); | |
1227 | out_rele_bitmap: | |
1228 | xfs_irele(mp->m_rbmip); | |
1229 | return error; | |
1da177e4 LT |
1230 | } |
1231 | ||
b93b6e43 CH |
1232 | void |
1233 | xfs_rtunmount_inodes( | |
1234 | struct xfs_mount *mp) | |
1235 | { | |
355e3532 | 1236 | kmem_free(mp->m_rsum_cache); |
b93b6e43 | 1237 | if (mp->m_rbmip) |
44a8736b | 1238 | xfs_irele(mp->m_rbmip); |
b93b6e43 | 1239 | if (mp->m_rsumip) |
44a8736b | 1240 | xfs_irele(mp->m_rsumip); |
b93b6e43 CH |
1241 | } |
1242 | ||
1da177e4 LT |
1243 | /* |
1244 | * Pick an extent for allocation at the start of a new realtime file. | |
1245 | * Use the sequence number stored in the atime field of the bitmap inode. | |
1246 | * Translate this to a fraction of the rtextents, and return the product | |
1247 | * of rtextents and the fraction. | |
1248 | * The fraction sequence is 0, 1/2, 1/4, 3/4, 1/8, ..., 7/8, 1/16, ... | |
1249 | */ | |
152e2123 | 1250 | static int |
1da177e4 | 1251 | xfs_rtpick_extent( |
75d1e312 JL |
1252 | xfs_mount_t *mp, /* file system mount point */ |
1253 | xfs_trans_t *tp, /* transaction pointer */ | |
34f76326 LT |
1254 | xfs_rtxlen_t len, /* allocation length (rtextents) */ |
1255 | xfs_rtxnum_t *pick) /* result rt extent */ | |
1da177e4 | 1256 | { |
34f76326 | 1257 | xfs_rtxnum_t b; /* result rtext */ |
75d1e312 JL |
1258 | int log2; /* log of sequence number */ |
1259 | uint64_t resid; /* residual after log removed */ | |
1260 | uint64_t seq; /* sequence number of file creation */ | |
34f76326 | 1261 | struct timespec64 ts; /* timespec in inode */ |
1da177e4 | 1262 | |
04e99455 CH |
1263 | ASSERT(xfs_isilocked(mp->m_rbmip, XFS_ILOCK_EXCL)); |
1264 | ||
34f76326 | 1265 | ts = inode_get_atime(VFS_I(mp->m_rbmip)); |
db07349d CH |
1266 | if (!(mp->m_rbmip->i_diflags & XFS_DIFLAG_NEWRTBM)) { |
1267 | mp->m_rbmip->i_diflags |= XFS_DIFLAG_NEWRTBM; | |
75d1e312 JL |
1268 | seq = 0; |
1269 | } else { | |
34f76326 | 1270 | seq = ts.tv_sec; |
1da177e4 | 1271 | } |
1da177e4 LT |
1272 | if ((log2 = xfs_highbit64(seq)) == -1) |
1273 | b = 0; | |
1274 | else { | |
1275 | resid = seq - (1ULL << log2); | |
1276 | b = (mp->m_sb.sb_rextents * ((resid << 1) + 1ULL)) >> | |
1277 | (log2 + 1); | |
1278 | if (b >= mp->m_sb.sb_rextents) | |
0703a8e1 | 1279 | div64_u64_rem(b, mp->m_sb.sb_rextents, &b); |
1da177e4 LT |
1280 | if (b + len > mp->m_sb.sb_rextents) |
1281 | b = mp->m_sb.sb_rextents - len; | |
1282 | } | |
34f76326 | 1283 | ts.tv_sec = seq + 1; |
75d1e312 | 1284 | inode_set_atime_to_ts(VFS_I(mp->m_rbmip), ts); |
04e99455 | 1285 | xfs_trans_log_inode(tp, mp->m_rbmip, XFS_ILOG_CORE); |
1da177e4 LT |
1286 | *pick = b; |
1287 | return 0; | |
1288 | } | |
152e2123 | 1289 | |
b6bb3458 CH |
1290 | static void |
1291 | xfs_rtalloc_align_minmax( | |
1292 | xfs_rtxlen_t *raminlen, | |
1293 | xfs_rtxlen_t *ramaxlen, | |
1294 | xfs_rtxlen_t *prod) | |
1295 | { | |
1296 | xfs_rtxlen_t newmaxlen = *ramaxlen; | |
1297 | xfs_rtxlen_t newminlen = *raminlen; | |
1298 | xfs_rtxlen_t slack; | |
1299 | ||
1300 | slack = newmaxlen % *prod; | |
1301 | if (slack) | |
1302 | newmaxlen -= slack; | |
1303 | slack = newminlen % *prod; | |
1304 | if (slack) | |
1305 | newminlen += *prod - slack; | |
1306 | ||
1307 | /* | |
1308 | * If adjusting for extent size hint alignment produces an invalid | |
1309 | * min/max len combination, go ahead without it. | |
1310 | */ | |
1311 | if (newmaxlen < newminlen) { | |
1312 | *prod = 1; | |
1313 | return; | |
1314 | } | |
1315 | *ramaxlen = newmaxlen; | |
1316 | *raminlen = newminlen; | |
1317 | } | |
1318 | ||
152e2123 CH |
1319 | int |
1320 | xfs_bmap_rtalloc( | |
1321 | struct xfs_bmalloca *ap) | |
1322 | { | |
1323 | struct xfs_mount *mp = ap->ip->i_mount; | |
1324 | xfs_fileoff_t orig_offset = ap->offset; | |
a3e48f68 CH |
1325 | xfs_rtxnum_t start; /* allocation hint rtextent no */ |
1326 | xfs_rtxnum_t rtx; /* actually allocated rtextent no */ | |
152e2123 CH |
1327 | xfs_rtxlen_t prod = 0; /* product factor for allocators */ |
1328 | xfs_extlen_t mod = 0; /* product factor for allocators */ | |
1329 | xfs_rtxlen_t ralen = 0; /* realtime allocation length */ | |
1330 | xfs_extlen_t align; /* minimum allocation alignment */ | |
1331 | xfs_extlen_t orig_length = ap->length; | |
1332 | xfs_extlen_t minlen = mp->m_sb.sb_rextsize; | |
1333 | xfs_rtxlen_t raminlen; | |
1334 | bool rtlocked = false; | |
1335 | bool ignore_locality = false; | |
e1ead237 CH |
1336 | struct xfs_rtalloc_args args = { |
1337 | .mp = mp, | |
1338 | .tp = ap->tp, | |
1339 | }; | |
152e2123 CH |
1340 | int error; |
1341 | ||
1342 | align = xfs_get_extsz_hint(ap->ip); | |
1343 | retry: | |
152e2123 CH |
1344 | error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev, |
1345 | align, 1, ap->eof, 0, | |
1346 | ap->conv, &ap->offset, &ap->length); | |
1347 | if (error) | |
1348 | return error; | |
1349 | ASSERT(ap->length); | |
1350 | ASSERT(xfs_extlen_to_rtxmod(mp, ap->length) == 0); | |
1351 | ||
1352 | /* | |
1353 | * If we shifted the file offset downward to satisfy an extent size | |
1354 | * hint, increase minlen by that amount so that the allocator won't | |
1355 | * give us an allocation that's too short to cover at least one of the | |
1356 | * blocks that the caller asked for. | |
1357 | */ | |
1358 | if (ap->offset != orig_offset) | |
1359 | minlen += orig_offset - ap->offset; | |
1360 | ||
152e2123 CH |
1361 | /* |
1362 | * Set ralen to be the actual requested length in rtextents. | |
1363 | * | |
1364 | * If the old value was close enough to XFS_BMBT_MAX_EXTLEN that | |
1365 | * we rounded up to it, cut it back so it's valid again. | |
1366 | * Note that if it's a really large request (bigger than | |
1367 | * XFS_BMBT_MAX_EXTLEN), we don't hear about that number, and can't | |
1368 | * adjust the starting point to match it. | |
1369 | */ | |
1370 | ralen = xfs_extlen_to_rtxlen(mp, min(ap->length, XFS_MAX_BMBT_EXTLEN)); | |
26e5eed7 | 1371 | raminlen = max_t(xfs_rtxlen_t, 1, xfs_extlen_to_rtxlen(mp, minlen)); |
e1ead237 CH |
1372 | ASSERT(raminlen > 0); |
1373 | ASSERT(raminlen <= ralen); | |
152e2123 CH |
1374 | |
1375 | /* | |
1376 | * Lock out modifications to both the RT bitmap and summary inodes | |
1377 | */ | |
1378 | if (!rtlocked) { | |
1379 | xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL|XFS_ILOCK_RTBITMAP); | |
1380 | xfs_trans_ijoin(ap->tp, mp->m_rbmip, XFS_ILOCK_EXCL); | |
1381 | xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL|XFS_ILOCK_RTSUM); | |
1382 | xfs_trans_ijoin(ap->tp, mp->m_rsumip, XFS_ILOCK_EXCL); | |
1383 | rtlocked = true; | |
1384 | } | |
1385 | ||
a3e48f68 CH |
1386 | if (ignore_locality) { |
1387 | start = 0; | |
1388 | } else if (xfs_bmap_adjacent(ap)) { | |
1389 | start = xfs_rtb_to_rtx(mp, ap->blkno); | |
1390 | } else if (ap->eof && ap->offset == 0) { | |
1391 | /* | |
1392 | * If it's an allocation to an empty file at offset 0, pick an | |
1393 | * extent that will space things out in the rt area. | |
1394 | */ | |
1395 | error = xfs_rtpick_extent(mp, ap->tp, ralen, &start); | |
152e2123 CH |
1396 | if (error) |
1397 | return error; | |
152e2123 | 1398 | } else { |
a3e48f68 | 1399 | start = 0; |
152e2123 CH |
1400 | } |
1401 | ||
26e5eed7 CH |
1402 | /* |
1403 | * Only bother calculating a real prod factor if offset & length are | |
1404 | * perfectly aligned, otherwise it will just get us in trouble. | |
1405 | */ | |
1406 | div_u64_rem(ap->offset, align, &mod); | |
b6bb3458 | 1407 | if (mod || ap->length % align) { |
26e5eed7 | 1408 | prod = 1; |
b6bb3458 | 1409 | } else { |
26e5eed7 | 1410 | prod = xfs_extlen_to_rtxlen(mp, align); |
b6bb3458 CH |
1411 | if (prod > 1) |
1412 | xfs_rtalloc_align_minmax(&raminlen, &ralen, &prod); | |
1413 | } | |
26e5eed7 | 1414 | |
e1ead237 CH |
1415 | if (start) { |
1416 | error = xfs_rtallocate_extent_near(&args, start, raminlen, | |
1417 | ralen, &ralen, prod, &rtx); | |
1418 | } else { | |
1419 | error = xfs_rtallocate_extent_size(&args, raminlen, | |
1420 | ralen, &ralen, prod, &rtx); | |
1421 | } | |
1422 | xfs_rtbuf_cache_relse(&args); | |
1423 | ||
db8616e2 CH |
1424 | if (error == -ENOSPC) { |
1425 | if (align > mp->m_sb.sb_rextsize) { | |
1426 | /* | |
1427 | * We previously enlarged the request length to try to | |
1428 | * satisfy an extent size hint. The allocator didn't | |
1429 | * return anything, so reset the parameters to the | |
1430 | * original values and try again without alignment | |
1431 | * criteria. | |
1432 | */ | |
1433 | ap->offset = orig_offset; | |
1434 | ap->length = orig_length; | |
1435 | minlen = align = mp->m_sb.sb_rextsize; | |
1436 | goto retry; | |
1437 | } | |
ce42b5d3 | 1438 | |
a3e48f68 | 1439 | if (!ignore_locality && start != 0) { |
db8616e2 CH |
1440 | /* |
1441 | * If we can't allocate near a specific rt extent, try | |
1442 | * again without locality criteria. | |
1443 | */ | |
1444 | ignore_locality = true; | |
1445 | goto retry; | |
1446 | } | |
152e2123 | 1447 | |
db8616e2 CH |
1448 | ap->blkno = NULLFSBLOCK; |
1449 | ap->length = 0; | |
1450 | return 0; | |
152e2123 | 1451 | } |
db8616e2 CH |
1452 | if (error) |
1453 | return error; | |
152e2123 | 1454 | |
e1ead237 CH |
1455 | xfs_trans_mod_sb(ap->tp, ap->wasdel ? |
1456 | XFS_TRANS_SB_RES_FREXTENTS : XFS_TRANS_SB_FREXTENTS, | |
1457 | -(long)ralen); | |
db8616e2 CH |
1458 | ap->blkno = xfs_rtx_to_rtb(mp, rtx); |
1459 | ap->length = xfs_rtxlen_to_extlen(mp, ralen); | |
1460 | xfs_bmap_alloc_account(ap); | |
152e2123 CH |
1461 | return 0; |
1462 | } |