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