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