fs/xfs/xfs_rtalloc.c

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