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