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_may_overflow(ip, XFS_DATA_FORK, 699 XFS_IEXT_ADD_NOSPLIT_CNT); 700 if (error == -EFBIG) 701 error = xfs_iext_count_upgrade(tp, ip, 702 XFS_IEXT_ADD_NOSPLIT_CNT); 703 if (error) 704 goto out_trans_cancel; 705 706 /* 707 * Allocate blocks to the bitmap file. 708 */ 709 nmap = 1; 710 error = xfs_bmapi_write(tp, ip, oblocks, nblocks - oblocks, 711 XFS_BMAPI_METADATA, 0, &map, &nmap); 712 if (!error && nmap < 1) 713 error = -ENOSPC; 714 if (error) 715 goto out_trans_cancel; 716 /* 717 * Free any blocks freed up in the transaction, then commit. 718 */ 719 error = xfs_trans_commit(tp); 720 if (error) 721 return error; 722 /* 723 * Now we need to clear the allocated blocks. 724 * Do this one block per transaction, to keep it simple. 725 */ 726 for (bno = map.br_startoff, fsbno = map.br_startblock; 727 bno < map.br_startoff + map.br_blockcount; 728 bno++, fsbno++) { 729 /* 730 * Reserve log for one block zeroing. 731 */ 732 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_growrtzero, 733 0, 0, 0, &tp); 734 if (error) 735 return error; 736 /* 737 * Lock the bitmap inode. 738 */ 739 xfs_ilock(ip, XFS_ILOCK_EXCL); 740 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL); 741 /* 742 * Get a buffer for the block. 743 */ 744 d = XFS_FSB_TO_DADDR(mp, fsbno); 745 error = xfs_trans_get_buf(tp, mp->m_ddev_targp, d, 746 mp->m_bsize, 0, &bp); 747 if (error) 748 goto out_trans_cancel; 749 750 xfs_trans_buf_set_type(tp, bp, buf_type); 751 bp->b_ops = &xfs_rtbuf_ops; 752 memset(bp->b_addr, 0, mp->m_sb.sb_blocksize); 753 xfs_trans_log_buf(tp, bp, 0, mp->m_sb.sb_blocksize - 1); 754 /* 755 * Commit the transaction. 756 */ 757 error = xfs_trans_commit(tp); 758 if (error) 759 return error; 760 } 761 /* 762 * Go on to the next extent, if any. 763 */ 764 oblocks = map.br_startoff + map.br_blockcount; 765 } 766 767 return 0; 768 769out_trans_cancel: 770 xfs_trans_cancel(tp); 771 return error; 772} 773 774static void 775xfs_alloc_rsum_cache( 776 xfs_mount_t *mp, /* file system mount structure */ 777 xfs_extlen_t rbmblocks) /* number of rt bitmap blocks */ 778{ 779 /* 780 * The rsum cache is initialized to the maximum value, which is 781 * trivially an upper bound on the maximum level with any free extents. 782 * We can continue without the cache if it couldn't be allocated. 783 */ 784 mp->m_rsum_cache = kvmalloc(rbmblocks, GFP_KERNEL); 785 if (mp->m_rsum_cache) 786 memset(mp->m_rsum_cache, -1, rbmblocks); 787 else 788 xfs_warn(mp, "could not allocate realtime summary cache"); 789} 790 791/* 792 * Visible (exported) functions. 793 */ 794 795/* 796 * Grow the realtime area of the filesystem. 797 */ 798int 799xfs_growfs_rt( 800 xfs_mount_t *mp, /* mount point for filesystem */ 801 xfs_growfs_rt_t *in) /* growfs rt input struct */ 802{ 803 xfs_fileoff_t bmbno; /* bitmap block number */ 804 struct xfs_buf *bp; /* temporary buffer */ 805 int error; /* error return value */ 806 xfs_mount_t *nmp; /* new (fake) mount structure */ 807 xfs_rfsblock_t nrblocks; /* new number of realtime blocks */ 808 xfs_extlen_t nrbmblocks; /* new number of rt bitmap blocks */ 809 xfs_rtxnum_t nrextents; /* new number of realtime extents */ 810 uint8_t nrextslog; /* new log2 of sb_rextents */ 811 xfs_extlen_t nrsumblocks; /* new number of summary blocks */ 812 uint nrsumlevels; /* new rt summary levels */ 813 uint nrsumsize; /* new size of rt summary, bytes */ 814 xfs_sb_t *nsbp; /* new superblock */ 815 xfs_extlen_t rbmblocks; /* current number of rt bitmap blocks */ 816 xfs_extlen_t rsumblocks; /* current number of rt summary blks */ 817 xfs_sb_t *sbp; /* old superblock */ 818 uint8_t *rsum_cache; /* old summary cache */ 819 820 sbp = &mp->m_sb; 821 822 if (!capable(CAP_SYS_ADMIN)) 823 return -EPERM; 824 825 /* Needs to have been mounted with an rt device. */ 826 if (!XFS_IS_REALTIME_MOUNT(mp)) 827 return -EINVAL; 828 /* 829 * Mount should fail if the rt bitmap/summary files don't load, but 830 * we'll check anyway. 831 */ 832 if (!mp->m_rbmip || !mp->m_rsumip) 833 return -EINVAL; 834 835 /* Shrink not supported. */ 836 if (in->newblocks <= sbp->sb_rblocks) 837 return -EINVAL; 838 839 /* Can only change rt extent size when adding rt volume. */ 840 if (sbp->sb_rblocks > 0 && in->extsize != sbp->sb_rextsize) 841 return -EINVAL; 842 843 /* Range check the extent size. */ 844 if (XFS_FSB_TO_B(mp, in->extsize) > XFS_MAX_RTEXTSIZE || 845 XFS_FSB_TO_B(mp, in->extsize) < XFS_MIN_RTEXTSIZE) 846 return -EINVAL; 847 848 /* Unsupported realtime features. */ 849 if (xfs_has_rmapbt(mp) || xfs_has_reflink(mp) || xfs_has_quota(mp)) 850 return -EOPNOTSUPP; 851 852 nrblocks = in->newblocks; 853 error = xfs_sb_validate_fsb_count(sbp, nrblocks); 854 if (error) 855 return error; 856 /* 857 * Read in the last block of the device, make sure it exists. 858 */ 859 error = xfs_buf_read_uncached(mp->m_rtdev_targp, 860 XFS_FSB_TO_BB(mp, nrblocks - 1), 861 XFS_FSB_TO_BB(mp, 1), 0, &bp, NULL); 862 if (error) 863 return error; 864 xfs_buf_relse(bp); 865 866 /* 867 * Calculate new parameters. These are the final values to be reached. 868 */ 869 nrextents = nrblocks; 870 do_div(nrextents, in->extsize); 871 if (!xfs_validate_rtextents(nrextents)) 872 return -EINVAL; 873 nrbmblocks = xfs_rtbitmap_blockcount(mp, nrextents); 874 nrextslog = xfs_compute_rextslog(nrextents); 875 nrsumlevels = nrextslog + 1; 876 nrsumblocks = xfs_rtsummary_blockcount(mp, nrsumlevels, nrbmblocks); 877 nrsumsize = XFS_FSB_TO_B(mp, nrsumblocks); 878 /* 879 * New summary size can't be more than half the size of 880 * the log. This prevents us from getting a log overflow, 881 * since we'll log basically the whole summary file at once. 882 */ 883 if (nrsumblocks > (mp->m_sb.sb_logblocks >> 1)) 884 return -EINVAL; 885 /* 886 * Get the old block counts for bitmap and summary inodes. 887 * These can't change since other growfs callers are locked out. 888 */ 889 rbmblocks = XFS_B_TO_FSB(mp, mp->m_rbmip->i_disk_size); 890 rsumblocks = XFS_B_TO_FSB(mp, mp->m_rsumip->i_disk_size); 891 /* 892 * Allocate space to the bitmap and summary files, as necessary. 893 */ 894 error = xfs_growfs_rt_alloc(mp, rbmblocks, nrbmblocks, mp->m_rbmip); 895 if (error) 896 return error; 897 error = xfs_growfs_rt_alloc(mp, rsumblocks, nrsumblocks, mp->m_rsumip); 898 if (error) 899 return error; 900 901 rsum_cache = mp->m_rsum_cache; 902 if (nrbmblocks != sbp->sb_rbmblocks) 903 xfs_alloc_rsum_cache(mp, nrbmblocks); 904 905 /* 906 * Allocate a new (fake) mount/sb. 907 */ 908 nmp = kmalloc(sizeof(*nmp), GFP_KERNEL | __GFP_NOFAIL); 909 /* 910 * Loop over the bitmap blocks. 911 * We will do everything one bitmap block at a time. 912 * Skip the current block if it is exactly full. 913 * This also deals with the case where there were no rtextents before. 914 */ 915 for (bmbno = sbp->sb_rbmblocks - 916 ((sbp->sb_rextents & ((1 << mp->m_blkbit_log) - 1)) != 0); 917 bmbno < nrbmblocks; 918 bmbno++) { 919 struct xfs_rtalloc_args args = { 920 .mp = mp, 921 }; 922 struct xfs_rtalloc_args nargs = { 923 .mp = nmp, 924 }; 925 struct xfs_trans *tp; 926 xfs_rfsblock_t nrblocks_step; 927 928 *nmp = *mp; 929 nsbp = &nmp->m_sb; 930 /* 931 * Calculate new sb and mount fields for this round. 932 */ 933 nsbp->sb_rextsize = in->extsize; 934 nmp->m_rtxblklog = -1; /* don't use shift or masking */ 935 nsbp->sb_rbmblocks = bmbno + 1; 936 nrblocks_step = (bmbno + 1) * NBBY * nsbp->sb_blocksize * 937 nsbp->sb_rextsize; 938 nsbp->sb_rblocks = min(nrblocks, nrblocks_step); 939 nsbp->sb_rextents = xfs_rtb_to_rtx(nmp, nsbp->sb_rblocks); 940 ASSERT(nsbp->sb_rextents != 0); 941 nsbp->sb_rextslog = xfs_compute_rextslog(nsbp->sb_rextents); 942 nrsumlevels = nmp->m_rsumlevels = nsbp->sb_rextslog + 1; 943 nrsumblocks = xfs_rtsummary_blockcount(mp, nrsumlevels, 944 nsbp->sb_rbmblocks); 945 nmp->m_rsumsize = nrsumsize = XFS_FSB_TO_B(mp, nrsumblocks); 946 /* recompute growfsrt reservation from new rsumsize */ 947 xfs_trans_resv_calc(nmp, &nmp->m_resv); 948 949 /* 950 * Start a transaction, get the log reservation. 951 */ 952 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_growrtfree, 0, 0, 0, 953 &tp); 954 if (error) 955 break; 956 args.tp = tp; 957 nargs.tp = tp; 958 959 /* 960 * Lock out other callers by grabbing the bitmap inode lock. 961 */ 962 xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL | XFS_ILOCK_RTBITMAP); 963 xfs_trans_ijoin(tp, mp->m_rbmip, XFS_ILOCK_EXCL); 964 /* 965 * Update the bitmap inode's size ondisk and incore. We need 966 * to update the incore size so that inode inactivation won't 967 * punch what it thinks are "posteof" blocks. 968 */ 969 mp->m_rbmip->i_disk_size = 970 nsbp->sb_rbmblocks * nsbp->sb_blocksize; 971 i_size_write(VFS_I(mp->m_rbmip), mp->m_rbmip->i_disk_size); 972 xfs_trans_log_inode(tp, mp->m_rbmip, XFS_ILOG_CORE); 973 /* 974 * Get the summary inode into the transaction. 975 */ 976 xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL | XFS_ILOCK_RTSUM); 977 xfs_trans_ijoin(tp, mp->m_rsumip, XFS_ILOCK_EXCL); 978 /* 979 * Update the summary inode's size. We need to update the 980 * incore size so that inode inactivation won't punch what it 981 * thinks are "posteof" blocks. 982 */ 983 mp->m_rsumip->i_disk_size = nmp->m_rsumsize; 984 i_size_write(VFS_I(mp->m_rsumip), mp->m_rsumip->i_disk_size); 985 xfs_trans_log_inode(tp, mp->m_rsumip, XFS_ILOG_CORE); 986 /* 987 * Copy summary data from old to new sizes. 988 * Do this when the real size (not block-aligned) changes. 989 */ 990 if (sbp->sb_rbmblocks != nsbp->sb_rbmblocks || 991 mp->m_rsumlevels != nmp->m_rsumlevels) { 992 error = xfs_rtcopy_summary(&args, &nargs); 993 if (error) 994 goto error_cancel; 995 } 996 /* 997 * Update superblock fields. 998 */ 999 if (nsbp->sb_rextsize != sbp->sb_rextsize) 1000 xfs_trans_mod_sb(tp, XFS_TRANS_SB_REXTSIZE, 1001 nsbp->sb_rextsize - sbp->sb_rextsize); 1002 if (nsbp->sb_rbmblocks != sbp->sb_rbmblocks) 1003 xfs_trans_mod_sb(tp, XFS_TRANS_SB_RBMBLOCKS, 1004 nsbp->sb_rbmblocks - sbp->sb_rbmblocks); 1005 if (nsbp->sb_rblocks != sbp->sb_rblocks) 1006 xfs_trans_mod_sb(tp, XFS_TRANS_SB_RBLOCKS, 1007 nsbp->sb_rblocks - sbp->sb_rblocks); 1008 if (nsbp->sb_rextents != sbp->sb_rextents) 1009 xfs_trans_mod_sb(tp, XFS_TRANS_SB_REXTENTS, 1010 nsbp->sb_rextents - sbp->sb_rextents); 1011 if (nsbp->sb_rextslog != sbp->sb_rextslog) 1012 xfs_trans_mod_sb(tp, XFS_TRANS_SB_REXTSLOG, 1013 nsbp->sb_rextslog - sbp->sb_rextslog); 1014 /* 1015 * Free new extent. 1016 */ 1017 error = xfs_rtfree_range(&nargs, sbp->sb_rextents, 1018 nsbp->sb_rextents - sbp->sb_rextents); 1019 xfs_rtbuf_cache_relse(&nargs); 1020 if (error) { 1021error_cancel: 1022 xfs_trans_cancel(tp); 1023 break; 1024 } 1025 /* 1026 * Mark more blocks free in the superblock. 1027 */ 1028 xfs_trans_mod_sb(tp, XFS_TRANS_SB_FREXTENTS, 1029 nsbp->sb_rextents - sbp->sb_rextents); 1030 /* 1031 * Update mp values into the real mp structure. 1032 */ 1033 mp->m_rsumlevels = nrsumlevels; 1034 mp->m_rsumsize = nrsumsize; 1035 /* recompute growfsrt reservation from new rsumsize */ 1036 xfs_trans_resv_calc(mp, &mp->m_resv); 1037 1038 error = xfs_trans_commit(tp); 1039 if (error) 1040 break; 1041 1042 /* Ensure the mount RT feature flag is now set. */ 1043 mp->m_features |= XFS_FEAT_REALTIME; 1044 } 1045 if (error) 1046 goto out_free; 1047 1048 /* Update secondary superblocks now the physical grow has completed */ 1049 error = xfs_update_secondary_sbs(mp); 1050 1051out_free: 1052 /* 1053 * Free the fake mp structure. 1054 */ 1055 kfree(nmp); 1056 1057 /* 1058 * If we had to allocate a new rsum_cache, we either need to free the 1059 * old one (if we succeeded) or free the new one and restore the old one 1060 * (if there was an error). 1061 */ 1062 if (rsum_cache != mp->m_rsum_cache) { 1063 if (error) { 1064 kvfree(mp->m_rsum_cache); 1065 mp->m_rsum_cache = rsum_cache; 1066 } else { 1067 kvfree(rsum_cache); 1068 } 1069 } 1070 1071 return error; 1072} 1073 1074/* 1075 * Initialize realtime fields in the mount structure. 1076 */ 1077int /* error */ 1078xfs_rtmount_init( 1079 struct xfs_mount *mp) /* file system mount structure */ 1080{ 1081 struct xfs_buf *bp; /* buffer for last block of subvolume */ 1082 struct xfs_sb *sbp; /* filesystem superblock copy in mount */ 1083 xfs_daddr_t d; /* address of last block of subvolume */ 1084 unsigned int rsumblocks; 1085 int error; 1086 1087 sbp = &mp->m_sb; 1088 if (sbp->sb_rblocks == 0) 1089 return 0; 1090 if (mp->m_rtdev_targp == NULL) { 1091 xfs_warn(mp, 1092 "Filesystem has a realtime volume, use rtdev=device option"); 1093 return -ENODEV; 1094 } 1095 mp->m_rsumlevels = sbp->sb_rextslog + 1; 1096 rsumblocks = xfs_rtsummary_blockcount(mp, mp->m_rsumlevels, 1097 mp->m_sb.sb_rbmblocks); 1098 mp->m_rsumsize = XFS_FSB_TO_B(mp, rsumblocks); 1099 mp->m_rbmip = mp->m_rsumip = NULL; 1100 /* 1101 * Check that the realtime section is an ok size. 1102 */ 1103 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_rblocks); 1104 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_rblocks) { 1105 xfs_warn(mp, "realtime mount -- %llu != %llu", 1106 (unsigned long long) XFS_BB_TO_FSB(mp, d), 1107 (unsigned long long) mp->m_sb.sb_rblocks); 1108 return -EFBIG; 1109 } 1110 error = xfs_buf_read_uncached(mp->m_rtdev_targp, 1111 d - XFS_FSB_TO_BB(mp, 1), 1112 XFS_FSB_TO_BB(mp, 1), 0, &bp, NULL); 1113 if (error) { 1114 xfs_warn(mp, "realtime device size check failed"); 1115 return error; 1116 } 1117 xfs_buf_relse(bp); 1118 return 0; 1119} 1120 1121static int 1122xfs_rtalloc_count_frextent( 1123 struct xfs_mount *mp, 1124 struct xfs_trans *tp, 1125 const struct xfs_rtalloc_rec *rec, 1126 void *priv) 1127{ 1128 uint64_t *valp = priv; 1129 1130 *valp += rec->ar_extcount; 1131 return 0; 1132} 1133 1134/* 1135 * Reinitialize the number of free realtime extents from the realtime bitmap. 1136 * Callers must ensure that there is no other activity in the filesystem. 1137 */ 1138int 1139xfs_rtalloc_reinit_frextents( 1140 struct xfs_mount *mp) 1141{ 1142 uint64_t val = 0; 1143 int error; 1144 1145 xfs_ilock(mp->m_rbmip, XFS_ILOCK_SHARED | XFS_ILOCK_RTBITMAP); 1146 error = xfs_rtalloc_query_all(mp, NULL, xfs_rtalloc_count_frextent, 1147 &val); 1148 xfs_iunlock(mp->m_rbmip, XFS_ILOCK_SHARED | XFS_ILOCK_RTBITMAP); 1149 if (error) 1150 return error; 1151 1152 spin_lock(&mp->m_sb_lock); 1153 mp->m_sb.sb_frextents = val; 1154 spin_unlock(&mp->m_sb_lock); 1155 percpu_counter_set(&mp->m_frextents, mp->m_sb.sb_frextents); 1156 return 0; 1157} 1158 1159/* 1160 * Read in the bmbt of an rt metadata inode so that we never have to load them 1161 * at runtime. This enables the use of shared ILOCKs for rtbitmap scans. Use 1162 * an empty transaction to avoid deadlocking on loops in the bmbt. 1163 */ 1164static inline int 1165xfs_rtmount_iread_extents( 1166 struct xfs_inode *ip, 1167 unsigned int lock_class) 1168{ 1169 struct xfs_trans *tp; 1170 int error; 1171 1172 error = xfs_trans_alloc_empty(ip->i_mount, &tp); 1173 if (error) 1174 return error; 1175 1176 xfs_ilock(ip, XFS_ILOCK_EXCL | lock_class); 1177 1178 error = xfs_iread_extents(tp, ip, XFS_DATA_FORK); 1179 if (error) 1180 goto out_unlock; 1181 1182 if (xfs_inode_has_attr_fork(ip)) { 1183 error = xfs_iread_extents(tp, ip, XFS_ATTR_FORK); 1184 if (error) 1185 goto out_unlock; 1186 } 1187 1188out_unlock: 1189 xfs_iunlock(ip, XFS_ILOCK_EXCL | lock_class); 1190 xfs_trans_cancel(tp); 1191 return error; 1192} 1193 1194/* 1195 * Get the bitmap and summary inodes and the summary cache into the mount 1196 * structure at mount time. 1197 */ 1198int /* error */ 1199xfs_rtmount_inodes( 1200 xfs_mount_t *mp) /* file system mount structure */ 1201{ 1202 int error; /* error return value */ 1203 xfs_sb_t *sbp; 1204 1205 sbp = &mp->m_sb; 1206 error = xfs_iget(mp, NULL, sbp->sb_rbmino, 0, 0, &mp->m_rbmip); 1207 if (xfs_metadata_is_sick(error)) 1208 xfs_rt_mark_sick(mp, XFS_SICK_RT_BITMAP); 1209 if (error) 1210 return error; 1211 ASSERT(mp->m_rbmip != NULL); 1212 1213 error = xfs_rtmount_iread_extents(mp->m_rbmip, XFS_ILOCK_RTBITMAP); 1214 if (error) 1215 goto out_rele_bitmap; 1216 1217 error = xfs_iget(mp, NULL, sbp->sb_rsumino, 0, 0, &mp->m_rsumip); 1218 if (xfs_metadata_is_sick(error)) 1219 xfs_rt_mark_sick(mp, XFS_SICK_RT_SUMMARY); 1220 if (error) 1221 goto out_rele_bitmap; 1222 ASSERT(mp->m_rsumip != NULL); 1223 1224 error = xfs_rtmount_iread_extents(mp->m_rsumip, XFS_ILOCK_RTSUM); 1225 if (error) 1226 goto out_rele_summary; 1227 1228 xfs_alloc_rsum_cache(mp, sbp->sb_rbmblocks); 1229 return 0; 1230 1231out_rele_summary: 1232 xfs_irele(mp->m_rsumip); 1233out_rele_bitmap: 1234 xfs_irele(mp->m_rbmip); 1235 return error; 1236} 1237 1238void 1239xfs_rtunmount_inodes( 1240 struct xfs_mount *mp) 1241{ 1242 kvfree(mp->m_rsum_cache); 1243 if (mp->m_rbmip) 1244 xfs_irele(mp->m_rbmip); 1245 if (mp->m_rsumip) 1246 xfs_irele(mp->m_rsumip); 1247} 1248 1249/* 1250 * Pick an extent for allocation at the start of a new realtime file. 1251 * Use the sequence number stored in the atime field of the bitmap inode. 1252 * Translate this to a fraction of the rtextents, and return the product 1253 * of rtextents and the fraction. 1254 * The fraction sequence is 0, 1/2, 1/4, 3/4, 1/8, ..., 7/8, 1/16, ... 1255 */ 1256static int 1257xfs_rtpick_extent( 1258 xfs_mount_t *mp, /* file system mount point */ 1259 xfs_trans_t *tp, /* transaction pointer */ 1260 xfs_rtxlen_t len, /* allocation length (rtextents) */ 1261 xfs_rtxnum_t *pick) /* result rt extent */ 1262{ 1263 xfs_rtxnum_t b; /* result rtext */ 1264 int log2; /* log of sequence number */ 1265 uint64_t resid; /* residual after log removed */ 1266 uint64_t seq; /* sequence number of file creation */ 1267 struct timespec64 ts; /* timespec in inode */ 1268 1269 xfs_assert_ilocked(mp->m_rbmip, XFS_ILOCK_EXCL); 1270 1271 ts = inode_get_atime(VFS_I(mp->m_rbmip)); 1272 if (!(mp->m_rbmip->i_diflags & XFS_DIFLAG_NEWRTBM)) { 1273 mp->m_rbmip->i_diflags |= XFS_DIFLAG_NEWRTBM; 1274 seq = 0; 1275 } else { 1276 seq = ts.tv_sec; 1277 } 1278 if ((log2 = xfs_highbit64(seq)) == -1) 1279 b = 0; 1280 else { 1281 resid = seq - (1ULL << log2); 1282 b = (mp->m_sb.sb_rextents * ((resid << 1) + 1ULL)) >> 1283 (log2 + 1); 1284 if (b >= mp->m_sb.sb_rextents) 1285 div64_u64_rem(b, mp->m_sb.sb_rextents, &b); 1286 if (b + len > mp->m_sb.sb_rextents) 1287 b = mp->m_sb.sb_rextents - len; 1288 } 1289 ts.tv_sec = seq + 1; 1290 inode_set_atime_to_ts(VFS_I(mp->m_rbmip), ts); 1291 xfs_trans_log_inode(tp, mp->m_rbmip, XFS_ILOG_CORE); 1292 *pick = b; 1293 return 0; 1294} 1295 1296static void 1297xfs_rtalloc_align_minmax( 1298 xfs_rtxlen_t *raminlen, 1299 xfs_rtxlen_t *ramaxlen, 1300 xfs_rtxlen_t *prod) 1301{ 1302 xfs_rtxlen_t newmaxlen = *ramaxlen; 1303 xfs_rtxlen_t newminlen = *raminlen; 1304 xfs_rtxlen_t slack; 1305 1306 slack = newmaxlen % *prod; 1307 if (slack) 1308 newmaxlen -= slack; 1309 slack = newminlen % *prod; 1310 if (slack) 1311 newminlen += *prod - slack; 1312 1313 /* 1314 * If adjusting for extent size hint alignment produces an invalid 1315 * min/max len combination, go ahead without it. 1316 */ 1317 if (newmaxlen < newminlen) { 1318 *prod = 1; 1319 return; 1320 } 1321 *ramaxlen = newmaxlen; 1322 *raminlen = newminlen; 1323} 1324 1325int 1326xfs_bmap_rtalloc( 1327 struct xfs_bmalloca *ap) 1328{ 1329 struct xfs_mount *mp = ap->ip->i_mount; 1330 xfs_fileoff_t orig_offset = ap->offset; 1331 xfs_rtxnum_t start; /* allocation hint rtextent no */ 1332 xfs_rtxnum_t rtx; /* actually allocated rtextent no */ 1333 xfs_rtxlen_t prod = 0; /* product factor for allocators */ 1334 xfs_extlen_t mod = 0; /* product factor for allocators */ 1335 xfs_rtxlen_t ralen = 0; /* realtime allocation length */ 1336 xfs_extlen_t align; /* minimum allocation alignment */ 1337 xfs_extlen_t orig_length = ap->length; 1338 xfs_extlen_t minlen = mp->m_sb.sb_rextsize; 1339 xfs_rtxlen_t raminlen; 1340 bool rtlocked = false; 1341 bool ignore_locality = false; 1342 struct xfs_rtalloc_args args = { 1343 .mp = mp, 1344 .tp = ap->tp, 1345 }; 1346 int error; 1347 1348 align = xfs_get_extsz_hint(ap->ip); 1349retry: 1350 error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev, 1351 align, 1, ap->eof, 0, 1352 ap->conv, &ap->offset, &ap->length); 1353 if (error) 1354 return error; 1355 ASSERT(ap->length); 1356 ASSERT(xfs_extlen_to_rtxmod(mp, ap->length) == 0); 1357 1358 /* 1359 * If we shifted the file offset downward to satisfy an extent size 1360 * hint, increase minlen by that amount so that the allocator won't 1361 * give us an allocation that's too short to cover at least one of the 1362 * blocks that the caller asked for. 1363 */ 1364 if (ap->offset != orig_offset) 1365 minlen += orig_offset - ap->offset; 1366 1367 /* 1368 * Set ralen to be the actual requested length in rtextents. 1369 * 1370 * If the old value was close enough to XFS_BMBT_MAX_EXTLEN that 1371 * we rounded up to it, cut it back so it's valid again. 1372 * Note that if it's a really large request (bigger than 1373 * XFS_BMBT_MAX_EXTLEN), we don't hear about that number, and can't 1374 * adjust the starting point to match it. 1375 */ 1376 ralen = xfs_extlen_to_rtxlen(mp, min(ap->length, XFS_MAX_BMBT_EXTLEN)); 1377 raminlen = max_t(xfs_rtxlen_t, 1, xfs_extlen_to_rtxlen(mp, minlen)); 1378 ASSERT(raminlen > 0); 1379 ASSERT(raminlen <= ralen); 1380 1381 /* 1382 * Lock out modifications to both the RT bitmap and summary inodes 1383 */ 1384 if (!rtlocked) { 1385 xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL|XFS_ILOCK_RTBITMAP); 1386 xfs_trans_ijoin(ap->tp, mp->m_rbmip, XFS_ILOCK_EXCL); 1387 xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL|XFS_ILOCK_RTSUM); 1388 xfs_trans_ijoin(ap->tp, mp->m_rsumip, XFS_ILOCK_EXCL); 1389 rtlocked = true; 1390 } 1391 1392 if (ignore_locality) { 1393 start = 0; 1394 } else if (xfs_bmap_adjacent(ap)) { 1395 start = xfs_rtb_to_rtx(mp, ap->blkno); 1396 } else if (ap->eof && ap->offset == 0) { 1397 /* 1398 * If it's an allocation to an empty file at offset 0, pick an 1399 * extent that will space things out in the rt area. 1400 */ 1401 error = xfs_rtpick_extent(mp, ap->tp, ralen, &start); 1402 if (error) 1403 return error; 1404 } else { 1405 start = 0; 1406 } 1407 1408 /* 1409 * Only bother calculating a real prod factor if offset & length are 1410 * perfectly aligned, otherwise it will just get us in trouble. 1411 */ 1412 div_u64_rem(ap->offset, align, &mod); 1413 if (mod || ap->length % align) { 1414 prod = 1; 1415 } else { 1416 prod = xfs_extlen_to_rtxlen(mp, align); 1417 if (prod > 1) 1418 xfs_rtalloc_align_minmax(&raminlen, &ralen, &prod); 1419 } 1420 1421 if (start) { 1422 error = xfs_rtallocate_extent_near(&args, start, raminlen, 1423 ralen, &ralen, prod, &rtx); 1424 } else { 1425 error = xfs_rtallocate_extent_size(&args, raminlen, 1426 ralen, &ralen, prod, &rtx); 1427 } 1428 xfs_rtbuf_cache_relse(&args); 1429 1430 if (error == -ENOSPC) { 1431 if (align > mp->m_sb.sb_rextsize) { 1432 /* 1433 * We previously enlarged the request length to try to 1434 * satisfy an extent size hint. The allocator didn't 1435 * return anything, so reset the parameters to the 1436 * original values and try again without alignment 1437 * criteria. 1438 */ 1439 ap->offset = orig_offset; 1440 ap->length = orig_length; 1441 minlen = align = mp->m_sb.sb_rextsize; 1442 goto retry; 1443 } 1444 1445 if (!ignore_locality && start != 0) { 1446 /* 1447 * If we can't allocate near a specific rt extent, try 1448 * again without locality criteria. 1449 */ 1450 ignore_locality = true; 1451 goto retry; 1452 } 1453 1454 ap->blkno = NULLFSBLOCK; 1455 ap->length = 0; 1456 return 0; 1457 } 1458 if (error) 1459 return error; 1460 1461 xfs_trans_mod_sb(ap->tp, ap->wasdel ? 1462 XFS_TRANS_SB_RES_FREXTENTS : XFS_TRANS_SB_FREXTENTS, 1463 -(long)ralen); 1464 ap->blkno = xfs_rtx_to_rtb(mp, rtx); 1465 ap->length = xfs_rtxlen_to_extlen(mp, ralen); 1466 xfs_bmap_alloc_account(ap); 1467 return 0; 1468} 1469