fs/xfs/xfs_fsmap.c

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