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