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