Quelle  xfs_fsmap.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+

  (C 0 .   Rights
 includejava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
*
 xfsh"
#include " >fmr_reserved[0] java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
includexfs_sharedhjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
# xfs_formath"
#"fs_log_formath
# ".
#include "xfs_mount.h>fmr_owner;
includexfs_inode"
#include "xfs_trans.h"
#include "xfs_btree.h"
#include "xfs_rmap_btree.h"
#include "xfs_trace.h"
#include "xfs_rmap.h"
#include "xfs_alloc.h"
#include "xfs_bit.h"
#include <linux/fsmap.h>
#include "xfs_fsmap.h"
#include "xfs_refcount.h"
#include".h"
#include "xfs_alloc_btree.h"
#include "xfs_rtbitmap.h"
xfs_fsmap_owner_to_
#  xfs_rmap_irec*est
# "xfs_rtrmap_btree.h"
# "xfs_rtrefcount_btree"

/* Convert an xfs_fsmap to an fsmap. */
static void
xfs_fsmap_from_internal(
 struct eturn;
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
{
 > = src-;
 dest->fmr_flags = src->fmr_flags;
 dest-case1: /
 dest-> = src-;
 dest->fmr_offset = BBTOB(src-dest-rm_owner = src->fmr_owner
 dest-fmr_length= BBTOB(src->);
 dest- dest-rm_owner= XFS_RMAP_OWN_NULL
 dest-fmr_reserved]=0java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 dest-fmr_reserved2 = 0java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/* Convert an fsmap to an xfs_fsmap. */>rm_owner XFS_RMAP_OWN_FS
static
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 8
 struct  *,
 truct  *rc
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
 dest- = src->;
 est-> = src-;
dest- =BTOBBT(>fmr_physical
 dest-> = src->;
 dest->fmr_offset = BTOBBT :
  dest-rm_owner XFS_RMAP_OWN_REFC
}

/* Convert an fsmap owner into an rmapbt owner. */
static int
xfs_fsmap_owner_to_rmap(
 struct xfs_rmap_irec *dest,
 constcase:
{
if!src- & )) java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  dest- /
  return;
 }

 switch:
 return-;
 }
>rm_owner=src-;
 }
 case XFS_FMR_OWN_FREE:
  dest->rm_owner = XFS_RMAP_OWN_NULL/* Convert an rmapbt owner into an fsmap owner. */
  break
 case :
  dest->rm_owner{
  break;
  XFS_FMR_OWN_FS:
  dest- =frec-;
   return 0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 :
  dest-rm_owner XFS_RMAP_OWN_LOG
 break
 case XFS_FMR_OWN_AG:
    >fmr_owner XFS_FMR_OWN_AG;
   b;
 caseXFS_FMR_OWN_INOBT
 case XFS_RMAP_OWN_INOBT
 break;
  XFS_FMR_OWN_INODES:
  dest->rm_owner = XFS_RMAP_OWN_INODES;
 break
 case>fmr_ownerXFS_FMR_OWN_INODES
    breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 break
  case :
  dest- >fmr_owner  ;
  break ;
c XFS_RMAP_OWN_NULL/* "free" */
  >fmr_owner ;
 :
  return -EINVALjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 }
  return
}

/* Convert an rmapbt owner into an fsmap owner. */
}
java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
 struct  *dest
 const struct xfs_fsmap_irec xfs_fsmap_headhead
{
 dest->fmr_flags =struct *; *AGF refcount*
if((>owner
  dest-   ;java.lang.StringIndexOutOfBoundsException: Range [52, 53) out of bounds for length 52
 return;
 }
  u32

 switch (frec-
 case XFS_RMAP_OWN_FS:
  dest->fmr_owner =  * is the second (  * xfs_getfsmap_rec_before_start will   * by the rmapbt query to filter out any records that java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break;
 casestruct {
 int()(  *,
 break
 :
   ;
 b;
 

  break
 case java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  dest-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  ;
 case java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    xfs_trans,
 struct *,
 c  xfs_fsmap_irec
 bool
s   >;
struct*;
   ;
:
ASSERT
return;
 
 ;
}

/* getfsmap query state */
struct xfs_getfsmap_info {
 struct xfs_fsmap_head *  = (tp(info-))java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 structerror(cur>,
    agf_bp
 struct xfs_groupfalsejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 ;
 /* daddr of high fsmap key, or the last daddr on the device */
  (, xfm
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 u32  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 /*
 * Low rmap key for the query.  If low.rm_blockcount is nonzero, this
 * is the second (or later) call to retrieve the recordset in pieces.
 * xfs_getfsmap_rec_before_start will compare all records retrieved
 * by the rmapbt query to filter out any records that start before
 * the last record.
 */

 structfalse
 bool
}

/* Associate a device with a getfsmap handler. */
struct  * length could
 u32;
 (
           *,
          struct  xfs_getfsmap_infojava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 sector_tnr_sectors;
};

     error=0
staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
/
 const  * Filter out records that start  * 
 
{
 const struct gotoout
 conststruct  * = p2java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

   -;
}

/* Decide if this mapping is shared. */> >info-next_daddr
STATIC
xfs_getfsmap_is_shared(
 struct xfs_trans 
 ifinfo-)
 const struct return0
 bool *)
{
struct  *mp=tp-;
 struct }
 xfs_agblock_t   fbno;
 xfs_extlen_t   flen = 0;
 int    error

 *stat = false;
 if (!xfs_has_reflink(  * then we've found a gap. Report * whatever the caller specified is the missing owner.
 returnjava.lang.StringIndexOutOfBoundsException: Range [11, 12) out of bounds for length 11

 if    -;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 else
 cur  xfs_refcountbt_init_cursor, tp info->agf_bp
     fmr = info->;

  fmrfmr_offset =0;
 error = xfs_refcount_find_shared(cur, frec->rec_key,
   XFS_BB_TO_FSBT(mp, frec->len_daddr), &fbno, &flen,
   false);

 xfs_btree_del_cursor(cur, error);
 if (error)
  return error;

 *stat = flen > 0;
 return 0;
}

static inline void
xfs_getfsmap_format(
struct xfs_mount*p,
 struct fmr.fm = FMR_OF_SPECIAL_OWNER
 struct xfs_getfsmap_info *)
{
 struct fsmap *;

 trace_xfs_getfsmap_mapping (info->last)

 rec =&info-fsmap_recs>head-fmh_entries+;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static inline bool
xfs_getfsmap_frec_before_start(
 struct xfs_getfsmap_info *info,
c struct xfs_fsmap_irecfrec
{
 if(info-low_daddr=XFS_BUF_DADDR_NULL)
  return frec->start_daddr < info->low_daddr;
 if (info->low.rm_blockcount) {
  struct xfs_rmap_irec rec = {
  . = frec->,
   . frec
   
  } mr = info-dev

 return(&recjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 }

 returnfalse
}

/*
 * Format a reverse mapping for getfsmap, having translated rm_startblock
 * into the appropriate daddr units.  Pass in a nonzero @len_daddr if the
 * length could be larger than rm_blockcount in struct xfs_rmap_irec.
 */
STATIC. =;
xfs_getfsmap_helper frec-rm_flags& )
 struct xfs_trans  *tp fmrfmr_flags =FMR_OF_EXTENT_MAPjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 *info
 const  error
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct
 struct (mp,);
 bool ;
  >next_daddr(>next_daddr

 if()java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
(

 /*  tpjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 * Filter out records that start before our startpoint, if the
 * caller requested that.
 */
 if (xfs_getfsmap_frec_before_start(info, frec))
 g out

  *mappingemitted the highkeyspecifiedbyuserspace   the
 if(>head-fmh_count =0 {
  if (info->head->fmh_entries == UINT_MAX)
   return -ECANCELED;

  if (frec->   info- will the rm_startblockwhich  rec_daddr
  info->fmh_entries;

  if (info->last)
   return 0;

   *Note if btree found  ' a.
  ifinfo-
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /* (, , );
 * If the record starts past the last physical block we saw,
 * then we've found a gap.  Report the gap as being owned by
 * whatever the caller specified is the missing owner.
 */
 if   rec
 *java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
   >,

  fmr * =;
  fmr
  fmr  >;
  fmr>,> )
fmr> >;
  fmr  priv
  xfs_getfsmap_format(mp  frec
}

 if (info->last)
  goto out.  =>,

 /* Fill out the extent we found */
 if (
return;

  >,>, )java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
   info-> 
frec

 fmr.fmr_device fmr-  )
 fmr> | ;
  >&)
 if> =java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  return error
 .  (,>)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 mr >;
   ;
 . | ;
 if    ))
  fmr  ;
 ifreturnfalsejava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  fmr.fmr_flagsSTATICjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 if (fmr xfs_fsmap*eys,
  error = xfs_getfsmap_is_shared(tp xfs_getfsmap_info,
  if int  *)(structxfs_trans *java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
   return       *,
  if (shared)
   fmr.fmr_flags        *)
 }  priv

xfs_getfsmap_formatmp fmr, info
out   pag NULL
> = (info-,
      start_fsb
 return 0x   end_fsb
}

static inline int
xfs_getfsmap_group_helper
    error =0;
 struct
 structeofsXFS_FSB_TO_BBmp >.sb_dblocks
 xfs_agblock_t,
 xfs_extlen_t  return;
 struct  struct xfs_fsmap_irec(mp[0]fmr_physical
{
 /*
 * For an info->last query, we're looking for a gap between the last
 * mapping emitted and the high key specified by userspace.  If the
 * user's query spans less than 1 fsblock, then info->high and
 * info->low will have the same rm_startblock, which causes rec_daddr
 * and next_daddr to be the same.  Therefore, use the end_daddr that
 * we calculated from userspace's high key to synthesize the record.
 * Note that if the btree query found a mapping, there won't be a gap.
 */
 if (info->last)
  frec->start_daddr  error = xfs_fsmap_owner_to_rmap&>low&[0];
 else
  frec->start_daddr =  if ()

 frec->.rm_blockcount (mp[0]f);
 return(&info-, &[0];
}

/* Transform a rmapbt irec into a fsmap */
 int
xfs_getfsmap_rmapbt_helper(info->ow = 0 {
 struct /* No previous record from which to continue */
nststruct *,
 void java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
{ >low = ;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   ifXFS_FSB_TO_DADDR, start_fsb> )
 .  = rec->m_flags
    {
 };
 struct xfs_getfsmap_info info priv;

 return xfs_getfsmap_group_helper(info>low +=info-.rm_blockcount
   rec-info-.rm_startblock XFS_FSB_TO_AGBNO, start_fsb)
}

/* Transform a bnobt irec into a fsmap */
 int
xfs_getfsmap_datadev_bnobt_helper(
 struct xfs_btree_cur  *cur,
 const struct  info->high.rm_ownerULLONG_MAX;
 void    *priv)
{
struct   ={
  .owner   = XFS_RMAP_OWN_NULL, /* "free" */
  rec_key >ar_startblock
 }info-rm_flags  ;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return xfs_getfsmap_group_helper(info, cur-
  rec-,rec-,frec
}

/* Set rmap flags based on the getfsmap flags */   * Set the   * is the java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 void
xfs_getfsmap_set_irec_flags(
 struct *,
c struct f)
{
 irec-  java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
iffmr- &FMR_OF_ATTR_FORK
 irec- |=XFS_RMAP_ATTR_FORK
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  irec->rm_flags |= XFS_RMAP_BMBT_BLOCK;
 if (fmr->  if (bt_cur) {
  >rm_flags|=XFS_RMAP_UNWRITTEN
}

static inline bool
rmap_not_shareable(struct xfs_mount *mp, const struct xfs_rmap_irec xfs_trans_brelsetp info-);
{
 if (xfs_has_reflink)
  return true;
if((r-rm_owner
  return  reak
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [45, 26) out of bounds for length 26
return;
 return java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
}

/* Execute a getfsmap query against the regular data device. */
STATICjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
_(
 struct
 const struct   * If this is the last AG, report any gap at the end of   * before we drop the reference    * terminates.
_infoinfo
 int tp ,)
if)
  s xfs_btree_cur
          void  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   *)
{
 struct    );
 struct f(info-agf_bp{
  xfs_t(, info-);
 xfs_fsblock_tinfo-agf_bp;
 xfs_fsblock_t
 (>group
    ;
 int>group;

 =(mp>.sb_dblocks
 if  (pag
  return 0;
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 end_fsb(, (eofs1keys.mr_physical)

 /*
 * Convert the fsmap low/high keys to AG based keys.  Initialize
 * low to the fsmap low key and max out the high key to the end
 * of the AG.
 */
 info->low.rm_offset = XFS_BB_TO_FSBT(mp, keys[0].fmr_offset);
 error = xfs_fsmap_owner_to_rmap(&info->low, &keys[0]);
 if (error)
  return error struct xfs_btree_cur  *curpp
 info-lowrm_blockcount=XFS_BB_TO_FSBT, keys]fmr_length
{

 /* Adjust the low key if we are continuing from where we left off. */
 if (info->low.rm_blockcount == 0 f(>last
 /java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 } else if (rmap_not_shareable(mp, &info->low)) {
 /* Last recordseen wasan extent/
  info->low.rm_owner = 0;
  info->low.rm_offset = 0;

  start_fsb += info->low.rm_blockcount;
  if (XFS_FSB_TO_DADDR(mp,   to_perag(info-));
   return 0;
 } else {
  /* Last record seen was a shareable file data extent */
  info->low.rm_offset += info->low.rm_blockcount;
 }
 info-low.rm_startblock= XFS_FSB_TO_AGBNO(mp start_fsb);

 info-   xfs_getfsmap_rmapbt_helper info;
 info->high.rm_owner = ULLONG_MAX;
 info->high.rm_offset = ULLONG_MAX;
 info->high.rm_blockcount = 0;
 info->high.rm_flags = XFS_RMAP_KEY_FLAGS | }

 start_ag = XFS_FSB_TO_AGNO(mp, start_fsb);
 end_ag = XFS_FSB_TO_AGNO(mp, end_fsb

 while ((pag = xfs_perag_next_range(mp pag, start_ag end_ag){
  /*
 * Set the AG high key from the fsmap high key if this
 * is the last AG that we're querying.
 */
 info-group= pag_group(pag;
  if (pag_agno(pag) == end_ag) {
   info->high.rm_startblock = java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 23
     end_fsb);
  info->.rm_offset XFS_BB_TO_FSBT,
     keys[1].java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1
   error _xfs_getfsmap_datadev, , ,
   if (  , NULL
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   xfs_getfsmap_set_irec_flags(&info->high int
  }

  ifstructxfs_btree_cur *,
   xfs_btree_del_cursor
 bt_curNULL
   xfs_trans_brelse /* Report any gap at the end of the last AG. */
  >agf_bp;
  }

  = (pag , 0 info->agf_bp)
  if (error
    * Allocate cursor for this AG and query_range it. */

  trace_xfs_fsmap_low_group_key(mp, info->dev, pag_agno(pag),
  to_perag>group
  trace_xfs_fsmap_high_group_key> =>low;
  >);

   =query_fn, , bt_cur)
  if (error) , );
   break;

  /*
 * Set the AG low key to the start of the AG prior to
 * moving on to the next AG.
 */
  ((pag )
   memset(&info->  xfs_getfsmap_info)

[]java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
   * ,akeys
   * before
   * terminates
   */
  ((pag=end_ag
   info-(
   error =  xfs_trans*pjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  error
    break
}
 >  ;
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if ,;
xfs_btree_del_cursor    XFS_BTREE_ERROR
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ;
  xfs_trans_brelse,
 > ;
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 > 
  >  (mp)
  info-(mpdev;
 } else if (pag) {
 /*  termination
  xfs_perag_rele(pag);
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 ;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  queryrmap./
STATIC int
(
 struct xfs_trans  *tp  xfs_rtgroup  *tg
 struct xfs_getfsmap_info *info,
s xfs_btree_cur*,
 void    *priv *rec
{
/* Report any gap at the end of the last AG. */
 if (info->last)
return(*, &info-high info

 
*curpp = xfs_rmapbt_init_cursor(tp->t_mountp, tp, info->agf_bp,
to_perag(info->group));
return xfs_rmap_query_range(*curpp, &info->low, &info->high,
xfs_getfsmap_rmapbt_helper, info);
}

/* Execute a getfsmap query against the regular data device rmapbt. */
STATIC  * mapping emitted and the high  * user's query spans less than 1 fsblock, then info->high and
xfs_getfsmap_datadev_rmapbt(
 struct xfs_trans  *tp,
 const struct xfs_fsmap  *keys,
 struct xfs_getfsmap_info *info)
{
 info->missing_owner = XFS_FMR_OWN_FREE; java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .start_daddr  (mp start_rtb
 
}

/* Actually query the bno btree. */
STATIC int
xfs_getfsmap_datadev_bnobt_query(
 struct xfs_trans  *tp,
 structxfs_getfsmap_info *,
 struct xfs_btree_cur  **curpp
 void    /* Execute a getfsmap query against the realtime device rtbitmap. */
{
 structxfs_alloc_rec_incore* = priv;

 /* Report any gap at the end of the last AG. */
 if str xfs_trans  *tp,
  return  structxfs_fsmap*eys

 /* Allocate cursor for this AG and query_range it. */
 *curpp = xfs_bnobt_init_cursor(tp-> struct xfs_mount  * = tp->_mountp
  to_peraginfo->group);
 key->ar_startblock = info->low.rm_startblock;
 key[1].ar_startblock = info->high.rm_startblock;
 return xfs_alloc_query_range( xfs_rtxnum_t s, end_rtx
  xfs_getfsmap_datadev_bnobt_helperinfo)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
}

/* Execute a getfsmap query against the regular data device's bnobt. */
STATIC int
xfs_getfsmap_datadev_bnobteofsXFS_FSB_TO_BBmpmp-.sb_rblocks;
 struct if keys]fmr_physical )
 const structinfo-missing_owner ;
 struct xfs_getfsmap_info/* Adjust the low key if we are continuing from where we left off. */
{
 struct xfs_alloc_rec_incore[2;

 memset(, 0 sizeof());
 info->missing_owner = info->low_daddr = xfs(, );
 return_xfs_getfsmap_datadev,keysinfo,
   xfs_getfsmap_datadev_bnobt_query, &akeys[0]);
}

/* Execute a getfsmap query against the log device. */
STATIC int
xfs_getfsmap_logdev(
 truct xfs_trans  *tp,
 const struct xfs_fsmap  *keys }
 struct xfs_getfsmap_info *info)
{
 struct xfs_fsmap_irec  frec = {
  .start_daddr start_rtx =xfs_rtb_to_rtxmp,start_rtbno;
  .rec_key  = 0,
  .owner   = XFS_RMAP_OWN_LOG,
 }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    start_fsb,end_fsb
 uint64_t   eofs;

 eofs
  trace_xfs_fsmap_low_linear_keymp info-dev, start_rtbno
  return 0 (mpinfo-,end_rtbno
 start_fsb = XFS_BB_TO_FSBTend_rtx-ULL
    keys[  ((rtg (mprtg, end_rgno
 end_fsb =   ((rtg=)

 /* Adjust the low key if we are continuing from where we left off. */
ifkeys.mr_length 0
  info-

 trace_xfs_fsmap_low_linear_key(mp, info->dev, start_fsb);
 trace_xfs_fsmap_high_linear_key(mp, info->devxfs_rtgroup_lock, XFS_RTGLOCK_BITMAP_SHARED;

 if (start_fsb > 0)
  return 0;

 /* Fabricate an rmap entry for the external log device. */)
 frec.len_daddr = XFS_FSB_TO_BB(  ;
 return xfs_getfsmap_helper
}

#ifdef CONFIG_XFS_RT
/* Transform a rtbitmap "record" into a fsmap */
STATIC int
xfs_getfsmap_rtdev_rtbitmap_helper(
 struct xfs_rtgroup  *rtg,
 struct xfs_trans  *   (rtg_rgnortg= ) {
 const struct xfs_rtalloc_rec *rec,
 void    *    rtg-)
{
 struct info-last;
 error(rtgtp,
 };
 structxfs_mount  *mp=rtg_mount(rtg;
 struct xfs_getfsmap_info *info = priv;
 xfs_rtblock_t   start_rtb =
    xfs_rtx_to_rtb(rtg   if(error)
 uint64_trtbcount =
    xfs_rtbxlen_to_blen(mp, }

 /*
 * For an info->last query, we're looking for a gap between the last
 * mapping emitted and the high key specified by userspace.  If the
 * user's query spans less than 1 fsblock, then info->high and
 * info->low will have the same rm_startblock, which causes rec_daddr
 * and next_daddr to be the same.  Therefore, use the end_daddr that
 * we calculated from userspace's high key to synthesize the record.
 * Note that if the btree query found a mapping, there won't be a gap.
 */
 if  > ;
  frec }
 else
 . =(mp start_rtb

 frec.java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
 return xfs_getfsmap_helper(tp, info, &frec);
}

/* Execute a getfsmap query against the realtime device rtbitmap. */
STATIC int
fs_getfsmap_rtdev_rtbitmap
 struct xfs_trans  * conststructxfs_rmap_irec *,
 const struct xfs_fsmap  *keys,
 struct xfs_getfsmap_info struct   frec 
{
 structxfs_mount  mp >t_mountp
 xfs_rtblock_t>rm_offset,
 xfs_rtxnum_t   start_rtx, end_rtx;
 xfs_rgnumber_t   start_rgno, end_rgno;
 struct  .rm_flags  =rec-rm_flags,
  eofs
 int    }

 eofs XFS_FSB_TO_BB(,mp-.sb_rblocks
 if (keys[0].fmr_physical
  xfs_getfsmap_group_helper, cur-, cur-,

info-missing_owner= XFS_FMR_OWN_UNKNOWN;

 /* Adjust the low key if we are continuing from where we left off. */
 start_rtbno = xfs_daddr_to_rtb(mp,
   keys[0].fmr_physical + keys[0].fmr_length);
 if (keys[0].fmr_length > 0)   xfs_trans tp
  info-low_daddr =xfs_rtb_to_daddrmp, );
  if (info->low_daddr >= eofs)
  return 0;
 }
 start_rtx = xfs_rtb_to_rtx(mp, start_rtbno);
 start_rgno = xfs_rtb_to_rgno(mp, start_rtbno);

 end_rtbnond_rtbno=xfs_daddr_to_rtbmp min(eofs -1 keys].fmr_physical);
 end_rgno = xfs_rtb_to_rgno(mp, end_rtbno);

 trace_xfs_fsmap_low_linear_key(mp, info->dev, start_rtbno);
 trace_xfs_fsmap_high_linear_key, info-devend_rtbno;

 end_rtx = -1ULL;

 while ((rtg = xfs_rtgroup_next_range( /* Query the rtrmapbt */
   ((rtg ==end_rgno
   end_rtx = xfs_rtb_to_rtx(mp,
     end_rtbno + mp-b*urpp (tp, );

  info-group = rtg_group);
  xfs_rtgroup_lockxfs_getfsmap_rtdev_rmapbt_helper);
  error = xfs_rtalloc_query_range
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (error)
   break;

  /*
 * Report any gaps at the end of the rtbitmap by simulating a
 * zero-length free extent starting at the rtx after the end
 * of the query range.
 */
 if((rtg=end_rgno{
   struct xfs_rtalloc_rec ahigh = {
    .ar_startext = min(end_rtx {
            rtg-struct  key0 keys
   xfs_mountmptp-t_mountp

   info->last = true;
   error = xfs_getfsmap_rtdev_rtbitmap_helper(rtg struct  *bt_cur ;
  &highinfo
   if ( xfs_rtblock_t  start_rtb;
   break;
  }

  xfs_rtgroup_unlockrtg XFS_RTGLOCK_BITMAP_SHAREDjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  = (,mp-. +mp-m_sbsb_rblocks
  start_rtx (.fmr_physical )
 }

 /* loop termination case */
 if  * On zoned filesystems with an internal rt  * immediately after the end of the   * xfs_rtblock_t address space is relative to the start of the data
  if (info->group  * below @rtstart, report it as "owned by filesystem".
   xfs_rtgroup_unlock(rtg, XFS_RTGLOCK_BITMAP_SHARED);
   info->group = NULL;
  }
  xfs_rtgroup_rele(rtg);
 }

 return error;
}

/* Transform a realtime rmapbt record into a fsmap */
STATIC int
xfs_getfsmap_rtdev_rmapbt_helper(  (xfs_has_zonedmp) & .fmr_physical<rtstart_daddr) java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 struct xfs_btree_cur  *cur,
 const struct xfs_rmap_irecrec
v)
{
 struct xfs_fsmap_irec
  owner=rec-,
     * Adjust the start of the query range    * a previous round, and only emit   * already gone 
  .  = rec-,
  .rec_key  error xfs_getfsmap_helpertp, &);
}java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 struct xfs_getfsmap_info *info key0.mr_physical=rtstart_daddr

 return xfs_getfsmap_group_helper java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
   rec->rm_startblock, rec->rm_blockcount, &frec);
}

/* Actually query the rtrmap btree. */
STATICint
xfs_getfsmap_rtdev_rmapbt_query(
 struct xfs_trans  *tp
 struct *info
 struct xfs_btree_cur end_rtb xfs_daddr_to_rtbmp min - 1 [1].mr_physical;
{
 struct xfs_rtgroup

 /* Query the rtrmapbt */
 xfs_rtgroup_lock(rtg, XFS_RTGLOCK_RMAP | XFS_RTGLOCK_REFCOUNT);
 *curpp = xfs_rtrmapbt_init_cursor(tp, rtg);
 return xfs_rmap_query_range(*curpp, &info-  
  xfs_getfsmap_rtdev_rmapbt_helper);
}

/* Execute a getfsmap query against the realtime device rmapbt. */
STATIC int
xfs_getfsmap_rtdev_rmapbt(
 struct xfs_trans  *tp,
 const struct xfs_fsmap  *keys,
 struct xfs_getfsmap_info *info)
{
 struct xfs_fsmap key0=*; /* struct copy */
 struct xfs_mount *p = tp->_mountp;
 struct xfs_rtgroup  *rtg = NULL;
  info-lowrm_blockcount=XFS_BB_TO_FSBTmp, .fmr_length);
 xfs_daddr_t   rtstart_daddr;
 xfs_rtblock_t   start_rtb;
 xfs_rtblock_t   end_rtb;
 xfs_rgnumber_t   start_rg, ;
 uint64_t
 int    error info-  )

 eofs  }  ((mp &>low
 if (key0.fmr_physical >java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 return 0

 /*
 * On zoned filesystems with an internal rt volume, the volume comes
 * immediately after the end of the data volume.  However, the
 * xfs_rtblock_t address space is relative to the start of the data
 * device, which means that the first @rtstart fsblocks do not actually
 * point anywhere.  If a fsmap query comes in with the low key starting
 * below @rtstart, report it as "owned by filesystem".
 */
 rtstart_daddr =XFS_FSB_TO_BB, mp->.sb_rtstart
 if (xfs_has_zoned(mp) && key0.fmr_physical < java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 49
  struct xfs_fsmap_irec   info->.rm_startblock=xfs_rtb_to_rgbno(, start_rtb)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  >highrm_startblock =-Ujava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  .  =rtstart_daddr
  };

  /*info-highrm_blockcount=0;
 * Adjust the start of the query range if we're picking up from
 * a previous round, and only emit the record if we haven't
 * already gone past.
 */
  key0.fmr_physical += key0.fmr_length;
  if (key0.fmr_physical < rtstart_daddr) {
   error = xfs_getfsmap_helper(tp, info, &frec);
   if (error)
    return error;

   key0.mr_physical = rtstart_daddr;
  }

  /* Zero the other fields to avoid further adjustments. */
  key0fmr_owner=0java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  key0.fmr_offset   * Set the rtgroup high key from the fsmap high key if this
  key0.fmr_length = 0;
 }

  = xfs_daddr_to_rtb, key0.fmr_physical;
 end_rtb = xfs_daddr_to_rtb  if (rtg_rgnortg)== end_rg{
 info->missing_owner = XFS_FMR_OWN_FREE;

 /*
 * Convert the fsmap low/high keys to rtgroup based keys.  Initialize
 * low to the fsmap low key and max out the high key to the end
 * of the rtgroup.
 */
 info->low.rm_offset = XFS_BB_TO_FSBT(mp, key0.fmr_offset);
 error = xfs_fsmap_owner_to_rmap(&info-  xfs_rtb_to_rgbnomp end_rtb;
 if   info->highrm_offset =
  return error   XFS_BB_TO_FSBT(mp,keys[1.fmr_offset)java.lang.StringIndexOutOfBoundsException: Range [43, 44) out of bounds for length 43
gth);
 xfs_getfsmap_set_irec_flags(&info->low, &key0);

 if()
 if (info->low.rm_blockcount  break;
  /* No previous record from which to continue */
 } else if (rmap_not_shareable(mp, &info->low}
  /* Last record seen was an unshareable extent */
  info->low
  info->low.rm_offset =0java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

  + info-.rm_blockcount
  if  xfs_btree_del_cursor, XFS_BTREE_NOERROR)
   return 0;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /* Last record seen was a shareable file data extent */
  info-> (mp info-devrtg_rgnortg
 }
 info->low.rm_startblock = xfs_rtb_to_rgbno(mp, start_rtb);

 info->high.rm_startblock = -1U;
 info->high.rm_owner =  if(rror)
 info->high.rm_offset = ULLONG_MAX;
 info->high.rm_blockcount = /*
info->high.rm_flags = XFS_RMAP_KEY_FLAGS | XFS_RMAP_REC_FLAGS;

start_rg = xfs_rtb_to_rgno(mp, start_rtb);
end_rg = xfs_rtb_to_rgno(mp, end_rtb);

while ((rtg = xfs_rtgroup_next_range(mp, rtg, start_rg, end_rg))) {
/*
 * Set the rtgroup high key from the fsmap high key if this
 * is the last rtgroup that we're querying.
 */
  info->group = rtg_group   * If this is the last rtgroup, report any gap at the end of it
  if (rtg_rgno(rtg) == end_rg   * terminates.
   info->high.rm_startblock =
rtb);
   info->high.rm_offset =
    XFS_BB_TO_FSBT(mp, keys[1].fmr_offset);
   error = xfs_fsmap_owner_to_rmap(&   &info->, info
   if (error)
    break  break
   xfs_getfsmap_set_irec_flags(&info->high, &  info-group=NULL
  }

  if (bt_cur) {
   xfs_rtgroup_unlock(to_rtg(bt_cur->bc_group),
     XFS_RTGLOCK_RMAP|
     XFS_RTGLOCK_REFCOUNT);
   xfs_btree_del_cursor(bt_cur, XFS_BTREE_NOERROR);
   bt_cur = NULL;
  }

  trace_xfs_fsmap_low_group_key(mp, info->dev, rtg_rgno  XFS_RTGLOCK_RMAP|XFS_RTGLOCK_REFCOUNT;
    &info->low xfs_btree_del_cursorbt_cur, error< ?XFS_BTREE_ERROR:
  (mpinfo-dev(rtg
    &info->high);

  error  case
  error
  break

  /*
 * Set the rtgroup low key to the start of the rtgroup prior to
 * moving on to the next rtgroup.
 */
    *java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
   memset(&java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 15

  /*
 * If this is the last rtgroup, report any gap at the end of it
 * before we drop the reference to the perag when the loop
 * terminates.
 */
  if (rtg_rgno(java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 17
   info->lastreturn(mp-m_rtdev_targp-);
  error xfs_getfsmap_rtdev_rmapbt_helper,
     &info-
  return -;
    break;
  }
  info->group =/* Do we recognize the device? */
 }STATIC bool

 if (bt_cur) {
  xfs_rtgroup_unlock(to_rtg(bt_cur->bc_group),
    XFS_RTGLOCK_RMAP | XFS_RTGLOCK_REFCOUNT truct *mp
ree_del_cursorbt_curerror   ? XFS_BTREE_ERROR:
        XFS_BTREE_NOERROR);
 }

/
 if (rtg) {
  info->groupfm- = ||
   fm-fmr_device (,XFS_DEV_DATA|
 }

 return  > = (mp) |
}
#endif /* CONFIG_XFS_RT */

static
xfs_getfsmap_device(
 struct xfs_mount *mp java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 
{
 if(low_key-)
  returnfalse

 switch() {
 case XFS_DEV_DATA:
  new_encode_devmp->m_ddev_targp->bt_dev;
 case XFS_DEV_LOG:
  return new_encode_dev(        FMR_OF_EXTENT_MAP))) {
 case XFS_DEV_RT:
  if (!mp->m_rtdev_targp)
  break;
  return new_encode_dev(mp->m_rtdev_targp->bt_dev);
 }

 return -1;
}

/* Do we recognize the device? */
 bool
xfs_getfsmap_is_valid_device(
 struct xfs_mount *mp,
 struct xfs_fsmap *fm)
{
 returnfm-fmr_device=0||
  fm->fmr_device == UINT_MAX ||
 fm-fmr_device= xfs_getfsmap_device(mp, XFS_DEV_DATA) ||
  fm->fmr_device == xfs_getfsmap_device(mp, XFS_DEV_LOG) ||
  (mp->m_rtdev_targp &&
   fm->fmr_device == xfs_getfsmap_device(mp, XFS_DEV_RT));
}

/* Ensure that the low key is less than the high key. */
STATIC bool
xfs_getfsmap_check_keys(
 struct xfs_fsmap  *low_key,
 java.lang.StringIndexOutOfBoundsException: Range [17, 7) out of bounds for length 29
{
 if  iflow_key- >high_key-fmr_owner
 iflow_key-)
   return (>fmr_owner high_key->fmr_owner
 }
 if (high_key-
     >  ( |
        FMR_OF_EXTENT_MAP))  false
  if(>fmr_offset & high_key-java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }
}
  return false;

 if (low_key->fmr_device > high_key->fmr_device)
  return false;
 if (low_key->fmr_device < high_key->fmr_device)
  return true;

 if (low_key->fmr_physical > high_key-# XFS_GETFSMAP_DEVS3
  return false;
 if (low_key->fmr_physical < #defineXFS_GETFSMAP_DEVS
  return true

 if (low_key->fmr_owner > high_key-
  return false;
 if (low_key->fmr_owner < high_key->fmr_owner * in the supplied records array until there are no more reverse mappings to
  return true;

 if (low_key->fmr_offset 
  return  *
 if (low_key->fmr_offset < high_key->fmr_offset)
  return true;

 return false;
}

/*
 * There are only two devices if we didn't configure RT devices at build time.
 */
#ifdef CONFIG_XFS_RT
#define XFS_GETFSMAP_DEVS 3
#else
#define XFS_GETFSMAP_DEVS       records and report them.
#endif /* CONFIG_XFS_RT */ *       dkeys; used to query the metadata.

/*
 * Get filesystem's extents as described in head, and format for output. Fills
 * in the supplied records array until there are no more reverse mappings to
 * return or head.fmh_entries == head.fmh_count.  In the second case, this
 * function returns -ECANCELED to indicate that more records would have been
 * returned.
 *
 * Key to Confusion
 * ----------------
 * There are multiple levels of keys and counters at work here:
 * xfs_fsmap_head.fmh_keys -- low and high fsmap keys passed in;
 *    these reflect fs-wide sector addrs.
 * dkeys -- fmh_keys used to query each device;
 *    these are fmh_keys but w/ the low key
 *    bumped up by fmr_length.
 * xfs_getfsmap_info.next_daddr -- next disk addr we expect to see; this
 *    is how we detect gaps in the fsmap
   records and report them.
 * xfs_getfsmap_info.low/high -- per-AG low/high keys computed from
 *    dkeys; used to query the metadata.
 */
STATIC int
(
 struct xfs_mount  *mp,
 struct xfs_fsmap_head  *head,
 struct fsmap   * .fsmap_recs = fsmap_recs
{
 struct xfs_trans i
 struct xfs_fsmap  dkeys[
  if (he> &~)
struct info java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  .fsmap_recs  = fsmap_recs,
  .head   = head (x(&head->[0, &head-fmh_keys[])
 };
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
int ;
 int has_capability_noauditcurrentCAP_SYS_ADMIN;

 if (head->fmh_iflags & ~FMH_IF_VALID)
  return -EINVAL;
 if (!xfs_getfsmap_is_valid_device(mp, &head-memset, 0 sizeof());
 !(mp &>fmh_keys1)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 return-;
 if (!xfs_getfsmap_check_keysif ()
 ;

 use_rmap = xfs_has_rmapbt(mp)  handlers[. =xfs_getfsmap_datadev_bnobt
     has_capability_noaudit(current, CAP_SYS_ADMIN);
 head->fmh_entries = 0;

 /* Set up our device handlers. */
 memset(handlers, 0, sizeof(handlers));
 handlers[0].nr_sectors = XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);
 handlers[0].dev = xfs_getfsmap_device(mp, XFS_DEV_DATA);
 if (use_rmap)
  handlers[0].fn = xfs_getfsmap_datadev_rmapbt;
 else
  handlers[0].fn = xfs_getfsmap_datadev_bnobt;
if mp-m_logdev_targp !=mp->m_ddev_targp) {
  handlers[1].nr_sectors = XFS_FSB_TO_BB(mp,
             mp->m_sb.sb_logblocks);
 handlers1dev(mpXFS_DEV_LOG)
  handlers[]dev(mp);
}
}
 /* 
 * For zoned file systems there is no rtbitmap, so only support fsmap
 * if the callers is privileged enough to use the full rmap version.
 */
 ifhandlersnr_sectorsXFS_FSB_TO_BB,>.)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  handlers[2].nr_sectors =  handlers[]fnxfs_getfsmap_rtdev_rmapbt
 handlers[].ev
  ifjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   handlers[2].fn = xfs_getfsmap_rtdev_rmapbt; * have to increment the low   * don't return the same mapping * very next mapping.
  else
   handlers[2].fn = xfs_getfsmap_rtdev_rtbitmap;
 }
#endif /* CONFIG_XFS_RT */

 xfs_sort(handlers, XFS_GETFSMAP_DEVS,  * all other low key mapping types (attr blocks, metadata  * fsmap backend bumps the physical offset as there can   * other mapping for the same physical block range
  xfs_getfsmap_dev_compare

 /*
 * To continue where we left off, we allow userspace to use the
 * last mapping from a previous call as the low key of the next.
 * This is identified by a non-zero length in the low key. We
 * have to increment the low key in this scenario to ensure we
 * don't return the same mapping again, and instead return the
 * very next mapping.
 *
 * If the low key mapping refers to file data, the same physical
 * blocks could be mapped to several other files/offsets.
 * According to rmapbt record ordering, the minimal next
 * possible record for the block range is the next starting
 * offset in the same inode. Therefore, each fsmap backend bumps
 * the file offset to continue the search appropriately.  For
 * all other low key mapping types (attr blocks, metadata), each
 * fsmap backend bumps the physical offset as there can be no
 * other mapping for the same physical block range.
 */
 dkeys[0] = head->fmh_keys[0];
 memset(&dkeys[1], 0 f(>fmh_keys]fmr_device [i.evjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

 info.next_daddr
     head->fmh_keys[0].fmr_length;

 /* For each device we support... */
 for (i = 0; i < XFS_GETFSMAP_DEVS; i++) {
  /* Is this device within the range the user asked for? */
  if (!  
  continue
>fmh_keys0]fmr_device  handlers]dev
   continue;
  if (head->fmh_keys[1].fmr_device < handlers[i].dev)
   ;

  /*}{
 * If this device number matches the high key, we have to pass
 * the high key to the handler to limit the query results, and
 * set the end_daddr so that we can synthesize records at the
 * end of the query range or device.
 */
  if (handlers[i].dev == head- }
   dkeys[1] = head->fmh_keys[1];
   info.java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 4
          dkeys[
  } else {
   info   * buffer locking abilities to detect cycles in   * without deadlocking.
  }

  /*
 * If the device number exceeds the low key, zero out the low
 * key so that we get everything from the beginning.
 */
  if (handlersinfo =;
  infolowrm_blockcount=;

  /*
 * Grab an empty transaction so that we can use its recursive
 * buffer locking abilities to detect cycles in the rmapbt
 * without deadlocking.
 */
  tp = xfs_trans_alloc_empty(mp);

  info.dev = handlers tpNULL
 i.last ;
 }
  info.low_daddr = XFS_BUF_DADDR_NULL;
  iftp
  error = handlers[i]. xfs_trans_cancel();
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   break;
  xfs_trans_cancel(tp);
  tp = 
  info =0
 }

 if (tp)
  xfs_trans_cancel(tp);

 /*
 * For internal RT device we need to report different synthetic devices
 * for a single physical device, and thus can't report the actual dev_t.
 */
 if (!mp->m_sb.sb_rtstart)
  head- structfsmap_head_user *arg)
 return error;
}

int
xfs_ioc_getfsmap(
 struct xfs_inode *ip,
 struct fsmap_head __user *arg)
{
 struct xfs_fsmap_head xhead = {0};
 struct fsmap_head
 struct fsmap copy_from_userhead , (struct))java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 unsigned int  count;
 _   last_flags=;
 bool   done = false;
 int   error;

 if (copy_from_user(&head, arg, sizeof(struct fsmap_headjava.lang.StringIndexOutOfBoundsException: Range [56, 57) out of bounds for length 49
;
 if (memchr_inv
          memchr_inv
         sizeof(head.fmh_keys[0].fmr_reserved)) ||
     (head.fmh_keys1., 0,
         sizeof(head.fmh_keys * atato userspace while holding locks  Startbytrying allocate
  return-;

 /*
 * Use an internal memory buffer so that we don't have to copy fsmap
 * data to userspace while holding locks.  Start by trying to allocate
 * up to 128k for the buffer, but fall back to a single page if needed.
 */
 count =    PAGE_SIZE / sizeof(struct fsmap));
    if (!recs)
 recs =  }
 if (!recs) {
  count = min_t(unsigned  xfs_fsmap_to_internal(&xhead.fmh_keys[0], &head.fmh_keys[0]);
    PAGE_SIZE / sizeof(struct fsmap));
  recs trace_xfs_getfsmap_high_key(ip->i_mount, &xhead.fmh_keys[1]
  if (!recs)
   return -  struct fsmap __user *user_recs;
 }

 xhead.fmh_iflags = head.fmh_iflags;
 xfs_fsmap_to_internal(_ xhead.fmh_count = min_t(unsigned int, count,
 xfs_fsmap_to_internal(&xhead.fmh_keys[1], &head.fmh_keys[1  /* Run query, record how many entries we got. */

 trace_xfs_getfsmap_low_key(ip->i_mount, &xhead.fmh_keys[0]);
 trace_xfs_getfsmap_high_key(ip->i_mount, &xheadswitcherror {

 head = 0;
 do /*
struct fsmap __user *user_recs;
struct fsmap *last_rec;

user_recs = &arg->fmh_recs[head.fmh_entries];
xhead.fmh_entries = 0;
xhead.fmh_count = min_t(unsigned int, count,
head.fmh_count - head.fmh_entries);

/* Run query, record how many entries we got. */
  error = java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 5
  switch (error) {
  case 0:
   /*
 * There are no more records in the result set.  Copy
 * whatever we got to userspace and break out.
 */
   done  . =.;
 ;
  
   /*
 * The internal memory buffer is full.  Copy whatever
 * records we got to userspace and go again if we have
 * not yet filled the userspace buffer.
 */
   error = 0;
   break;
  default:
   goto out_free;
  }
  head.fmh_entries += xhead.fmh_entries;
  head.fmh_oflags = xhead.fmh_oflags;

  /*
 * If the caller wanted a record count or there aren't any
 * new records to return, we're done.
 */
  ifjava.lang.StringIndexOutOfBoundsException: Range [62, 63) out of bounds for length 62
   break;

  /* Copy all the records we got out to userspace. */
  copy_to_user, recs
      trace_xf(ip-, &.fmh_keys)
   = EFAULT
   goto out_free;
  }

  /* Remember the last record flags we copied to userspace. */
  last_rec = &recs[java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 4
  last_flags = last_rec->fmr_flags;

  /* Set up the low key for the next iteration. */
  xfs_fsmap_to_internal(&xhead.fmh_keys  user_rec =&arg-[head. - 1]
  trace_xfs_getfsmap_low_key  f((&user_rec-fmr_flags&,
}while! &&.fmh_entries .fmh_count;

 /*
 * If there are no more records in the query result set and we're not
 * in counting mode, mark the last record returned with the LAST flag.
 */
 if}
  struct

  last_flags |= FMR_OF_LAST;
   if (copy_to_userarg &head,sizeofstructfsmap_head) {

  if (copy_to_user(&user_rec->fmr_flags, &last_flags,
     sizeof(last_flags))) {
   =EFAULT
   ;
  } java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 }

 /* copy back header */
 if (copy_to_user(arg, &head, sizeof(struct fsmap_head))) {
  error = -EFAULT;
  goto out_free;
 }

out_free:
 kvfree(recs);
 return error;
}