fs/xfs/xfs_fsmap.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2017 Oracle.  All Rights Reserved.
   4  * Author: Darrick J. Wong <darrick.wong@oracle.com>
   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_mount.h"
  13 #include "xfs_inode.h"
  14 #include "xfs_trans.h"
  15 #include "xfs_btree.h"
  16 #include "xfs_rmap_btree.h"
  17 #include "xfs_trace.h"
  18 #include "xfs_rmap.h"
  19 #include "xfs_alloc.h"
  20 #include "xfs_bit.h"
  21 #include <linux/fsmap.h>
  22 #include "xfs_fsmap.h"
  23 #include "xfs_refcount.h"
  24 #include "xfs_refcount_btree.h"
  25 #include "xfs_alloc_btree.h"
  26 #include "xfs_rtalloc.h"
  27 #include "xfs_ag.h"
  28
  29 /* Convert an xfs_fsmap to an fsmap. */
  30 static void
  31 xfs_fsmap_from_internal(
  32         struct fsmap            *dest,
  33         struct xfs_fsmap        *src)
  34 {
  35         dest->fmr_device = src->fmr_device;
  36         dest->fmr_flags = src->fmr_flags;
  37         dest->fmr_physical = BBTOB(src->fmr_physical);
  38         dest->fmr_owner = src->fmr_owner;
  39         dest->fmr_offset = BBTOB(src->fmr_offset);
  40         dest->fmr_length = BBTOB(src->fmr_length);
  41         dest->fmr_reserved[0] = 0;
  42         dest->fmr_reserved[1] = 0;
  43         dest->fmr_reserved[2] = 0;
  44 }
  45
  46 /* Convert an fsmap to an xfs_fsmap. */
  47 void
  48 xfs_fsmap_to_internal(
  49         struct xfs_fsmap        *dest,
  50         struct fsmap            *src)
  51 {
  52         dest->fmr_device = src->fmr_device;
  53         dest->fmr_flags = src->fmr_flags;
  54         dest->fmr_physical = BTOBBT(src->fmr_physical);
  55         dest->fmr_owner = src->fmr_owner;
  56         dest->fmr_offset = BTOBBT(src->fmr_offset);
  57         dest->fmr_length = BTOBBT(src->fmr_length);
  58 }
  59
  60 /* Convert an fsmap owner into an rmapbt owner. */
  61 static int
  62 xfs_fsmap_owner_to_rmap(
  63         struct xfs_rmap_irec    *dest,
  64         const struct xfs_fsmap  *src)
  65 {
  66         if (!(src->fmr_flags & FMR_OF_SPECIAL_OWNER)) {
  67                 dest->rm_owner = src->fmr_owner;
  68                 return 0;
  69         }
  70
  71         switch (src->fmr_owner) {
  72         case 0:                 /* "lowest owner id possible" */
  73         case -1ULL:             /* "highest owner id possible" */
  74                 dest->rm_owner = 0;
  75                 break;
  76         case XFS_FMR_OWN_FREE:
  77                 dest->rm_owner = XFS_RMAP_OWN_NULL;
  78                 break;
  79         case XFS_FMR_OWN_UNKNOWN:
  80                 dest->rm_owner = XFS_RMAP_OWN_UNKNOWN;
  81                 break;
  82         case XFS_FMR_OWN_FS:
  83                 dest->rm_owner = XFS_RMAP_OWN_FS;
  84                 break;
  85         case XFS_FMR_OWN_LOG:
  86                 dest->rm_owner = XFS_RMAP_OWN_LOG;
  87                 break;
  88         case XFS_FMR_OWN_AG:
  89                 dest->rm_owner = XFS_RMAP_OWN_AG;
  90                 break;
  91         case XFS_FMR_OWN_INOBT:
  92                 dest->rm_owner = XFS_RMAP_OWN_INOBT;
  93                 break;
  94         case XFS_FMR_OWN_INODES:
  95                 dest->rm_owner = XFS_RMAP_OWN_INODES;
  96                 break;
  97         case XFS_FMR_OWN_REFC:
  98                 dest->rm_owner = XFS_RMAP_OWN_REFC;
  99                 break;
 100         case XFS_FMR_OWN_COW:
 101                 dest->rm_owner = XFS_RMAP_OWN_COW;
 102                 break;
 103         case XFS_FMR_OWN_DEFECTIVE:     /* not implemented */
 104                 /* fall through */
 105         default:
 106                 return -EINVAL;
 107         }
 108         return 0;
 109 }
 110
 111 /* Convert an rmapbt owner into an fsmap owner. */
 112 static int
 113 xfs_fsmap_owner_from_rmap(
 114         struct xfs_fsmap                *dest,
 115         const struct xfs_rmap_irec      *src)
 116 {
 117         dest->fmr_flags = 0;
 118         if (!XFS_RMAP_NON_INODE_OWNER(src->rm_owner)) {
 119                 dest->fmr_owner = src->rm_owner;
 120                 return 0;
 121         }
 122         dest->fmr_flags |= FMR_OF_SPECIAL_OWNER;
 123
 124         switch (src->rm_owner) {
 125         case XFS_RMAP_OWN_FS:
 126                 dest->fmr_owner = XFS_FMR_OWN_FS;
 127                 break;
 128         case XFS_RMAP_OWN_LOG:
 129                 dest->fmr_owner = XFS_FMR_OWN_LOG;
 130                 break;
 131         case XFS_RMAP_OWN_AG:
 132                 dest->fmr_owner = XFS_FMR_OWN_AG;
 133                 break;
 134         case XFS_RMAP_OWN_INOBT:
 135                 dest->fmr_owner = XFS_FMR_OWN_INOBT;
 136                 break;
 137         case XFS_RMAP_OWN_INODES:
 138                 dest->fmr_owner = XFS_FMR_OWN_INODES;
 139                 break;
 140         case XFS_RMAP_OWN_REFC:
 141                 dest->fmr_owner = XFS_FMR_OWN_REFC;
 142                 break;
 143         case XFS_RMAP_OWN_COW:
 144                 dest->fmr_owner = XFS_FMR_OWN_COW;
 145                 break;
 146         case XFS_RMAP_OWN_NULL: /* "free" */
 147                 dest->fmr_owner = XFS_FMR_OWN_FREE;
 148                 break;
 149         default:
 150                 ASSERT(0);
 151                 return -EFSCORRUPTED;
 152         }
 153         return 0;
 154 }
 155
 156 /* getfsmap query state */
 157 struct xfs_getfsmap_info {
 158         struct xfs_fsmap_head   *head;
 159         struct fsmap            *fsmap_recs;    /* mapping records */
 160         struct xfs_buf          *agf_bp;        /* AGF, for refcount queries */
 161         struct xfs_perag        *pag;           /* AG info, if applicable */
 162         xfs_daddr_t             next_daddr;     /* next daddr we expect */
 163         u64                     missing_owner;  /* owner of holes */
 164         u32                     dev;            /* device id */
 165         struct xfs_rmap_irec    low;            /* low rmap key */
 166         struct xfs_rmap_irec    high;           /* high rmap key */
 167         bool                    last;           /* last extent? */
 168 };
 169
 170 /* Associate a device with a getfsmap handler. */
 171 struct xfs_getfsmap_dev {
 172         u32                     dev;
 173         int                     (*fn)(struct xfs_trans *tp,
 174                                       const struct xfs_fsmap *keys,
 175                                       struct xfs_getfsmap_info *info);
 176 };
 177
 178 /* Compare two getfsmap device handlers. */
 179 static int
 180 xfs_getfsmap_dev_compare(
 181         const void                      *p1,
 182         const void                      *p2)
 183 {
 184         const struct xfs_getfsmap_dev   *d1 = p1;
 185         const struct xfs_getfsmap_dev   *d2 = p2;
 186
 187         return d1->dev - d2->dev;
 188 }
 189
 190 /* Decide if this mapping is shared. */
 191 STATIC int
 192 xfs_getfsmap_is_shared(
 193         struct xfs_trans                *tp,
 194         struct xfs_getfsmap_info        *info,
 195         const struct xfs_rmap_irec      *rec,
 196         bool                            *stat)
 197 {
 198         struct xfs_mount                *mp = tp->t_mountp;
 199         struct xfs_btree_cur            *cur;
 200         xfs_agblock_t                   fbno;
 201         xfs_extlen_t                    flen;
 202         int                             error;
 203
 204         *stat = false;
 205         if (!xfs_has_reflink(mp))
 206                 return 0;
 207         /* rt files will have no perag structure */
 208         if (!info->pag)
 209                 return 0;
 210
 211         /* Are there any shared blocks here? */
 212         flen = 0;
 213         cur = xfs_refcountbt_init_cursor(mp, tp, info->agf_bp, info->pag);
 214
 215         error = xfs_refcount_find_shared(cur, rec->rm_startblock,
 216                         rec->rm_blockcount, &fbno, &flen, false);
 217
 218         xfs_btree_del_cursor(cur, error);
 219         if (error)
 220                 return error;
 221
 222         *stat = flen > 0;
 223         return 0;
 224 }
 225
 226 static inline void
 227 xfs_getfsmap_format(
 228         struct xfs_mount                *mp,
 229         struct xfs_fsmap                *xfm,
 230         struct xfs_getfsmap_info        *info)
 231 {
 232         struct fsmap                    *rec;
 233
 234         trace_xfs_getfsmap_mapping(mp, xfm);
 235
 236         rec = &info->fsmap_recs[info->head->fmh_entries++];
 237         xfs_fsmap_from_internal(rec, xfm);
 238 }
 239
 240 /*
 241  * Format a reverse mapping for getfsmap, having translated rm_startblock
 242  * into the appropriate daddr units.
 243  */
 244 STATIC int
 245 xfs_getfsmap_helper(
 246         struct xfs_trans                *tp,
 247         struct xfs_getfsmap_info        *info,
 248         const struct xfs_rmap_irec      *rec,
 249         xfs_daddr_t                     rec_daddr)
 250 {
 251         struct xfs_fsmap                fmr;
 252         struct xfs_mount                *mp = tp->t_mountp;
 253         bool                            shared;
 254         int                             error;
 255
 256         if (fatal_signal_pending(current))
 257                 return -EINTR;
 258
 259         /*
 260          * Filter out records that start before our startpoint, if the
 261          * caller requested that.
 262          */
 263         if (xfs_rmap_compare(rec, &info->low) < 0) {
 264                 rec_daddr += XFS_FSB_TO_BB(mp, rec->rm_blockcount);
 265                 if (info->next_daddr < rec_daddr)
 266                         info->next_daddr = rec_daddr;
 267                 return 0;
 268         }
 269
 270         /* Are we just counting mappings? */
 271         if (info->head->fmh_count == 0) {
 272                 if (info->head->fmh_entries == UINT_MAX)
 273                         return -ECANCELED;
 274
 275                 if (rec_daddr > info->next_daddr)
 276                         info->head->fmh_entries++;
 277
 278                 if (info->last)
 279                         return 0;
 280
 281                 info->head->fmh_entries++;
 282
 283                 rec_daddr += XFS_FSB_TO_BB(mp, rec->rm_blockcount);
 284                 if (info->next_daddr < rec_daddr)
 285                         info->next_daddr = rec_daddr;
 286                 return 0;
 287         }
 288
 289         /*
 290          * If the record starts past the last physical block we saw,
 291          * then we've found a gap.  Report the gap as being owned by
 292          * whatever the caller specified is the missing owner.
 293          */
 294         if (rec_daddr > info->next_daddr) {
 295                 if (info->head->fmh_entries >= info->head->fmh_count)
 296                         return -ECANCELED;
 297
 298                 fmr.fmr_device = info->dev;
 299                 fmr.fmr_physical = info->next_daddr;
 300                 fmr.fmr_owner = info->missing_owner;
 301                 fmr.fmr_offset = 0;
 302                 fmr.fmr_length = rec_daddr - info->next_daddr;
 303                 fmr.fmr_flags = FMR_OF_SPECIAL_OWNER;
 304                 xfs_getfsmap_format(mp, &fmr, info);
 305         }
 306
 307         if (info->last)
 308                 goto out;
 309
 310         /* Fill out the extent we found */
 311         if (info->head->fmh_entries >= info->head->fmh_count)
 312                 return -ECANCELED;
 313
 314         trace_xfs_fsmap_mapping(mp, info->dev,
 315                         info->pag ? info->pag->pag_agno : NULLAGNUMBER, rec);
 316
 317         fmr.fmr_device = info->dev;
 318         fmr.fmr_physical = rec_daddr;
 319         error = xfs_fsmap_owner_from_rmap(&fmr, rec);
 320         if (error)
 321                 return error;
 322         fmr.fmr_offset = XFS_FSB_TO_BB(mp, rec->rm_offset);
 323         fmr.fmr_length = XFS_FSB_TO_BB(mp, rec->rm_blockcount);
 324         if (rec->rm_flags & XFS_RMAP_UNWRITTEN)
 325                 fmr.fmr_flags |= FMR_OF_PREALLOC;
 326         if (rec->rm_flags & XFS_RMAP_ATTR_FORK)
 327                 fmr.fmr_flags |= FMR_OF_ATTR_FORK;
 328         if (rec->rm_flags & XFS_RMAP_BMBT_BLOCK)
 329                 fmr.fmr_flags |= FMR_OF_EXTENT_MAP;
 330         if (fmr.fmr_flags == 0) {
 331                 error = xfs_getfsmap_is_shared(tp, info, rec, &shared);
 332                 if (error)
 333                         return error;
 334                 if (shared)
 335                         fmr.fmr_flags |= FMR_OF_SHARED;
 336         }
 337
 338         xfs_getfsmap_format(mp, &fmr, info);
 339 out:
 340         rec_daddr += XFS_FSB_TO_BB(mp, rec->rm_blockcount);
 341         if (info->next_daddr < rec_daddr)
 342                 info->next_daddr = rec_daddr;
 343         return 0;
 344 }
 345
 346 /* Transform a rmapbt irec into a fsmap */
 347 STATIC int
 348 xfs_getfsmap_datadev_helper(
 349         struct xfs_btree_cur            *cur,
 350         const struct xfs_rmap_irec      *rec,
 351         void                            *priv)
 352 {
 353         struct xfs_mount                *mp = cur->bc_mp;
 354         struct xfs_getfsmap_info        *info = priv;
 355         xfs_fsblock_t                   fsb;
 356         xfs_daddr_t                     rec_daddr;
 357
 358         fsb = XFS_AGB_TO_FSB(mp, cur->bc_ag.pag->pag_agno, rec->rm_startblock);
 359         rec_daddr = XFS_FSB_TO_DADDR(mp, fsb);
 360
 361         return xfs_getfsmap_helper(cur->bc_tp, info, rec, rec_daddr);
 362 }
 363
 364 /* Transform a bnobt irec into a fsmap */
 365 STATIC int
 366 xfs_getfsmap_datadev_bnobt_helper(
 367         struct xfs_btree_cur            *cur,
 368         const struct xfs_alloc_rec_incore *rec,
 369         void                            *priv)
 370 {
 371         struct xfs_mount                *mp = cur->bc_mp;
 372         struct xfs_getfsmap_info        *info = priv;
 373         struct xfs_rmap_irec            irec;
 374         xfs_daddr_t                     rec_daddr;
 375
 376         rec_daddr = XFS_AGB_TO_DADDR(mp, cur->bc_ag.pag->pag_agno,
 377                         rec->ar_startblock);
 378
 379         irec.rm_startblock = rec->ar_startblock;
 380         irec.rm_blockcount = rec->ar_blockcount;
 381         irec.rm_owner = XFS_RMAP_OWN_NULL;      /* "free" */
 382         irec.rm_offset = 0;
 383         irec.rm_flags = 0;
 384
 385         return xfs_getfsmap_helper(cur->bc_tp, info, &irec, rec_daddr);
 386 }
 387
 388 /* Set rmap flags based on the getfsmap flags */
 389 static void
 390 xfs_getfsmap_set_irec_flags(
 391         struct xfs_rmap_irec    *irec,
 392         const struct xfs_fsmap  *fmr)
 393 {
 394         irec->rm_flags = 0;
 395         if (fmr->fmr_flags & FMR_OF_ATTR_FORK)
 396                 irec->rm_flags |= XFS_RMAP_ATTR_FORK;
 397         if (fmr->fmr_flags & FMR_OF_EXTENT_MAP)
 398                 irec->rm_flags |= XFS_RMAP_BMBT_BLOCK;
 399         if (fmr->fmr_flags & FMR_OF_PREALLOC)
 400                 irec->rm_flags |= XFS_RMAP_UNWRITTEN;
 401 }
 402
 403 /* Execute a getfsmap query against the log device. */
 404 STATIC int
 405 xfs_getfsmap_logdev(
 406         struct xfs_trans                *tp,
 407         const struct xfs_fsmap          *keys,
 408         struct xfs_getfsmap_info        *info)
 409 {
 410         struct xfs_mount                *mp = tp->t_mountp;
 411         struct xfs_rmap_irec            rmap;
 412         int                             error;
 413
 414         /* Set up search keys */
 415         info->low.rm_startblock = XFS_BB_TO_FSBT(mp, keys[0].fmr_physical);
 416         info->low.rm_offset = XFS_BB_TO_FSBT(mp, keys[0].fmr_offset);
 417         error = xfs_fsmap_owner_to_rmap(&info->low, keys);
 418         if (error)
 419                 return error;
 420         info->low.rm_blockcount = 0;
 421         xfs_getfsmap_set_irec_flags(&info->low, &keys[0]);
 422
 423         error = xfs_fsmap_owner_to_rmap(&info->high, keys + 1);
 424         if (error)
 425                 return error;
 426         info->high.rm_startblock = -1U;
 427         info->high.rm_owner = ULLONG_MAX;
 428         info->high.rm_offset = ULLONG_MAX;
 429         info->high.rm_blockcount = 0;
 430         info->high.rm_flags = XFS_RMAP_KEY_FLAGS | XFS_RMAP_REC_FLAGS;
 431         info->missing_owner = XFS_FMR_OWN_FREE;
 432
 433         trace_xfs_fsmap_low_key(mp, info->dev, NULLAGNUMBER, &info->low);
 434         trace_xfs_fsmap_high_key(mp, info->dev, NULLAGNUMBER, &info->high);
 435
 436         if (keys[0].fmr_physical > 0)
 437                 return 0;
 438
 439         /* Fabricate an rmap entry for the external log device. */
 440         rmap.rm_startblock = 0;
 441         rmap.rm_blockcount = mp->m_sb.sb_logblocks;
 442         rmap.rm_owner = XFS_RMAP_OWN_LOG;
 443         rmap.rm_offset = 0;
 444         rmap.rm_flags = 0;
 445
 446         return xfs_getfsmap_helper(tp, info, &rmap, 0);
 447 }
 448
 449 #ifdef CONFIG_XFS_RT
 450 /* Transform a rtbitmap "record" into a fsmap */
 451 STATIC int
 452 xfs_getfsmap_rtdev_rtbitmap_helper(
 453         struct xfs_mount                *mp,
 454         struct xfs_trans                *tp,
 455         const struct xfs_rtalloc_rec    *rec,
 456         void                            *priv)
 457 {
 458         struct xfs_getfsmap_info        *info = priv;
 459         struct xfs_rmap_irec            irec;
 460         xfs_daddr_t                     rec_daddr;
 461
 462         irec.rm_startblock = rec->ar_startext * mp->m_sb.sb_rextsize;
 463         rec_daddr = XFS_FSB_TO_BB(mp, irec.rm_startblock);
 464         irec.rm_blockcount = rec->ar_extcount * mp->m_sb.sb_rextsize;
 465         irec.rm_owner = XFS_RMAP_OWN_NULL;      /* "free" */
 466         irec.rm_offset = 0;
 467         irec.rm_flags = 0;
 468
 469         return xfs_getfsmap_helper(tp, info, &irec, rec_daddr);
 470 }
 471
 472 /* Execute a getfsmap query against the realtime device. */
 473 STATIC int
 474 __xfs_getfsmap_rtdev(
 475         struct xfs_trans                *tp,
 476         const struct xfs_fsmap          *keys,
 477         int                             (*query_fn)(struct xfs_trans *,
 478                                                     struct xfs_getfsmap_info *),
 479         struct xfs_getfsmap_info        *info)
 480 {
 481         struct xfs_mount                *mp = tp->t_mountp;
 482         xfs_fsblock_t                   start_fsb;
 483         xfs_fsblock_t                   end_fsb;
 484         uint64_t                        eofs;
 485         int                             error = 0;
 486
 487         eofs = XFS_FSB_TO_BB(mp, mp->m_sb.sb_rblocks);
 488         if (keys[0].fmr_physical >= eofs)
 489                 return 0;
 490         start_fsb = XFS_BB_TO_FSBT(mp, keys[0].fmr_physical);
 491         end_fsb = XFS_BB_TO_FSB(mp, min(eofs - 1, keys[1].fmr_physical));
 492
 493         /* Set up search keys */
 494         info->low.rm_startblock = start_fsb;
 495         error = xfs_fsmap_owner_to_rmap(&info->low, &keys[0]);
 496         if (error)
 497                 return error;
 498         info->low.rm_offset = XFS_BB_TO_FSBT(mp, keys[0].fmr_offset);
 499         info->low.rm_blockcount = 0;
 500         xfs_getfsmap_set_irec_flags(&info->low, &keys[0]);
 501
 502         info->high.rm_startblock = end_fsb;
 503         error = xfs_fsmap_owner_to_rmap(&info->high, &keys[1]);
 504         if (error)
 505                 return error;
 506         info->high.rm_offset = XFS_BB_TO_FSBT(mp, keys[1].fmr_offset);
 507         info->high.rm_blockcount = 0;
 508         xfs_getfsmap_set_irec_flags(&info->high, &keys[1]);
 509
 510         trace_xfs_fsmap_low_key(mp, info->dev, NULLAGNUMBER, &info->low);
 511         trace_xfs_fsmap_high_key(mp, info->dev, NULLAGNUMBER, &info->high);
 512
 513         return query_fn(tp, info);
 514 }
 515
 516 /* Actually query the realtime bitmap. */
 517 STATIC int
 518 xfs_getfsmap_rtdev_rtbitmap_query(
 519         struct xfs_trans                *tp,
 520         struct xfs_getfsmap_info        *info)
 521 {
 522         struct xfs_rtalloc_rec          alow = { 0 };
 523         struct xfs_rtalloc_rec          ahigh = { 0 };
 524         struct xfs_mount                *mp = tp->t_mountp;
 525         int                             error;
 526
 527         xfs_ilock(mp->m_rbmip, XFS_ILOCK_SHARED);
 528
 529         /*
 530          * Set up query parameters to return free rtextents covering the range
 531          * we want.
 532          */
 533         alow.ar_startext = info->low.rm_startblock;
 534         ahigh.ar_startext = info->high.rm_startblock;
 535         do_div(alow.ar_startext, mp->m_sb.sb_rextsize);
 536         if (do_div(ahigh.ar_startext, mp->m_sb.sb_rextsize))
 537                 ahigh.ar_startext++;
 538         error = xfs_rtalloc_query_range(mp, tp, &alow, &ahigh,
 539                         xfs_getfsmap_rtdev_rtbitmap_helper, info);
 540         if (error)
 541                 goto err;
 542
 543         /*
 544          * Report any gaps at the end of the rtbitmap by simulating a null
 545          * rmap starting at the block after the end of the query range.
 546          */
 547         info->last = true;
 548         ahigh.ar_startext = min(mp->m_sb.sb_rextents, ahigh.ar_startext);
 549
 550         error = xfs_getfsmap_rtdev_rtbitmap_helper(mp, tp, &ahigh, info);
 551         if (error)
 552                 goto err;
 553 err:
 554         xfs_iunlock(mp->m_rbmip, XFS_ILOCK_SHARED);
 555         return error;
 556 }
 557
 558 /* Execute a getfsmap query against the realtime device rtbitmap. */
 559 STATIC int
 560 xfs_getfsmap_rtdev_rtbitmap(
 561         struct xfs_trans                *tp,
 562         const struct xfs_fsmap          *keys,
 563         struct xfs_getfsmap_info        *info)
 564 {
 565         info->missing_owner = XFS_FMR_OWN_UNKNOWN;
 566         return __xfs_getfsmap_rtdev(tp, keys, xfs_getfsmap_rtdev_rtbitmap_query,
 567                         info);
 568 }
 569 #endif /* CONFIG_XFS_RT */
 570
 571 /* Execute a getfsmap query against the regular data device. */
 572 STATIC int
 573 __xfs_getfsmap_datadev(
 574         struct xfs_trans                *tp,
 575         const struct xfs_fsmap          *keys,
 576         struct xfs_getfsmap_info        *info,
 577         int                             (*query_fn)(struct xfs_trans *,
 578                                                     struct xfs_getfsmap_info *,
 579                                                     struct xfs_btree_cur **,
 580                                                     void *),
 581         void                            *priv)
 582 {
 583         struct xfs_mount                *mp = tp->t_mountp;
 584         struct xfs_perag                *pag;
 585         struct xfs_btree_cur            *bt_cur = NULL;
 586         xfs_fsblock_t                   start_fsb;
 587         xfs_fsblock_t                   end_fsb;
 588         xfs_agnumber_t                  start_ag;
 589         xfs_agnumber_t                  end_ag;
 590         uint64_t                        eofs;
 591         int                             error = 0;
 592
 593         eofs = XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);
 594         if (keys[0].fmr_physical >= eofs)
 595                 return 0;
 596         start_fsb = XFS_DADDR_TO_FSB(mp, keys[0].fmr_physical);
 597         end_fsb = XFS_DADDR_TO_FSB(mp, min(eofs - 1, keys[1].fmr_physical));
 598
 599         /*
 600          * Convert the fsmap low/high keys to AG based keys.  Initialize
 601          * low to the fsmap low key and max out the high key to the end
 602          * of the AG.
 603          */
 604         info->low.rm_startblock = XFS_FSB_TO_AGBNO(mp, start_fsb);
 605         info->low.rm_offset = XFS_BB_TO_FSBT(mp, keys[0].fmr_offset);
 606         error = xfs_fsmap_owner_to_rmap(&info->low, &keys[0]);
 607         if (error)
 608                 return error;
 609         info->low.rm_blockcount = 0;
 610         xfs_getfsmap_set_irec_flags(&info->low, &keys[0]);
 611
 612         info->high.rm_startblock = -1U;
 613         info->high.rm_owner = ULLONG_MAX;
 614         info->high.rm_offset = ULLONG_MAX;
 615         info->high.rm_blockcount = 0;
 616         info->high.rm_flags = XFS_RMAP_KEY_FLAGS | XFS_RMAP_REC_FLAGS;
 617
 618         start_ag = XFS_FSB_TO_AGNO(mp, start_fsb);
 619         end_ag = XFS_FSB_TO_AGNO(mp, end_fsb);
 620
 621         for_each_perag_range(mp, start_ag, end_ag, pag) {
 622                 /*
 623                  * Set the AG high key from the fsmap high key if this
 624                  * is the last AG that we're querying.
 625                  */
 626                 info->pag = pag;
 627                 if (pag->pag_agno == end_ag) {
 628                         info->high.rm_startblock = XFS_FSB_TO_AGBNO(mp,
 629                                         end_fsb);
 630                         info->high.rm_offset = XFS_BB_TO_FSBT(mp,
 631                                         keys[1].fmr_offset);
 632                         error = xfs_fsmap_owner_to_rmap(&info->high, &keys[1]);
 633                         if (error)
 634                                 break;
 635                         xfs_getfsmap_set_irec_flags(&info->high, &keys[1]);
 636                 }
 637
 638                 if (bt_cur) {
 639                         xfs_btree_del_cursor(bt_cur, XFS_BTREE_NOERROR);
 640                         bt_cur = NULL;
 641                         xfs_trans_brelse(tp, info->agf_bp);
 642                         info->agf_bp = NULL;
 643                 }
 644
 645                 error = xfs_alloc_read_agf(mp, tp, pag->pag_agno, 0,
 646                                 &info->agf_bp);
 647                 if (error)
 648                         break;
 649
 650                 trace_xfs_fsmap_low_key(mp, info->dev, pag->pag_agno,
 651                                 &info->low);
 652                 trace_xfs_fsmap_high_key(mp, info->dev, pag->pag_agno,
 653                                 &info->high);
 654
 655                 error = query_fn(tp, info, &bt_cur, priv);
 656                 if (error)
 657                         break;
 658
 659                 /*
 660                  * Set the AG low key to the start of the AG prior to
 661                  * moving on to the next AG.
 662                  */
 663                 if (pag->pag_agno == start_ag) {
 664                         info->low.rm_startblock = 0;
 665                         info->low.rm_owner = 0;
 666                         info->low.rm_offset = 0;
 667                         info->low.rm_flags = 0;
 668                 }
 669
 670                 /*
 671                  * If this is the last AG, report any gap at the end of it
 672                  * before we drop the reference to the perag when the loop
 673                  * terminates.
 674                  */
 675                 if (pag->pag_agno == end_ag) {
 676                         info->last = true;
 677                         error = query_fn(tp, info, &bt_cur, priv);
 678                         if (error)
 679                                 break;
 680                 }
 681                 info->pag = NULL;
 682         }
 683
 684         if (bt_cur)
 685                 xfs_btree_del_cursor(bt_cur, error < 0 ? XFS_BTREE_ERROR :
 686                                                          XFS_BTREE_NOERROR);
 687         if (info->agf_bp) {
 688                 xfs_trans_brelse(tp, info->agf_bp);
 689                 info->agf_bp = NULL;
 690         }
 691         if (info->pag) {
 692                 xfs_perag_put(info->pag);
 693                 info->pag = NULL;
 694         } else if (pag) {
 695                 /* loop termination case */
 696                 xfs_perag_put(pag);
 697         }
 698
 699         return error;
 700 }
 701
 702 /* Actually query the rmap btree. */
 703 STATIC int
 704 xfs_getfsmap_datadev_rmapbt_query(
 705         struct xfs_trans                *tp,
 706         struct xfs_getfsmap_info        *info,
 707         struct xfs_btree_cur            **curpp,
 708         void                            *priv)
 709 {
 710         /* Report any gap at the end of the last AG. */
 711         if (info->last)
 712                 return xfs_getfsmap_datadev_helper(*curpp, &info->high, info);
 713
 714         /* Allocate cursor for this AG and query_range it. */
 715         *curpp = xfs_rmapbt_init_cursor(tp->t_mountp, tp, info->agf_bp,
 716                         info->pag);
 717         return xfs_rmap_query_range(*curpp, &info->low, &info->high,
 718                         xfs_getfsmap_datadev_helper, info);
 719 }
 720
 721 /* Execute a getfsmap query against the regular data device rmapbt. */
 722 STATIC int
 723 xfs_getfsmap_datadev_rmapbt(
 724         struct xfs_trans                *tp,
 725         const struct xfs_fsmap          *keys,
 726         struct xfs_getfsmap_info        *info)
 727 {
 728         info->missing_owner = XFS_FMR_OWN_FREE;
 729         return __xfs_getfsmap_datadev(tp, keys, info,
 730                         xfs_getfsmap_datadev_rmapbt_query, NULL);
 731 }
 732
 733 /* Actually query the bno btree. */
 734 STATIC int
 735 xfs_getfsmap_datadev_bnobt_query(
 736         struct xfs_trans                *tp,
 737         struct xfs_getfsmap_info        *info,
 738         struct xfs_btree_cur            **curpp,
 739         void                            *priv)
 740 {
 741         struct xfs_alloc_rec_incore     *key = priv;
 742
 743         /* Report any gap at the end of the last AG. */
 744         if (info->last)
 745                 return xfs_getfsmap_datadev_bnobt_helper(*curpp, &key[1], info);
 746
 747         /* Allocate cursor for this AG and query_range it. */
 748         *curpp = xfs_allocbt_init_cursor(tp->t_mountp, tp, info->agf_bp,
 749                         info->pag, XFS_BTNUM_BNO);
 750         key->ar_startblock = info->low.rm_startblock;
 751         key[1].ar_startblock = info->high.rm_startblock;
 752         return xfs_alloc_query_range(*curpp, key, &key[1],
 753                         xfs_getfsmap_datadev_bnobt_helper, info);
 754 }
 755
 756 /* Execute a getfsmap query against the regular data device's bnobt. */
 757 STATIC int
 758 xfs_getfsmap_datadev_bnobt(
 759         struct xfs_trans                *tp,
 760         const struct xfs_fsmap          *keys,
 761         struct xfs_getfsmap_info        *info)
 762 {
 763         struct xfs_alloc_rec_incore     akeys[2];
 764
 765         info->missing_owner = XFS_FMR_OWN_UNKNOWN;
 766         return __xfs_getfsmap_datadev(tp, keys, info,
 767                         xfs_getfsmap_datadev_bnobt_query, &akeys[0]);
 768 }
 769
 770 /* Do we recognize the device? */
 771 STATIC bool
 772 xfs_getfsmap_is_valid_device(
 773         struct xfs_mount        *mp,
 774         struct xfs_fsmap        *fm)
 775 {
 776         if (fm->fmr_device == 0 || fm->fmr_device == UINT_MAX ||
 777             fm->fmr_device == new_encode_dev(mp->m_ddev_targp->bt_dev))
 778                 return true;
 779         if (mp->m_logdev_targp &&
 780             fm->fmr_device == new_encode_dev(mp->m_logdev_targp->bt_dev))
 781                 return true;
 782         if (mp->m_rtdev_targp &&
 783             fm->fmr_device == new_encode_dev(mp->m_rtdev_targp->bt_dev))
 784                 return true;
 785         return false;
 786 }
 787
 788 /* Ensure that the low key is less than the high key. */
 789 STATIC bool
 790 xfs_getfsmap_check_keys(
 791         struct xfs_fsmap                *low_key,
 792         struct xfs_fsmap                *high_key)
 793 {
 794         if (low_key->fmr_device > high_key->fmr_device)
 795                 return false;
 796         if (low_key->fmr_device < high_key->fmr_device)
 797                 return true;
 798
 799         if (low_key->fmr_physical > high_key->fmr_physical)
 800                 return false;
 801         if (low_key->fmr_physical < high_key->fmr_physical)
 802                 return true;
 803
 804         if (low_key->fmr_owner > high_key->fmr_owner)
 805                 return false;
 806         if (low_key->fmr_owner < high_key->fmr_owner)
 807                 return true;
 808
 809         if (low_key->fmr_offset > high_key->fmr_offset)
 810                 return false;
 811         if (low_key->fmr_offset < high_key->fmr_offset)
 812                 return true;
 813
 814         return false;
 815 }
 816
 817 /*
 818  * There are only two devices if we didn't configure RT devices at build time.
 819  */
 820 #ifdef CONFIG_XFS_RT
 821 #define XFS_GETFSMAP_DEVS       3
 822 #else
 823 #define XFS_GETFSMAP_DEVS       2
 824 #endif /* CONFIG_XFS_RT */
 825
 826 /*
 827  * Get filesystem's extents as described in head, and format for output. Fills
 828  * in the supplied records array until there are no more reverse mappings to
 829  * return or head.fmh_entries == head.fmh_count.  In the second case, this
 830  * function returns -ECANCELED to indicate that more records would have been
 831  * returned.
 832  *
 833  * Key to Confusion
 834  * ----------------
 835  * There are multiple levels of keys and counters at work here:
 836  * xfs_fsmap_head.fmh_keys      -- low and high fsmap keys passed in;
 837  *                                 these reflect fs-wide sector addrs.
 838  * dkeys                        -- fmh_keys used to query each device;
 839  *                                 these are fmh_keys but w/ the low key
 840  *                                 bumped up by fmr_length.
 841  * xfs_getfsmap_info.next_daddr -- next disk addr we expect to see; this
 842  *                                 is how we detect gaps in the fsmap
 843                                    records and report them.
 844  * xfs_getfsmap_info.low/high   -- per-AG low/high keys computed from
 845  *                                 dkeys; used to query the metadata.
 846  */
 847 int
 848 xfs_getfsmap(
 849         struct xfs_mount                *mp,
 850         struct xfs_fsmap_head           *head,
 851         struct fsmap                    *fsmap_recs)
 852 {
 853         struct xfs_trans                *tp = NULL;
 854         struct xfs_fsmap                dkeys[2];       /* per-dev keys */
 855         struct xfs_getfsmap_dev         handlers[XFS_GETFSMAP_DEVS];
 856         struct xfs_getfsmap_info        info = { NULL };
 857         bool                            use_rmap;
 858         int                             i;
 859         int                             error = 0;
 860
 861         if (head->fmh_iflags & ~FMH_IF_VALID)
 862                 return -EINVAL;
 863         if (!xfs_getfsmap_is_valid_device(mp, &head->fmh_keys[0]) ||
 864             !xfs_getfsmap_is_valid_device(mp, &head->fmh_keys[1]))
 865                 return -EINVAL;
 866
 867         use_rmap = xfs_has_rmapbt(mp) &&
 868                    has_capability_noaudit(current, CAP_SYS_ADMIN);
 869         head->fmh_entries = 0;
 870
 871         /* Set up our device handlers. */
 872         memset(handlers, 0, sizeof(handlers));
 873         handlers[0].dev = new_encode_dev(mp->m_ddev_targp->bt_dev);
 874         if (use_rmap)
 875                 handlers[0].fn = xfs_getfsmap_datadev_rmapbt;
 876         else
 877                 handlers[0].fn = xfs_getfsmap_datadev_bnobt;
 878         if (mp->m_logdev_targp != mp->m_ddev_targp) {
 879                 handlers[1].dev = new_encode_dev(mp->m_logdev_targp->bt_dev);
 880                 handlers[1].fn = xfs_getfsmap_logdev;
 881         }
 882 #ifdef CONFIG_XFS_RT
 883         if (mp->m_rtdev_targp) {
 884                 handlers[2].dev = new_encode_dev(mp->m_rtdev_targp->bt_dev);
 885                 handlers[2].fn = xfs_getfsmap_rtdev_rtbitmap;
 886         }
 887 #endif /* CONFIG_XFS_RT */
 888
 889         xfs_sort(handlers, XFS_GETFSMAP_DEVS, sizeof(struct xfs_getfsmap_dev),
 890                         xfs_getfsmap_dev_compare);
 891
 892         /*
 893          * To continue where we left off, we allow userspace to use the
 894          * last mapping from a previous call as the low key of the next.
 895          * This is identified by a non-zero length in the low key. We
 896          * have to increment the low key in this scenario to ensure we
 897          * don't return the same mapping again, and instead return the
 898          * very next mapping.
 899          *
 900          * If the low key mapping refers to file data, the same physical
 901          * blocks could be mapped to several other files/offsets.
 902          * According to rmapbt record ordering, the minimal next
 903          * possible record for the block range is the next starting
 904          * offset in the same inode. Therefore, bump the file offset to
 905          * continue the search appropriately.  For all other low key
 906          * mapping types (attr blocks, metadata), bump the physical
 907          * offset as there can be no other mapping for the same physical
 908          * block range.
 909          */
 910         dkeys[0] = head->fmh_keys[0];
 911         if (dkeys[0].fmr_flags & (FMR_OF_SPECIAL_OWNER | FMR_OF_EXTENT_MAP)) {
 912                 dkeys[0].fmr_physical += dkeys[0].fmr_length;
 913                 dkeys[0].fmr_owner = 0;
 914                 if (dkeys[0].fmr_offset)
 915                         return -EINVAL;
 916         } else
 917                 dkeys[0].fmr_offset += dkeys[0].fmr_length;
 918         dkeys[0].fmr_length = 0;
 919         memset(&dkeys[1], 0xFF, sizeof(struct xfs_fsmap));
 920
 921         if (!xfs_getfsmap_check_keys(dkeys, &head->fmh_keys[1]))
 922                 return -EINVAL;
 923
 924         info.next_daddr = head->fmh_keys[0].fmr_physical +
 925                           head->fmh_keys[0].fmr_length;
 926         info.fsmap_recs = fsmap_recs;
 927         info.head = head;
 928
 929         /* For each device we support... */
 930         for (i = 0; i < XFS_GETFSMAP_DEVS; i++) {
 931                 /* Is this device within the range the user asked for? */
 932                 if (!handlers[i].fn)
 933                         continue;
 934                 if (head->fmh_keys[0].fmr_device > handlers[i].dev)
 935                         continue;
 936                 if (head->fmh_keys[1].fmr_device < handlers[i].dev)
 937                         break;
 938
 939                 /*
 940                  * If this device number matches the high key, we have
 941                  * to pass the high key to the handler to limit the
 942                  * query results.  If the device number exceeds the
 943                  * low key, zero out the low key so that we get
 944                  * everything from the beginning.
 945                  */
 946                 if (handlers[i].dev == head->fmh_keys[1].fmr_device)
 947                         dkeys[1] = head->fmh_keys[1];
 948                 if (handlers[i].dev > head->fmh_keys[0].fmr_device)
 949                         memset(&dkeys[0], 0, sizeof(struct xfs_fsmap));
 950
 951                 /*
 952                  * Grab an empty transaction so that we can use its recursive
 953                  * buffer locking abilities to detect cycles in the rmapbt
 954                  * without deadlocking.
 955                  */
 956                 error = xfs_trans_alloc_empty(mp, &tp);
 957                 if (error)
 958                         break;
 959
 960                 info.dev = handlers[i].dev;
 961                 info.last = false;
 962                 info.pag = NULL;
 963                 error = handlers[i].fn(tp, dkeys, &info);
 964                 if (error)
 965                         break;
 966                 xfs_trans_cancel(tp);
 967                 tp = NULL;
 968                 info.next_daddr = 0;
 969         }
 970
 971         if (tp)
 972                 xfs_trans_cancel(tp);
 973         head->fmh_oflags = FMH_OF_DEV_T;
 974         return error;
 975 }