fs/xfs/libxfs/xfs_rtbitmap.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_trans.h"
  17 #include "xfs_rtalloc.h"
  18 #include "xfs_error.h"
  19 #include "xfs_rtbitmap.h"
  20
  21 /*
  22  * Realtime allocator bitmap functions shared with userspace.
  23  */
  24
  25 /*
  26  * Real time buffers need verifiers to avoid runtime warnings during IO.
  27  * We don't have anything to verify, however, so these are just dummy
  28  * operations.
  29  */
  30 static void
  31 xfs_rtbuf_verify_read(
  32         struct xfs_buf  *bp)
  33 {
  34         return;
  35 }
  36
  37 static void
  38 xfs_rtbuf_verify_write(
  39         struct xfs_buf  *bp)
  40 {
  41         return;
  42 }
  43
  44 const struct xfs_buf_ops xfs_rtbuf_ops = {
  45         .name = "rtbuf",
  46         .verify_read = xfs_rtbuf_verify_read,
  47         .verify_write = xfs_rtbuf_verify_write,
  48 };
  49
  50 /* Release cached rt bitmap and summary buffers. */
  51 void
  52 xfs_rtbuf_cache_relse(
  53         struct xfs_rtalloc_args *args)
  54 {
  55         if (args->rbmbp) {
  56                 xfs_trans_brelse(args->tp, args->rbmbp);
  57                 args->rbmbp = NULL;
  58                 args->rbmoff = NULLFILEOFF;
  59         }
  60         if (args->sumbp) {
  61                 xfs_trans_brelse(args->tp, args->sumbp);
  62                 args->sumbp = NULL;
  63                 args->sumoff = NULLFILEOFF;
  64         }
  65 }
  66
  67 /*
  68  * Get a buffer for the bitmap or summary file block specified.
  69  * The buffer is returned read and locked.
  70  */
  71 int
  72 xfs_rtbuf_get(
  73         struct xfs_rtalloc_args *args,
  74         xfs_fileoff_t           block,  /* block number in bitmap or summary */
  75         int                     issum)  /* is summary not bitmap */
  76 {
  77         struct xfs_mount        *mp = args->mp;
  78         struct xfs_buf          **cbpp; /* cached block buffer */
  79         xfs_fileoff_t           *coffp; /* cached block number */
  80         struct xfs_buf          *bp;    /* block buffer, result */
  81         struct xfs_inode        *ip;    /* bitmap or summary inode */
  82         struct xfs_bmbt_irec    map;
  83         enum xfs_blft           type;
  84         int                     nmap = 1;
  85         int                     error;
  86
  87         if (issum) {
  88                 cbpp = &args->sumbp;
  89                 coffp = &args->sumoff;
  90                 ip = mp->m_rsumip;
  91                 type = XFS_BLFT_RTSUMMARY_BUF;
  92         } else {
  93                 cbpp = &args->rbmbp;
  94                 coffp = &args->rbmoff;
  95                 ip = mp->m_rbmip;
  96                 type = XFS_BLFT_RTBITMAP_BUF;
  97         }
  98
  99         /*
 100          * If we have a cached buffer, and the block number matches, use that.
 101          */
 102         if (*cbpp && *coffp == block)
 103                 return 0;
 104
 105         /*
 106          * Otherwise we have to have to get the buffer.  If there was an old
 107          * one, get rid of it first.
 108          */
 109         if (*cbpp) {
 110                 xfs_trans_brelse(args->tp, *cbpp);
 111                 *cbpp = NULL;
 112         }
 113
 114         error = xfs_bmapi_read(ip, block, 1, &map, &nmap, 0);
 115         if (error)
 116                 return error;
 117
 118         if (XFS_IS_CORRUPT(mp, nmap == 0 || !xfs_bmap_is_written_extent(&map)))
 119                 return -EFSCORRUPTED;
 120
 121         ASSERT(map.br_startblock != NULLFSBLOCK);
 122         error = xfs_trans_read_buf(mp, args->tp, mp->m_ddev_targp,
 123                                    XFS_FSB_TO_DADDR(mp, map.br_startblock),
 124                                    mp->m_bsize, 0, &bp, &xfs_rtbuf_ops);
 125         if (error)
 126                 return error;
 127
 128         xfs_trans_buf_set_type(args->tp, bp, type);
 129         *cbpp = bp;
 130         *coffp = block;
 131         return 0;
 132 }
 133
 134 /*
 135  * Searching backward from start to limit, find the first block whose
 136  * allocated/free state is different from start's.
 137  */
 138 int
 139 xfs_rtfind_back(
 140         struct xfs_rtalloc_args *args,
 141         xfs_rtxnum_t            start,  /* starting rtext to look at */
 142         xfs_rtxnum_t            limit,  /* last rtext to look at */
 143         xfs_rtxnum_t            *rtx)   /* out: start rtext found */
 144 {
 145         struct xfs_mount        *mp = args->mp;
 146         int                     bit;    /* bit number in the word */
 147         xfs_fileoff_t           block;  /* bitmap block number */
 148         int                     error;  /* error value */
 149         xfs_rtxnum_t            firstbit; /* first useful bit in the word */
 150         xfs_rtxnum_t            i;      /* current bit number rel. to start */
 151         xfs_rtxnum_t            len;    /* length of inspected area */
 152         xfs_rtword_t            mask;   /* mask of relevant bits for value */
 153         xfs_rtword_t            want;   /* mask for "good" values */
 154         xfs_rtword_t            wdiff;  /* difference from wanted value */
 155         xfs_rtword_t            incore;
 156         unsigned int            word;   /* word number in the buffer */
 157
 158         /*
 159          * Compute and read in starting bitmap block for starting block.
 160          */
 161         block = xfs_rtx_to_rbmblock(mp, start);
 162         error = xfs_rtbitmap_read_buf(args, block);
 163         if (error)
 164                 return error;
 165
 166         /*
 167          * Get the first word's index & point to it.
 168          */
 169         word = xfs_rtx_to_rbmword(mp, start);
 170         bit = (int)(start & (XFS_NBWORD - 1));
 171         len = start - limit + 1;
 172         /*
 173          * Compute match value, based on the bit at start: if 1 (free)
 174          * then all-ones, else all-zeroes.
 175          */
 176         incore = xfs_rtbitmap_getword(args, word);
 177         want = (incore & ((xfs_rtword_t)1 << bit)) ? -1 : 0;
 178         /*
 179          * If the starting position is not word-aligned, deal with the
 180          * partial word.
 181          */
 182         if (bit < XFS_NBWORD - 1) {
 183                 /*
 184                  * Calculate first (leftmost) bit number to look at,
 185                  * and mask for all the relevant bits in this word.
 186                  */
 187                 firstbit = max_t(xfs_srtblock_t, bit - len + 1, 0);
 188                 mask = (((xfs_rtword_t)1 << (bit - firstbit + 1)) - 1) <<
 189                         firstbit;
 190                 /*
 191                  * Calculate the difference between the value there
 192                  * and what we're looking for.
 193                  */
 194                 if ((wdiff = (incore ^ want) & mask)) {
 195                         /*
 196                          * Different.  Mark where we are and return.
 197                          */
 198                         i = bit - xfs_highbit32(wdiff);
 199                         *rtx = start - i + 1;
 200                         return 0;
 201                 }
 202                 i = bit - firstbit + 1;
 203                 /*
 204                  * Go on to previous block if that's where the previous word is
 205                  * and we need the previous word.
 206                  */
 207                 if (--word == -1 && i < len) {
 208                         /*
 209                          * If done with this block, get the previous one.
 210                          */
 211                         error = xfs_rtbitmap_read_buf(args, --block);
 212                         if (error)
 213                                 return error;
 214
 215                         word = mp->m_blockwsize - 1;
 216                 }
 217         } else {
 218                 /*
 219                  * Starting on a word boundary, no partial word.
 220                  */
 221                 i = 0;
 222         }
 223         /*
 224          * Loop over whole words in buffers.  When we use up one buffer
 225          * we move on to the previous one.
 226          */
 227         while (len - i >= XFS_NBWORD) {
 228                 /*
 229                  * Compute difference between actual and desired value.
 230                  */
 231                 incore = xfs_rtbitmap_getword(args, word);
 232                 if ((wdiff = incore ^ want)) {
 233                         /*
 234                          * Different, mark where we are and return.
 235                          */
 236                         i += XFS_NBWORD - 1 - xfs_highbit32(wdiff);
 237                         *rtx = start - i + 1;
 238                         return 0;
 239                 }
 240                 i += XFS_NBWORD;
 241                 /*
 242                  * Go on to previous block if that's where the previous word is
 243                  * and we need the previous word.
 244                  */
 245                 if (--word == -1 && i < len) {
 246                         /*
 247                          * If done with this block, get the previous one.
 248                          */
 249                         error = xfs_rtbitmap_read_buf(args, --block);
 250                         if (error)
 251                                 return error;
 252
 253                         word = mp->m_blockwsize - 1;
 254                 }
 255         }
 256         /*
 257          * If not ending on a word boundary, deal with the last
 258          * (partial) word.
 259          */
 260         if (len - i) {
 261                 /*
 262                  * Calculate first (leftmost) bit number to look at,
 263                  * and mask for all the relevant bits in this word.
 264                  */
 265                 firstbit = XFS_NBWORD - (len - i);
 266                 mask = (((xfs_rtword_t)1 << (len - i)) - 1) << firstbit;
 267                 /*
 268                  * Compute difference between actual and desired value.
 269                  */
 270                 incore = xfs_rtbitmap_getword(args, word);
 271                 if ((wdiff = (incore ^ want) & mask)) {
 272                         /*
 273                          * Different, mark where we are and return.
 274                          */
 275                         i += XFS_NBWORD - 1 - xfs_highbit32(wdiff);
 276                         *rtx = start - i + 1;
 277                         return 0;
 278                 } else
 279                         i = len;
 280         }
 281         /*
 282          * No match, return that we scanned the whole area.
 283          */
 284         *rtx = start - i + 1;
 285         return 0;
 286 }
 287
 288 /*
 289  * Searching forward from start to limit, find the first block whose
 290  * allocated/free state is different from start's.
 291  */
 292 int
 293 xfs_rtfind_forw(
 294         struct xfs_rtalloc_args *args,
 295         xfs_rtxnum_t            start,  /* starting rtext to look at */
 296         xfs_rtxnum_t            limit,  /* last rtext to look at */
 297         xfs_rtxnum_t            *rtx)   /* out: start rtext found */
 298 {
 299         struct xfs_mount        *mp = args->mp;
 300         int                     bit;    /* bit number in the word */
 301         xfs_fileoff_t           block;  /* bitmap block number */
 302         int                     error;
 303         xfs_rtxnum_t            i;      /* current bit number rel. to start */
 304         xfs_rtxnum_t            lastbit;/* last useful bit in the word */
 305         xfs_rtxnum_t            len;    /* length of inspected area */
 306         xfs_rtword_t            mask;   /* mask of relevant bits for value */
 307         xfs_rtword_t            want;   /* mask for "good" values */
 308         xfs_rtword_t            wdiff;  /* difference from wanted value */
 309         xfs_rtword_t            incore;
 310         unsigned int            word;   /* word number in the buffer */
 311
 312         /*
 313          * Compute and read in starting bitmap block for starting block.
 314          */
 315         block = xfs_rtx_to_rbmblock(mp, start);
 316         error = xfs_rtbitmap_read_buf(args, block);
 317         if (error)
 318                 return error;
 319
 320         /*
 321          * Get the first word's index & point to it.
 322          */
 323         word = xfs_rtx_to_rbmword(mp, start);
 324         bit = (int)(start & (XFS_NBWORD - 1));
 325         len = limit - start + 1;
 326         /*
 327          * Compute match value, based on the bit at start: if 1 (free)
 328          * then all-ones, else all-zeroes.
 329          */
 330         incore = xfs_rtbitmap_getword(args, word);
 331         want = (incore & ((xfs_rtword_t)1 << bit)) ? -1 : 0;
 332         /*
 333          * If the starting position is not word-aligned, deal with the
 334          * partial word.
 335          */
 336         if (bit) {
 337                 /*
 338                  * Calculate last (rightmost) bit number to look at,
 339                  * and mask for all the relevant bits in this word.
 340                  */
 341                 lastbit = min(bit + len, XFS_NBWORD);
 342                 mask = (((xfs_rtword_t)1 << (lastbit - bit)) - 1) << bit;
 343                 /*
 344                  * Calculate the difference between the value there
 345                  * and what we're looking for.
 346                  */
 347                 if ((wdiff = (incore ^ want) & mask)) {
 348                         /*
 349                          * Different.  Mark where we are and return.
 350                          */
 351                         i = xfs_lowbit32(wdiff) - bit;
 352                         *rtx = start + i - 1;
 353                         return 0;
 354                 }
 355                 i = lastbit - bit;
 356                 /*
 357                  * Go on to next block if that's where the next word is
 358                  * and we need the next word.
 359                  */
 360                 if (++word == mp->m_blockwsize && i < len) {
 361                         /*
 362                          * If done with this block, get the previous one.
 363                          */
 364                         error = xfs_rtbitmap_read_buf(args, ++block);
 365                         if (error)
 366                                 return error;
 367
 368                         word = 0;
 369                 }
 370         } else {
 371                 /*
 372                  * Starting on a word boundary, no partial word.
 373                  */
 374                 i = 0;
 375         }
 376         /*
 377          * Loop over whole words in buffers.  When we use up one buffer
 378          * we move on to the next one.
 379          */
 380         while (len - i >= XFS_NBWORD) {
 381                 /*
 382                  * Compute difference between actual and desired value.
 383                  */
 384                 incore = xfs_rtbitmap_getword(args, word);
 385                 if ((wdiff = incore ^ want)) {
 386                         /*
 387                          * Different, mark where we are and return.
 388                          */
 389                         i += xfs_lowbit32(wdiff);
 390                         *rtx = start + i - 1;
 391                         return 0;
 392                 }
 393                 i += XFS_NBWORD;
 394                 /*
 395                  * Go on to next block if that's where the next word is
 396                  * and we need the next word.
 397                  */
 398                 if (++word == mp->m_blockwsize && i < len) {
 399                         /*
 400                          * If done with this block, get the next one.
 401                          */
 402                         error = xfs_rtbitmap_read_buf(args, ++block);
 403                         if (error)
 404                                 return error;
 405
 406                         word = 0;
 407                 }
 408         }
 409         /*
 410          * If not ending on a word boundary, deal with the last
 411          * (partial) word.
 412          */
 413         if ((lastbit = len - i)) {
 414                 /*
 415                  * Calculate mask for all the relevant bits in this word.
 416                  */
 417                 mask = ((xfs_rtword_t)1 << lastbit) - 1;
 418                 /*
 419                  * Compute difference between actual and desired value.
 420                  */
 421                 incore = xfs_rtbitmap_getword(args, word);
 422                 if ((wdiff = (incore ^ want) & mask)) {
 423                         /*
 424                          * Different, mark where we are and return.
 425                          */
 426                         i += xfs_lowbit32(wdiff);
 427                         *rtx = start + i - 1;
 428                         return 0;
 429                 } else
 430                         i = len;
 431         }
 432         /*
 433          * No match, return that we scanned the whole area.
 434          */
 435         *rtx = start + i - 1;
 436         return 0;
 437 }
 438
 439 /* Log rtsummary counter at @infoword. */
 440 static inline void
 441 xfs_trans_log_rtsummary(
 442         struct xfs_rtalloc_args *args,
 443         unsigned int            infoword)
 444 {
 445         struct xfs_buf          *bp = args->sumbp;
 446         size_t                  first, last;
 447
 448         first = (void *)xfs_rsumblock_infoptr(args, infoword) - bp->b_addr;
 449         last = first + sizeof(xfs_suminfo_t) - 1;
 450
 451         xfs_trans_log_buf(args->tp, bp, first, last);
 452 }
 453
 454 /*
 455  * Modify the summary information for a given extent size, bitmap block
 456  * combination.
 457  */
 458 int
 459 xfs_rtmodify_summary(
 460         struct xfs_rtalloc_args *args,
 461         int                     log,    /* log2 of extent size */
 462         xfs_fileoff_t           bbno,   /* bitmap block number */
 463         int                     delta)  /* in/out: summary block number */
 464 {
 465         struct xfs_mount        *mp = args->mp;
 466         xfs_rtsumoff_t          so = xfs_rtsumoffs(mp, log, bbno);
 467         unsigned int            infoword;
 468         xfs_suminfo_t           val;
 469         int                     error;
 470
 471         error = xfs_rtsummary_read_buf(args, xfs_rtsumoffs_to_block(mp, so));
 472         if (error)
 473                 return error;
 474
 475         infoword = xfs_rtsumoffs_to_infoword(mp, so);
 476         val = xfs_suminfo_add(args, infoword, delta);
 477
 478         if (mp->m_rsum_cache) {
 479                 if (val == 0 && log + 1 == mp->m_rsum_cache[bbno])
 480                         mp->m_rsum_cache[bbno] = log;
 481                 if (val != 0 && log >= mp->m_rsum_cache[bbno])
 482                         mp->m_rsum_cache[bbno] = log + 1;
 483         }
 484
 485         xfs_trans_log_rtsummary(args, infoword);
 486         return 0;
 487 }
 488
 489 /*
 490  * Read and return the summary information for a given extent size, bitmap block
 491  * combination.
 492  */
 493 int
 494 xfs_rtget_summary(
 495         struct xfs_rtalloc_args *args,
 496         int                     log,    /* log2 of extent size */
 497         xfs_fileoff_t           bbno,   /* bitmap block number */
 498         xfs_suminfo_t           *sum)   /* out: summary info for this block */
 499 {
 500         struct xfs_mount        *mp = args->mp;
 501         xfs_rtsumoff_t          so = xfs_rtsumoffs(mp, log, bbno);
 502         int                     error;
 503
 504         error = xfs_rtsummary_read_buf(args, xfs_rtsumoffs_to_block(mp, so));
 505         if (!error)
 506                 *sum = xfs_suminfo_get(args, xfs_rtsumoffs_to_infoword(mp, so));
 507         return error;
 508 }
 509
 510 /* Log rtbitmap block from the word @from to the byte before @next. */
 511 static inline void
 512 xfs_trans_log_rtbitmap(
 513         struct xfs_rtalloc_args *args,
 514         unsigned int            from,
 515         unsigned int            next)
 516 {
 517         struct xfs_buf          *bp = args->rbmbp;
 518         size_t                  first, last;
 519
 520         first = (void *)xfs_rbmblock_wordptr(args, from) - bp->b_addr;
 521         last = ((void *)xfs_rbmblock_wordptr(args, next) - 1) - bp->b_addr;
 522
 523         xfs_trans_log_buf(args->tp, bp, first, last);
 524 }
 525
 526 /*
 527  * Set the given range of bitmap bits to the given value.
 528  * Do whatever I/O and logging is required.
 529  */
 530 int
 531 xfs_rtmodify_range(
 532         struct xfs_rtalloc_args *args,
 533         xfs_rtxnum_t            start,  /* starting rtext to modify */
 534         xfs_rtxlen_t            len,    /* length of extent to modify */
 535         int                     val)    /* 1 for free, 0 for allocated */
 536 {
 537         struct xfs_mount        *mp = args->mp;
 538         int                     bit;    /* bit number in the word */
 539         xfs_fileoff_t           block;  /* bitmap block number */
 540         int                     error;
 541         int                     i;      /* current bit number rel. to start */
 542         int                     lastbit; /* last useful bit in word */
 543         xfs_rtword_t            mask;    /* mask of relevant bits for value */
 544         xfs_rtword_t            incore;
 545         unsigned int            firstword; /* first word used in the buffer */
 546         unsigned int            word;   /* word number in the buffer */
 547
 548         /*
 549          * Compute starting bitmap block number.
 550          */
 551         block = xfs_rtx_to_rbmblock(mp, start);
 552         /*
 553          * Read the bitmap block, and point to its data.
 554          */
 555         error = xfs_rtbitmap_read_buf(args, block);
 556         if (error)
 557                 return error;
 558
 559         /*
 560          * Compute the starting word's address, and starting bit.
 561          */
 562         firstword = word = xfs_rtx_to_rbmword(mp, start);
 563         bit = (int)(start & (XFS_NBWORD - 1));
 564         /*
 565          * 0 (allocated) => all zeroes; 1 (free) => all ones.
 566          */
 567         val = -val;
 568         /*
 569          * If not starting on a word boundary, deal with the first
 570          * (partial) word.
 571          */
 572         if (bit) {
 573                 /*
 574                  * Compute first bit not changed and mask of relevant bits.
 575                  */
 576                 lastbit = min(bit + len, XFS_NBWORD);
 577                 mask = (((xfs_rtword_t)1 << (lastbit - bit)) - 1) << bit;
 578                 /*
 579                  * Set/clear the active bits.
 580                  */
 581                 incore = xfs_rtbitmap_getword(args, word);
 582                 if (val)
 583                         incore |= mask;
 584                 else
 585                         incore &= ~mask;
 586                 xfs_rtbitmap_setword(args, word, incore);
 587                 i = lastbit - bit;
 588                 /*
 589                  * Go on to the next block if that's where the next word is
 590                  * and we need the next word.
 591                  */
 592                 if (++word == mp->m_blockwsize && i < len) {
 593                         /*
 594                          * Log the changed part of this block.
 595                          * Get the next one.
 596                          */
 597                         xfs_trans_log_rtbitmap(args, firstword, word);
 598                         error = xfs_rtbitmap_read_buf(args, ++block);
 599                         if (error)
 600                                 return error;
 601
 602                         firstword = word = 0;
 603                 }
 604         } else {
 605                 /*
 606                  * Starting on a word boundary, no partial word.
 607                  */
 608                 i = 0;
 609         }
 610         /*
 611          * Loop over whole words in buffers.  When we use up one buffer
 612          * we move on to the next one.
 613          */
 614         while (len - i >= XFS_NBWORD) {
 615                 /*
 616                  * Set the word value correctly.
 617                  */
 618                 xfs_rtbitmap_setword(args, word, val);
 619                 i += XFS_NBWORD;
 620                 /*
 621                  * Go on to the next block if that's where the next word is
 622                  * and we need the next word.
 623                  */
 624                 if (++word == mp->m_blockwsize && i < len) {
 625                         /*
 626                          * Log the changed part of this block.
 627                          * Get the next one.
 628                          */
 629                         xfs_trans_log_rtbitmap(args, firstword, word);
 630                         error = xfs_rtbitmap_read_buf(args, ++block);
 631                         if (error)
 632                                 return error;
 633
 634                         firstword = word = 0;
 635                 }
 636         }
 637         /*
 638          * If not ending on a word boundary, deal with the last
 639          * (partial) word.
 640          */
 641         if ((lastbit = len - i)) {
 642                 /*
 643                  * Compute a mask of relevant bits.
 644                  */
 645                 mask = ((xfs_rtword_t)1 << lastbit) - 1;
 646                 /*
 647                  * Set/clear the active bits.
 648                  */
 649                 incore = xfs_rtbitmap_getword(args, word);
 650                 if (val)
 651                         incore |= mask;
 652                 else
 653                         incore &= ~mask;
 654                 xfs_rtbitmap_setword(args, word, incore);
 655                 word++;
 656         }
 657         /*
 658          * Log any remaining changed bytes.
 659          */
 660         if (word > firstword)
 661                 xfs_trans_log_rtbitmap(args, firstword, word);
 662         return 0;
 663 }
 664
 665 /*
 666  * Mark an extent specified by start and len freed.
 667  * Updates all the summary information as well as the bitmap.
 668  */
 669 int
 670 xfs_rtfree_range(
 671         struct xfs_rtalloc_args *args,
 672         xfs_rtxnum_t            start,  /* starting rtext to free */
 673         xfs_rtxlen_t            len)    /* in/out: summary block number */
 674 {
 675         struct xfs_mount        *mp = args->mp;
 676         xfs_rtxnum_t            end;    /* end of the freed extent */
 677         int                     error;  /* error value */
 678         xfs_rtxnum_t            postblock; /* first rtext freed > end */
 679         xfs_rtxnum_t            preblock;  /* first rtext freed < start */
 680
 681         end = start + len - 1;
 682         /*
 683          * Modify the bitmap to mark this extent freed.
 684          */
 685         error = xfs_rtmodify_range(args, start, len, 1);
 686         if (error) {
 687                 return error;
 688         }
 689         /*
 690          * Assume we're freeing out of the middle of an allocated extent.
 691          * We need to find the beginning and end of the extent so we can
 692          * properly update the summary.
 693          */
 694         error = xfs_rtfind_back(args, start, 0, &preblock);
 695         if (error) {
 696                 return error;
 697         }
 698         /*
 699          * Find the next allocated block (end of allocated extent).
 700          */
 701         error = xfs_rtfind_forw(args, end, mp->m_sb.sb_rextents - 1,
 702                         &postblock);
 703         if (error)
 704                 return error;
 705         /*
 706          * If there are blocks not being freed at the front of the
 707          * old extent, add summary data for them to be allocated.
 708          */
 709         if (preblock < start) {
 710                 error = xfs_rtmodify_summary(args,
 711                                 xfs_highbit64(start - preblock),
 712                                 xfs_rtx_to_rbmblock(mp, preblock), -1);
 713                 if (error) {
 714                         return error;
 715                 }
 716         }
 717         /*
 718          * If there are blocks not being freed at the end of the
 719          * old extent, add summary data for them to be allocated.
 720          */
 721         if (postblock > end) {
 722                 error = xfs_rtmodify_summary(args,
 723                                 xfs_highbit64(postblock - end),
 724                                 xfs_rtx_to_rbmblock(mp, end + 1), -1);
 725                 if (error) {
 726                         return error;
 727                 }
 728         }
 729         /*
 730          * Increment the summary information corresponding to the entire
 731          * (new) free extent.
 732          */
 733         return xfs_rtmodify_summary(args,
 734                         xfs_highbit64(postblock + 1 - preblock),
 735                         xfs_rtx_to_rbmblock(mp, preblock), 1);
 736 }
 737
 738 /*
 739  * Check that the given range is either all allocated (val = 0) or
 740  * all free (val = 1).
 741  */
 742 int
 743 xfs_rtcheck_range(
 744         struct xfs_rtalloc_args *args,
 745         xfs_rtxnum_t            start,  /* starting rtext number of extent */
 746         xfs_rtxlen_t            len,    /* length of extent */
 747         int                     val,    /* 1 for free, 0 for allocated */
 748         xfs_rtxnum_t            *new,   /* out: first rtext not matching */
 749         int                     *stat)  /* out: 1 for matches, 0 for not */
 750 {
 751         struct xfs_mount        *mp = args->mp;
 752         int                     bit;    /* bit number in the word */
 753         xfs_fileoff_t           block;  /* bitmap block number */
 754         int                     error;
 755         xfs_rtxnum_t            i;      /* current bit number rel. to start */
 756         xfs_rtxnum_t            lastbit; /* last useful bit in word */
 757         xfs_rtword_t            mask;   /* mask of relevant bits for value */
 758         xfs_rtword_t            wdiff;  /* difference from wanted value */
 759         xfs_rtword_t            incore;
 760         unsigned int            word;   /* word number in the buffer */
 761
 762         /*
 763          * Compute starting bitmap block number
 764          */
 765         block = xfs_rtx_to_rbmblock(mp, start);
 766         /*
 767          * Read the bitmap block.
 768          */
 769         error = xfs_rtbitmap_read_buf(args, block);
 770         if (error)
 771                 return error;
 772
 773         /*
 774          * Compute the starting word's address, and starting bit.
 775          */
 776         word = xfs_rtx_to_rbmword(mp, start);
 777         bit = (int)(start & (XFS_NBWORD - 1));
 778         /*
 779          * 0 (allocated) => all zero's; 1 (free) => all one's.
 780          */
 781         val = -val;
 782         /*
 783          * If not starting on a word boundary, deal with the first
 784          * (partial) word.
 785          */
 786         if (bit) {
 787                 /*
 788                  * Compute first bit not examined.
 789                  */
 790                 lastbit = min(bit + len, XFS_NBWORD);
 791                 /*
 792                  * Mask of relevant bits.
 793                  */
 794                 mask = (((xfs_rtword_t)1 << (lastbit - bit)) - 1) << bit;
 795                 /*
 796                  * Compute difference between actual and desired value.
 797                  */
 798                 incore = xfs_rtbitmap_getword(args, word);
 799                 if ((wdiff = (incore ^ val) & mask)) {
 800                         /*
 801                          * Different, compute first wrong bit and return.
 802                          */
 803                         i = xfs_lowbit32(wdiff) - bit;
 804                         *new = start + i;
 805                         *stat = 0;
 806                         return 0;
 807                 }
 808                 i = lastbit - bit;
 809                 /*
 810                  * Go on to next block if that's where the next word is
 811                  * and we need the next word.
 812                  */
 813                 if (++word == mp->m_blockwsize && i < len) {
 814                         /*
 815                          * If done with this block, get the next one.
 816                          */
 817                         error = xfs_rtbitmap_read_buf(args, ++block);
 818                         if (error)
 819                                 return error;
 820
 821                         word = 0;
 822                 }
 823         } else {
 824                 /*
 825                  * Starting on a word boundary, no partial word.
 826                  */
 827                 i = 0;
 828         }
 829         /*
 830          * Loop over whole words in buffers.  When we use up one buffer
 831          * we move on to the next one.
 832          */
 833         while (len - i >= XFS_NBWORD) {
 834                 /*
 835                  * Compute difference between actual and desired value.
 836                  */
 837                 incore = xfs_rtbitmap_getword(args, word);
 838                 if ((wdiff = incore ^ val)) {
 839                         /*
 840                          * Different, compute first wrong bit and return.
 841                          */
 842                         i += xfs_lowbit32(wdiff);
 843                         *new = start + i;
 844                         *stat = 0;
 845                         return 0;
 846                 }
 847                 i += XFS_NBWORD;
 848                 /*
 849                  * Go on to next block if that's where the next word is
 850                  * and we need the next word.
 851                  */
 852                 if (++word == mp->m_blockwsize && i < len) {
 853                         /*
 854                          * If done with this block, get the next one.
 855                          */
 856                         error = xfs_rtbitmap_read_buf(args, ++block);
 857                         if (error)
 858                                 return error;
 859
 860                         word = 0;
 861                 }
 862         }
 863         /*
 864          * If not ending on a word boundary, deal with the last
 865          * (partial) word.
 866          */
 867         if ((lastbit = len - i)) {
 868                 /*
 869                  * Mask of relevant bits.
 870                  */
 871                 mask = ((xfs_rtword_t)1 << lastbit) - 1;
 872                 /*
 873                  * Compute difference between actual and desired value.
 874                  */
 875                 incore = xfs_rtbitmap_getword(args, word);
 876                 if ((wdiff = (incore ^ val) & mask)) {
 877                         /*
 878                          * Different, compute first wrong bit and return.
 879                          */
 880                         i += xfs_lowbit32(wdiff);
 881                         *new = start + i;
 882                         *stat = 0;
 883                         return 0;
 884                 } else
 885                         i = len;
 886         }
 887         /*
 888          * Successful, return.
 889          */
 890         *new = start + i;
 891         *stat = 1;
 892         return 0;
 893 }
 894
 895 #ifdef DEBUG
 896 /*
 897  * Check that the given extent (block range) is allocated already.
 898  */
 899 STATIC int
 900 xfs_rtcheck_alloc_range(
 901         struct xfs_rtalloc_args *args,
 902         xfs_rtxnum_t            start,  /* starting rtext number of extent */
 903         xfs_rtxlen_t            len)    /* length of extent */
 904 {
 905         xfs_rtxnum_t            new;    /* dummy for xfs_rtcheck_range */
 906         int                     stat;
 907         int                     error;
 908
 909         error = xfs_rtcheck_range(args, start, len, 0, &new, &stat);
 910         if (error)
 911                 return error;
 912         ASSERT(stat);
 913         return 0;
 914 }
 915 #else
 916 #define xfs_rtcheck_alloc_range(a,b,l)  (0)
 917 #endif
 918 /*
 919  * Free an extent in the realtime subvolume.  Length is expressed in
 920  * realtime extents, as is the block number.
 921  */
 922 int
 923 xfs_rtfree_extent(
 924         struct xfs_trans        *tp,    /* transaction pointer */
 925         xfs_rtxnum_t            start,  /* starting rtext number to free */
 926         xfs_rtxlen_t            len)    /* length of extent freed */
 927 {
 928         struct xfs_mount        *mp = tp->t_mountp;
 929         struct xfs_rtalloc_args args = {
 930                 .mp             = mp,
 931                 .tp             = tp,
 932         };
 933         int                     error;
 934         struct timespec64       atime;
 935
 936         ASSERT(mp->m_rbmip->i_itemp != NULL);
 937         ASSERT(xfs_isilocked(mp->m_rbmip, XFS_ILOCK_EXCL));
 938
 939         error = xfs_rtcheck_alloc_range(&args, start, len);
 940         if (error)
 941                 return error;
 942
 943         /*
 944          * Free the range of realtime blocks.
 945          */
 946         error = xfs_rtfree_range(&args, start, len);
 947         if (error)
 948                 goto out;
 949
 950         /*
 951          * Mark more blocks free in the superblock.
 952          */
 953         xfs_trans_mod_sb(tp, XFS_TRANS_SB_FREXTENTS, (long)len);
 954         /*
 955          * If we've now freed all the blocks, reset the file sequence
 956          * number to 0.
 957          */
 958         if (tp->t_frextents_delta + mp->m_sb.sb_frextents ==
 959             mp->m_sb.sb_rextents) {
 960                 if (!(mp->m_rbmip->i_diflags & XFS_DIFLAG_NEWRTBM))
 961                         mp->m_rbmip->i_diflags |= XFS_DIFLAG_NEWRTBM;
 962
 963                 atime = inode_get_atime(VFS_I(mp->m_rbmip));
 964                 atime.tv_sec = 0;
 965                 inode_set_atime_to_ts(VFS_I(mp->m_rbmip), atime);
 966                 xfs_trans_log_inode(tp, mp->m_rbmip, XFS_ILOG_CORE);
 967         }
 968         error = 0;
 969 out:
 970         xfs_rtbuf_cache_relse(&args);
 971         return error;
 972 }
 973
 974 /*
 975  * Free some blocks in the realtime subvolume.  rtbno and rtlen are in units of
 976  * rt blocks, not rt extents; must be aligned to the rt extent size; and rtlen
 977  * cannot exceed XFS_MAX_BMBT_EXTLEN.
 978  */
 979 int
 980 xfs_rtfree_blocks(
 981         struct xfs_trans        *tp,
 982         xfs_fsblock_t           rtbno,
 983         xfs_filblks_t           rtlen)
 984 {
 985         struct xfs_mount        *mp = tp->t_mountp;
 986         xfs_rtxnum_t            start;
 987         xfs_filblks_t           len;
 988         xfs_extlen_t            mod;
 989
 990         ASSERT(rtlen <= XFS_MAX_BMBT_EXTLEN);
 991
 992         len = xfs_rtb_to_rtxrem(mp, rtlen, &mod);
 993         if (mod) {
 994                 ASSERT(mod == 0);
 995                 return -EIO;
 996         }
 997
 998         start = xfs_rtb_to_rtxrem(mp, rtbno, &mod);
 999         if (mod) {
1000                 ASSERT(mod == 0);
1001                 return -EIO;
1002         }
1003
1004         return xfs_rtfree_extent(tp, start, len);
1005 }
1006
1007 /* Find all the free records within a given range. */
1008 int
1009 xfs_rtalloc_query_range(
1010         struct xfs_mount                *mp,
1011         struct xfs_trans                *tp,
1012         const struct xfs_rtalloc_rec    *low_rec,
1013         const struct xfs_rtalloc_rec    *high_rec,
1014         xfs_rtalloc_query_range_fn      fn,
1015         void                            *priv)
1016 {
1017         struct xfs_rtalloc_args         args = {
1018                 .mp                     = mp,
1019                 .tp                     = tp,
1020         };
1021         struct xfs_rtalloc_rec          rec;
1022         xfs_rtxnum_t                    rtstart;
1023         xfs_rtxnum_t                    rtend;
1024         xfs_rtxnum_t                    high_key;
1025         int                             is_free;
1026         int                             error = 0;
1027
1028         if (low_rec->ar_startext > high_rec->ar_startext)
1029                 return -EINVAL;
1030         if (low_rec->ar_startext >= mp->m_sb.sb_rextents ||
1031             low_rec->ar_startext == high_rec->ar_startext)
1032                 return 0;
1033
1034         high_key = min(high_rec->ar_startext, mp->m_sb.sb_rextents - 1);
1035
1036         /* Iterate the bitmap, looking for discrepancies. */
1037         rtstart = low_rec->ar_startext;
1038         while (rtstart <= high_key) {
1039                 /* Is the first block free? */
1040                 error = xfs_rtcheck_range(&args, rtstart, 1, 1, &rtend,
1041                                 &is_free);
1042                 if (error)
1043                         break;
1044
1045                 /* How long does the extent go for? */
1046                 error = xfs_rtfind_forw(&args, rtstart, high_key, &rtend);
1047                 if (error)
1048                         break;
1049
1050                 if (is_free) {
1051                         rec.ar_startext = rtstart;
1052                         rec.ar_extcount = rtend - rtstart + 1;
1053
1054                         error = fn(mp, tp, &rec, priv);
1055                         if (error)
1056                                 break;
1057                 }
1058
1059                 rtstart = rtend + 1;
1060         }
1061
1062         xfs_rtbuf_cache_relse(&args);
1063         return error;
1064 }
1065
1066 /* Find all the free records. */
1067 int
1068 xfs_rtalloc_query_all(
1069         struct xfs_mount                *mp,
1070         struct xfs_trans                *tp,
1071         xfs_rtalloc_query_range_fn      fn,
1072         void                            *priv)
1073 {
1074         struct xfs_rtalloc_rec          keys[2];
1075
1076         keys[0].ar_startext = 0;
1077         keys[1].ar_startext = mp->m_sb.sb_rextents - 1;
1078         keys[0].ar_extcount = keys[1].ar_extcount = 0;
1079
1080         return xfs_rtalloc_query_range(mp, tp, &keys[0], &keys[1], fn, priv);
1081 }
1082
1083 /* Is the given extent all free? */
1084 int
1085 xfs_rtalloc_extent_is_free(
1086         struct xfs_mount                *mp,
1087         struct xfs_trans                *tp,
1088         xfs_rtxnum_t                    start,
1089         xfs_rtxlen_t                    len,
1090         bool                            *is_free)
1091 {
1092         struct xfs_rtalloc_args         args = {
1093                 .mp                     = mp,
1094                 .tp                     = tp,
1095         };
1096         xfs_rtxnum_t                    end;
1097         int                             matches;
1098         int                             error;
1099
1100         error = xfs_rtcheck_range(&args, start, len, 1, &end, &matches);
1101         xfs_rtbuf_cache_relse(&args);
1102         if (error)
1103                 return error;
1104
1105         *is_free = matches;
1106         return 0;
1107 }
1108
1109 /*
1110  * Compute the number of rtbitmap blocks needed to track the given number of rt
1111  * extents.
1112  */
1113 xfs_filblks_t
1114 xfs_rtbitmap_blockcount(
1115         struct xfs_mount        *mp,
1116         xfs_rtbxlen_t           rtextents)
1117 {
1118         return howmany_64(rtextents, NBBY * mp->m_sb.sb_blocksize);
1119 }
1120
1121 /*
1122  * Compute the number of rtbitmap words needed to populate every block of a
1123  * bitmap that is large enough to track the given number of rt extents.
1124  */
1125 unsigned long long
1126 xfs_rtbitmap_wordcount(
1127         struct xfs_mount        *mp,
1128         xfs_rtbxlen_t           rtextents)
1129 {
1130         xfs_filblks_t           blocks;
1131
1132         blocks = xfs_rtbitmap_blockcount(mp, rtextents);
1133         return XFS_FSB_TO_B(mp, blocks) >> XFS_WORDLOG;
1134 }
1135
1136 /* Compute the number of rtsummary blocks needed to track the given rt space. */
1137 xfs_filblks_t
1138 xfs_rtsummary_blockcount(
1139         struct xfs_mount        *mp,
1140         unsigned int            rsumlevels,
1141         xfs_extlen_t            rbmblocks)
1142 {
1143         unsigned long long      rsumwords;
1144
1145         rsumwords = (unsigned long long)rsumlevels * rbmblocks;
1146         return XFS_B_TO_FSB(mp, rsumwords << XFS_WORDLOG);
1147 }
1148
1149 /*
1150  * Compute the number of rtsummary info words needed to populate every block of
1151  * a summary file that is large enough to track the given rt space.
1152  */
1153 unsigned long long
1154 xfs_rtsummary_wordcount(
1155         struct xfs_mount        *mp,
1156         unsigned int            rsumlevels,
1157         xfs_extlen_t            rbmblocks)
1158 {
1159         xfs_filblks_t           blocks;
1160
1161         blocks = xfs_rtsummary_blockcount(mp, rsumlevels, rbmblocks);
1162         return XFS_FSB_TO_B(mp, blocks) >> XFS_WORDLOG;
1163 }