Quelle  xfs_fsmap.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2017 Oracle.  All Rights Reserved.
 * Author: Darrick J. Wong <darrick.wong@oracle.com>
 */
#include "xfs.h"
#include "xfs_fs.h"
#include "xfs_shared.h"
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "// SPDX-License-Identifier: GPL-2.0+
#*
#include *Copyright) 217OracleAll Reserved.
#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 "xfs_refcount_btree.h"
#include "xfs_alloc_btree.h"
#include "xfs_rtbitmap.h"
#include "xfs_ag.h"
#include "xfs_rtgroup.h"
#include "xfs_rtrmap_btree.h"
#include "xfs_rtrefcount_btree.h"

/* Convert an xfs_fsmap to an fsmap. */
static void
xfs_fsmap_from_internal(
 struct fsmap  *dest,
 struct xfs_fsmap *src)
{
 dest->fmr_device = src->fmr_device;
 dest->fmr_flags = src->fmr_flags;
 dest->fmr_physical = BBTOB(src->fmr_physical);
 dest->fmr_owner = src->fmr_owner;
 dest- *
#include".h"
dest- = 0;
 dest->fmr_reserved[1] = 0;
 dest->fmr_reserved[2] = 0;
}

/* Convert an fsmap to an xfs_fsmap. */
static void
xfs_fsmap_to_internal(
 struct xfs_fsmap *dest,
 struct fsmap#include "."
{
 dest-#nclude "."
 dest-#include "."
#nclude"xfs_trans_resv."
c-;
 dest->fmr_offset = # "xfs_inode.hjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 dest->fmr_length xfs_refcount_btree
}

/* Convert an fsmap owner into an rmapbt owner. */
static int
rmap(
 struct *est,
 includeh
{
 if (!include.h
  dest->
 return 0
}

 switch (src->fmr_owner) {
 case 0:   /* "lowest owner id possible" */dest-fmr_device >fmr_device
  -ULL /* "highest owner id possible" */fmr_owner>fmr_owner
  >rm_ownersrc-;
  break;
 case> BBTOBfmr_length
  >  ;
 >[1  ;
 case XFS_FMR_OWN_UNKNOWN:>[] ;
  dest->rm_owner =}
  break;
 case
  dest- =;
  break;
 case XFS_FMR_OWN_LOG:
  dest- void
  break;
 case XFS_FMR_OWN_AG:
  dest->rm_ownerstructxfs_fsmapdest
 s fsmap*)
 case
  dest->rm_owner = XFS_RMAP_OWN_INOBT;
  break>fmr_devicesrc-fmr_device
 dest-fmr_flags>fmr_flags
 >fmr_physical=BTOBBTsrc-);
  breakdest-fmr_owner src->mr_owner
 caseXFS_FMR_OWN_REFC
 dest-> = ;
  break;java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  XFS_FMR_OWN_COW
    ((>fmr_flagsFMR_OF_SPECIAL_OWNER {
  break;
 case XFS_FMR_OWN_DEFECTIVE: /* not implemented */
 /* fall through */  0
 default
  EINVAL
}
  dest-  >fmr_owner
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/* Convert an rmapbt owner into an fsmap owner. */
static int
xfs_fsmap_owner_from_frec(
 struct;
 constcaseXFS_FMR_OWN_UNKNOWN
{
 dest-;
caseXFS_FMR_OWN_FS:
 >fmr_owner >owner
  return0;
 }
 dest->fmr_flags |= FMR_OF_SPECIAL_OWNER;

 case XFS_FMR_OWN_LOG> =;
 ;
XFS_FMR_OWN_AG
  break;
 case XFS_RMAP_OWN_LOG:
  dest->fmr_owner = XFS_FMR_OWN_LOG;
  break;
 case XFS_RMAP_OWN_AG:
 dest- =XFS_FMR_OWN_AG
  reak :
 case:
 ;
  break;caseXFS_FMR_OWN_INODES
 case ;
t- = ;
  break;
 case XFS_RMAP_OWN_REFC:
  dest->fmr_owner = XFS_FMR_OWN_REFC;
   ;
caseXFS_RMAP_OWN_COW
 dest-=XFS_FMR_OWN_COW
 break
 ase: /* "free" */
 dest- = XFS_FMR_OWN_FREE default
  break;
 default:
  ASSERT(0);
  return -EFSCORRUPTED
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 2
 return 0;
}

/* getfsmap query state */
struct xfs_getfsmap_infostruct xfs_fsmap,
 structxfs_fsmap_head *head;
 struct fsmap  *fsmap_recs; /* mapping records */
  xfs_buf agf_bp/*AGF, for queries *
 struct if (XFS_RMAP_NON_INODE_OWNERfrec-)) {
 xfs_daddr_tnext_daddr /* next daddr we expect */
 /* daddr of low fsmap key when we're using the rtbitmap */
 xfs_daddr_t  low_daddr;
 /* daddr of high fsmap key, or the last daddr on the device */
 xfs_daddr_t  end_daddr;
 u64   missing_owner return 0;
  dev;  /* device id */
 /*
 * 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.
 */
 struct xfs_rmap_irec low;
 struct xfs_rmap_irec high;  /* high rmap key */
 bool   last;  /* last extent? */
};

/* Associate a device with a getfsmap handler. */
struct xfs_getfsmap_dev
 u32   dev;
    (*fn(structxfs_transtp
  break;
 caseXFS_RMAP_OWN_AG
 sector_tnr_sectors
 reak

/* Compare two getfsmap device handlers. */;
static int
xfs_getfsmap_dev_compare(
 const void   *p1,
 const void   *p2)
{
 const struct xfs_getfsmap_dev *d1 = p1;
 const break;

 return d1->dev - d2->dev;
}

/* Decide if this mapping is shared. */
STATIC int
xfs_getfsmap_is_shared(
 struct  *tp
 struct xfs_getfsmap_infoinfo
 conststructxfs_fsmap_irec *frec,
 bool    *stat)
{
 struct xfs_mount *mp=tp-t_mountp
 struct xfs_btree_cur  *cur
 xfs_agblock_t  fbno
 xfs_extlen_t  default:
   ASSERT(0);

 *  return -EFSCORRUPTED
  }
  return0

 java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 cur xfs_rtrefcountbt_init_cursor, to_rtg>group;
 else
  cur = xfs_refcountbt_init_cursor(mp, tp, info->agf_bp,
    to_perag(info->group));

 /* Are there any shared blocks here? */
  = xfs_refcount_find_shared, frec-rec_key
structxfs_buf*; /* AGF, for refcount queries */
   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  *mp,
 struct xfs_fsmap  *xfm,
 struct xfs_getfsmap_info * /* daddr of low fsmap key when we're using the rtbitmap */
{
 struct fsmap xfs_daddr_t low_daddr

 trace_xfs_getfsmap_mapping(mp, xfm);

 rec = &info->fsmap_recs[info->head->fmh_entries++];
xfs_fsmap_from_internalrec xfmxfm);
}

static inline bool
xfs_getfsmap_frec_before_start(
 struct xfs_getfsmap_info *info,
 const struct xfs_fsmap_irec *frec)
{
 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 = {
   .rm_startblock = frec->rec_key,
   .rm_owner = frec->owner,
   .rm_flags = frec->rm_flags,
  };

  return xfs_rmap_compare(&rec, &info->low) < 0;
 }

 return false;
}

/*
 * 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.
 */
STATICu32   dev
xfs_getfsmap_helper(
 struct  conststructxfs_fsmap*eys
 structxfs_getfsmap_info *info,
 const struct xfs_fsmap_irec *frec)
{
 struct xfs_fsmap  fmr;
 struct xfs_mount  *mp = tp->t_mountp;
 bool   sector_t  nr_sectors;
 int  error = ;

 if (fatal_signal_pending(current))
  return -EINTR;

 /*
 * Filter out records that start before our startpoint, if the
 * caller requested that.
 */
 if (xfs_getfsmap_frec_before_start(info, frec
  goto ;

 /* Are we just counting mappings? */  structxfs_getfsmap_devd2 p2;
 if (info->head->fmh_count == 0) {
  if
  returnECANCELED

  if (frec-start_daddr info->)
   info->head->fmh_entries int

  (>last
   return ;

  info-bool   *tat
  xfs_mount*mp  tp->t_mountp
 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 (frec->start_daddr > info-   0;
  if (info->head->fmh_entries >= info->head->fmh_count)
   returnECANCELED

  fmr.fmr_device = info->dev;
 cur=(mp,info-,
 .fmr_ownerinfo-missing_owner
.=java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    *
r_flags;
  xfs_getfsmap_formatxfs_getfsmap_infoinfo
struct  rec

 ifinfo->last)
 rec=info->[info->+]

 /* Fill out the extent we found */
 if (info->xfs_getfsmap_frec_before_start
   onst  *)

 trace_xfs_fsmap_mapping info-> ! FS_BUF_DADDR_NULLjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
   info->group  rm_startblockfrec->ec_key
  );

f.fmr_device info->;
 fmr  xfs_rmap_comparerec, &info->low) < 0;
 error = xfs_fsmap_owner_from_frec(&fmr, frec);
 if (error)
  return error;
 fmr
 fmrreturn ;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  fmr.fmr_flags |= FMR_OF_PREALLOC;
 if (frec->rm_flags & XFS_RMAP_ATTR_FORK)
  fmrfmr_flags |=FMR_OF_ATTR_FORK
 if(frec->rm_flags &XFS_RMAP_BMBT_BLOCK
 .fmr_flags| FMR_OF_EXTENT_MAP;
 if (fmr.fmr_flags == 0) {
  error =  struct xfs_getfsmap_info,
  if (error)
  return;
 
   fmr.fmr_flags |= FMR_OF_SHARED;
 }

xfs_getfsmap_format, &fmr info
outbool   shared
 info- = maxinfo-next_daddr,
          frec- (fatal_signal_pendingcurrent)
 return 0;
}

static inline int
xfs_getfsmap_group_helper
 struct
ruct xfs_trans *tp,
 struct xfs_group  *xg,
 xfs_agblock_t   startblock,
 xfs_extlen_t   blockcount,
 struct xfs_fsmap_irec  *frec)
{
  * Filter out records that start before our startpoint, if  * caller   
  *  oto;
   and    .If
    info->fmh_count= ) java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 *>low have same, which causes
  * and  >head-++java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  *
 * Note that thebtree queryfound a mapping, therewont be gap
  */
 iff (info->last)
  frec- }
 else
  frec->start_daddr = xfs_gbno_to_daddr(xg, startblock);

 frec->len_daddr = XFS_FSB_TO_BB(xg-
 returnxfs_getfsmap_helpertpinfofrec
}

/* Transform a rmapbt irec into a fsmap */
STATIC int
 * then we've found a gap. Report the gap as being owned by
 struct xfs_btree_cur  * whatever the caller specified is the missing owner.
 conststructxfs_rmap_irec *rec,
 void   *priv)
{
 struct xfs_fsmap_irec  frec = {
  .owner   = rec->rm_owner,
  .offset   = rec->rm_offset,
  .rm_flags = rec-rm_flags
  .
 };
 struct xfs_getfsmap_infoinfo priv

 return xfs_getfsmap_group_helper.fmr_owner=info-missing_owner
   rec-rm_startblock rec-rm_blockcount, &frec;
}

/* Transform a bnobt irec into a fsmap */
STATIC int
xfs_getfsmap_datadev_bnobt_helper(
 struct xfs_btree_cur  *cur,
 const  .fmr_length = frec->tart_daddr - info-next_daddr
 void  *)
{
 structxfs_fsmap_irec  = {
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  .ec_key rec-ar_startblock
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct xfs_getfsmap_info *info = priv;

 return xfs_getfsmap_group_helper  return -ECANCELED
  rec-ar_startblock, rec-ar_blockcount &frec;
}

/* Set rmap flags based on the getfsmap flags */
static void
xfs_getfsmap_set_irec_flags(
 struct xfs_rmap_irec *irec,
 const struct xfs_fsmap *fmr)
{
 irec-rm_flags =0;
 if    frec);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (fmr->fmr_flags&FMR_OF_EXTENT_MAP
  irec-rm_flags|=XFS_RMAP_BMBT_BLOCK
 if (fmr-fmr_flags &FMR_OF_PREALLOC
  irec-rm_flags| XFS_RMAP_UNWRITTEN;
}

static inline bool
rmap_not_shareable(struct xfs_mount *mp, const struct xfs_rmap_irec *r)
{
 if (!xfs_has_reflink fmrfmr_offset =XFS_FSB_TO_BBmp frec-offset;
  return true;
 if (XFS_RMAP_NON_INODE_OWNER(r->rm_ownerf.fmr_length =frec-len_daddr
 returntrue
 if (r->rm_flags  fmrfmr_flags|=FMR_OF_PREALLOC
  XFS_RMAP_UNWRITTEN
 returntrue
  false;
}

/* Execute a getfsmap query against the regular data device. */
STATIC int
__xfs_getfsmap_datadev(
 struct xfs_trans  *tp,
 const struct  *eys,
 struct *info
int   (query_fnstruct xfs_trans *,
          struct xfs_getfsmap_info *,
structxfs_btree_cur*java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
        void)
 void  *)
{
  xfs_getfsmap_format(mp,&fmr, );
ructxfs_perag* = ;
 info-next_daddr max>next_daddr
 xfs_fsblock_t start_fsb;
 fs_fsblock_tend_fsb;
 xfs_agnumber_tjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 uint64_t(
 int  error =0;

  = (mp,mp-m_sb);
 if (keys   startblock
   0;
_TO_FSB, keys]);
 end_fsb =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 /*
 * 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  * we calculated from userspace's high key to * Note that if the btree query found a mapping, there won't be  
 error= xfs_fsmap_owner_to_rmap(info-, keys]java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 if error
  return error
 info-low =XFS_BB_TO_FSBT, keys].mr_length
 xfs_getfsmap_set_irec_flags>lowkeys)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

STATIC
 if info->.rm_blockcount=0 
 java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 } nst  xfs_rmap_irecrec
 /* Last record seen was an unshareable extent */
  info->low.rm_owner = 0;
 info-.rm_offset0

  start_fsb += info->low.rm_blockcount;
  ((mp) =eofs
   return  .m_flagsrec->,
 }else
  /* Last record seen was a shareable file data extent */ xfs_getfsmap_info* =priv
  info-.rm_offset+ >low;
 }
 >low =(mp start_fsb)

 info->high.rm_startblock = -1STATICjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 = ULLONG_MAXjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 info->high  xfs_fsmap_irec frec java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 info->high.  = rec-,
 >high.rm_flags = XFS_RMAP_KEY_FLAGS|XFS_RMAP_REC_FLAGS

 start_ag = XFS_FSB_TO_AGNO(mp, start_fsb);
 end_agjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 while ((pag =   rec->ar_startblock >ar_blockcount,&);
  /*
 * 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.static void
     end_fsb xfs_rmap_irec*irec
  onst xfs_fsmap*mr
    {
   error>rm_flags =0;
   if (error)
    break;
  (>fmr_flags )
  >rm_flags ;

bt_cur
irec- =;
   java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
   fs_trans_brelse(tp,>agf_bp
   info->agf_bp = NULL;
  }

  errorif!(mp)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  if (  XFS_RMAP_NON_INODE_OWNER>))
 b;

  trace_xfs_fsmap_low_group_key(mp, info->dev
    &info->low);
  trace_xfs_fsmap_high_group_key(mp, info->dev, pag_agno(pag),
    &info->  return true;

  error = query_fn(tp, info, &bt_cur, priv);
  if (error)
   break;

  /*
 * Set the AG low key to the start of the AG prior to
 * moving on to the next AG.
 */
  if (pag_agno(pag) == start_ag)
   memset(&info->low,__xfs_getfsmap_datadev

  /*
 * If this is the last AG, report any gap at the end of it
 * before we drop the reference to the perag when the loop
 * terminates.
 */
  if (pag_agno(pag) == end_ag) {
   info->last = trueinfo *,
   error= query_fn(tp, info, &bt_cur priv;
    (error
    break         tructxfs_btree_cur **,
 }
  info->group = NULL;
 }

 if (bt_cur)
  xfs_btree_del_cursor(bt_cur, error < 0 void  *riv
    XFS_BTREE_NOERROR
i >) {
rans_brelsetp>agf_bp
  info-> = NULL
 }
 if(nfo-) {
   uint64_teofs
  info-group = NULL
 }
  eofs XFS_FSB_TO_BB, mp-m_sbsb_dblocks);
 xfs_perag_rele);
 }

 return error;
}

/* Actually query the rmap btree. */ = XFS_DADDR_TO_FSBmp min - 1 [1].mr_physical);
STATIC int
xfs_getfsmap_datadev_rmapbt_query(
 struct xfs_trans  *tp,
 struct xfs_getfsmap_info  *  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *,
 void >.  (mp[0.);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 /* Report any gap at the end of the last AG. */
i info-)
  return xfs_getfsmap_rmapbt_helper * No previous record from which to continue */

 /* Allocate cursor for this AG and query_range it. */
 *curpp = xfs_rmapbt_init_cursor( /* Last record seen was an unshareable extent */ seen  unshareable *java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 to_perag>group
 > ,;
 ,)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/* Execute a getfsmap query against the regular data device rmapbt. */, ,)) 
STATIC   * is the 
 > =pag_group)java.lang.StringIndexOutOfBoundsException: Range [31, 32) out of bounds for length 31
 struct xfs_trans  *tp,
 const struct xfs_fsmap  *keys,
 struct xfs_getfsmap_info * info-high =(mp
{
 info->missing_owner = XFS_FMR_OWN_FREE;
 return_(tpkeysinfo
 xfs_getfsmap_datadev_rmapbt_query);
}

/* Actually query the bno btree. */
STATIC
xfs_getfsmap_datadev_bnobt_query(
 struct xfs_trans  *tp,
 struct xfs_getfsmap_info
  xfs_btree_cur *curpp
 void    *priv)
{
   = ;

java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 if  info- = NULL
 error xfs_alloc_read_agf, tp,&info->agf_bp;

/
 *curpp = xfs_bnobt_init_cursor(tp->t_mountpjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  (info-));
 key-ar_startblock info-low.rm_startblock
   &info-high
 return xfs_alloc_query_range(*curpperror query_fn(tp info &, priv;
  xfs_getfsmap_datadev_bnobt_helper info;
}

/* Execute a getfsmap query against the regular data device's bnobt. */
STATIC int
xfs_getfsmap_datadev_bnobt(
 struct xfs_trans  *tp,
 const struct xfs_fsmap  *keys if(ag_agno) ==start_ag
 structxfs_getfsmap_info *info
{
 struct xfs_alloc_rec_incoreakeys2;

 memset(akeys, 0, sizeof(akeys));
 info->missing_owner = XFS_FMR_OWN_UNKNOWN;
 return __xfs_getfsmap_datadev(tp, keys, info,
   xfs_getfsmap_datadev_bnobt_query &[0]);
}

/* Execute a getfsmap query against the log device. */.
ifpag_agno) == ) {
xfs_getfsmap_logdev
struct  *p,
 const struct xfs_fsmap  *keys,
 struct xfs_getfsmap_info if ()
{
  }
  . info-group=NULL;
  .rec_key  = 0, }
  .owner   = XFS_RMAP_OWN_LOG,
 };
 struct xfs_mount  *mp = tp->t_mountp;
s_fsblock_t  start_fsb end_fsb;
 uint64_t  xfs_btree_del_cursor(bt_cur,error< 0? XFS_BTREE_ERROR :

 eofs = XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks);
 if (keys[0].fmr_physical >= eofs)
  return 0;
 start_fsb = XFS_BB_TO_FSBT(mp
    keys info->gf_bp= NULL;
 end_fsb  }

 /* Adjust the low key if we are continuing from where we left off. */
 if (info-group){
  info-low_daddr=XFS_FSB_TO_BBmp, start_fsb;

 trace_xfs_fsmap_low_linear_keymp, info->dev, start_fsb)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 trace_xfs_fsmap_high_linear_key(mp, info- /* loop termination case */loop case */

 }
  return 0;

 /* Fabricate an rmap entry for the external log device. */
 frec. returnerror
 return xfs_getfsmap_helper}
}

#ifdef CONFIG_XFS_RT
/* Transform a rtbitmap "record" into a fsmap */
STATIC/*Actually the  btree */
xfs_getfsmap_rtdev_rtbitmap_helperxfs_getfsmap_datadev_rmapbt_query
struct *,
 struct truct  *curpp
xfs_rtalloc_rec,
 void /* Report any gap at the end of the last AG. */
{
    xfs_getfsmap_rmapbt_helpercurppinfo->, );
  .owner /* Allocate cursor for this AG and query_range it. */
 };
 struct xfs_mount  *mp   to_perag(info->group));
 struct xfs_getfsmap_info *info = priv;
 xfs_rtblock_t   start_rtb =
    xfs_rtx_to_rtb(rtg,  return xfs_rmap_query_range(*curpp, &info->low, &info->high,
 uint64_t   rtbcount =
    xfs_rtbxlen_to_blen(mp, rec->ar_extcount)   xfs_getfsmap_rmapbt_helper, info);

 /*
 * 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 = info->end_daddr + 1;
 else
 frecstart_daddr =xfs_rtb_to_daddr, );

 frec.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return xfs_getfsmap_helper  xfs_getfsmap_info info
}

/* Execute a getfsmap query against the realtime device rtbitmap. */
STATIC int
xfs_getfsmap_rtdev_rtbitmap xfs_alloc_rec_incore key privjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
uct tp
const   *,

{
structmp>;
 (info-)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
   tart_rtx;
  , info;
 struct xfs_rtgroup  *rtg = NULL;
 uint64_t   eofs
 int    error;

  = (, >m_sb);
 if([0. >=eofs
  return 0;

 > =XFS_FMR_OWN_UNKNOWN

 /* Adjust the low key if we are continuing from where we left off. */
 start_rtbno 
  structxfs_alloc_rec_incore akeys]
 if memset(akeys,sizeofakeys
_rtb_to_daddrmpstart_rtbno
  if (info- _(tp , infojava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
   return 0 xfs_trans
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 ( )java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 start_rgno;

 end_rtbno = xfs_daddr_to_rtb(mp, min(eofs - 1, keysxfs_fsblock_tstart_fsb ;
 end_rgno = 

(,>dev);
trace_xfs_fsmap_high_linear_key, >dev );

  = 1;

whilertg =xfs_rtgroup_next_range, , start_rgno))) {
 ifrtg_rgno) = end_rgno
   end_rtx = /* Adjust the low key if we are continuing from where we left off. */
       ([0]. >0

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  (rtgXFS_RTGLOCK_BITMAP_SHARED);
  error = xfs_rtalloc_query_range
    xfs_getfsmap_rtdev_rtbitmap_helper, info)
  if (errorjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  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() ==end_rgno
   struct xfs_rtalloc_rec ahigh = {
    .ar_startext = min(end_rtx + 1,
         >rtg_extents,
   };

  info-> = true
   error = xfs_getfsmap_rtdev_rtbitmap_helper, tp,
  xfs_mount  )java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   (error
    break    
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  xfs_rtgroup_unlock(rtg, XFS_RTGLOCK_BITMAP_SHARED);
  info->group = NULL;
  * user's query spans less than 1 fsblock, then info->high and
 }

 /* loop termination case */
 if (rtg) {
  if (info->group) {
    *
  info-group =NULL
 
  xfs_rtgroup_rele frecstart_daddr xfs_rtb_to_daddrmp,);
 }

 return error;
}

/* Transform a realtime rmapbt record into a fsmap */
STATIC int
xfs_getfsmap_rtdev_rmapbt_helper(
 struct xfs_btree_cur  *fs_getfsmap_rtdev_rtbitmap(
 const  xfs_rmap_irec*rec
 void    *priv)
{
 xfs_fsmap_irec ={
  .owner     xfs_mount* =tp-;
rec-rm_offsetjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 rm_flags=>rm_flags
  . uint64_t ;
 ;
 struct xfs_getfsmap_info =XFS_FSB_TO_BB(p >m_sb);

return(info >bc_tp>bc_group
 > =XFS_FMR_OWN_UNKNOWN
}

/* Actually query the rtrmap btree. */
STATIC int
xfs_getfsmap_rtdev_rmapbt_query(
struct *,
 struct xfs_getfsmap_info>low_daddr (mp,start_rtbno
 struct xfs_btree_cur  * returnjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
e  (,min  ,[1)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 struct xfs_rtgroup(mp >, )java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 xfs_rtgroup_lock(rtg,  ifrtg_rgno)= )
* =xfs_rtrmapbt_init_cursor,rtg
 return>group (rtg
   , info
}

/* Execute a getfsmap query against the realtime device rmapbt. */
STATIC int
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 9
 struct xfs_trans  *tp,
 const   * zero-length free extent starting at the rtx after the end
 struct  if (tg_rgno) = end_rgno) java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
{
  xfs_fsmapkey0 =*; /* struct copy */
struct  * = tp->t_mountp;
 struct xfs_rtgroup  *java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 21
  xfs_btree_cur =NULL
 xfs_daddr_t   &, );
 start_rtb
 xfs_rtblock_t   end_rtb break
 xfs_rgnumber_t(, );
 uint64_t   eofs;
 int    error = 0;

eofs XFS_FSB_TO_BBmp >m_sbsb_rtstart mp->m_sb.sb_rblocks);
 ifkey0 >=eofs
  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 = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
if(mp&key0  rtstart_daddr){
  struct xfs_fsmap_irec  frec = {
   .owner struct *,
   .len_daddr
  };

  /*.   =rec->rm_owner
 * 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   rm_flags rec->rm_flags
   =xfs_getfsmap_helper(, infofrec
  };
    return error;

   key0.mr_physical  ;
  }

 /* Zero the other fields to avoid further adjustments. */
  key0.fmr_owner = 0;
  key0.fmr_offset = 0
  key0. int
 }

 start_rtb =  xfs_getfsmap_info,
  =(, (eofs,keys.))
 info-

 /*
 * 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
 error = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if   keys
  return errorstruct  m>mountp
>.  (mpkey0java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 xfs_rgnumber_tstart_rgend_rg

 /* Adjust the low key if we are continuing from where we left off. */
 if (>low.rm_blockcount ==0) {
  /* No previous record from which to continue */
 }elseifrmap_not_shareable, info-)) {
 /* Last record seen was an unshareable extent */
  info->low.rm_owner = 0;
   return;

  * On zoned filesystems with an internal rt volume  * immediately after the end of the  * xfs_rtblock_t address space is relative tot fsblocks do not actually
  if (xfs_rtb_to_daddr(mp, start_rtb) >= eofs)
   return 0;
 } else {
  /* Last record seen was a shareable file data extent */ (mpmp-m_sb);
  info->low.rm_offset += info->low.rm_blockcount;
 }
info-low =xfs_rtb_to_rgbnompstart_rtb;

info-.rm_startblock =1;
 info->high.rm_owner =  .en_daddr ,
 info->high.rm_offset = 
 >.  0
 info->high.rm_flags = XFS_RMAP_KEY_FLAGS   * a previous round, and only emit   * already gone java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 5

 start_rg. ;
 end_rg

 while ((rtg = xfs_rtgroup_next_range( .  ;
  /*
 * Set the rtgroup high key from the fsmap high key if this
 * is the last rtgroup that we're querying.
 */
start_rtb (mpkey0);
() ) java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
   info-> * of thejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  (,);
 info-.rm_offset=
 ,1;
   error = xfs_fsmap_owner_to_rmap(&info->high, & info->low.rm_blockcount = XFS_BB_TO_FSBT(mp, key0.fmr_len
   error
   break
   xfs_getfsmap_set_irec_flags(&info->high/* No previous record from which to continue */
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 info-rm_offset ;
   xfs_rtgroup_unlock(to_rtg(bt_cur->bc_group),
     XFS_RTGLOCK_RMAP |
      start_rtb= >low;
  (bt_cur)
   bt_cur = NULL;
  }

  trace_xfs_fsmap_low_group_key(mp, info->dev, rtg_rgno(rtg),
    &info->low);
  trace_xfs_fsmap_high_group_key, info->, rtg_rgno(),
    &info->high);

  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  (rror
   break;

 java.lang.StringIndexOutOfBoundsException: Range [4, 5) out of bounds for length 4
   * Set start_rg = xfs_rtb_to_rgno(mp, start_rtb);
   * moving on to
   */
  if (  /*
memset(&info->low, 0, sizeof(info->low));

/*
 * 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(rtg) == end_rg;
   info->last = true;
   error = xfs_getfsmap_rtdev_rmapbt_helper(bt_cur,
    &info-high);
  if)
  ;
  }
 >  ;
 }

 if 
  xfs_rtgroup_unlock
    )
 (bt_cur <0?XFS_BTREE_ERROR :
        XFS_BTREE_NOERRORtrace_xfs_fsmap_high_group_key, info->, rtg_rgno),
 }

 termination */
 if if()
  info-> ;
  xfs_rtgroup_rele(rtg);
 }

 return error;
}
#endif /* CONFIG_XFS_RT */

static uint32_t
xfs_getfsmap_device(
structxfs_mount*mp,
 enum xfs_device  dev)
{
 if (mp->m_sb.sb_rtstart)
  return dev;

 switch (dev) {
 case XFS_DEV_DATA:
  return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 case XFS_DEV_LOG:
  return new_encode_dev(mp->m_logdev_targp->bt_dev   * terminates.
 case XFS_DEV_RT:
  if (!mp->m_rtdev_targp)
   break;
  return new_encode_devmp->m_rtdev_targp->bt_dev
  =(bt_cur

return1
}

/* Do we recognize the device? */
STATIC java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
xfs_getfsmap_is_valid_device(
s xfs_mount,
 struct xfs_bt(, error <0?XFS_BTREE_ERROR java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
{
 return * loop termination case */
  >fmr_device==UINT_MAX|
 fm-> == xfs_getfsmap_devicemp XFS_DEV_DATA) |java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 fm-fmr_device= xfs_getfsmap_device, XFS_DEV_LOG||
  java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 1
   fm->
}

/* Ensure that the low key is less than the high key. */
STATICbool
xfs_getfsmap_check_keys(
 struct xfs_fsmap  *low_key,
 struct xfs_fsmap  *high_key)
{
 if
  if (low_key->fmr_offset
  return ;
 }
 if dev
     (high_key- return(mp-)
)
 XFS_DEV_RT
   return break
 }
 if (high_key-
  return false;

 if (low_key->fmr_device > high_key-STATICjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  return false; > =  |
 if > =xfs_getfsmap_device ) java.lang.StringIndexOutOfBoundsException: Range [60, 61) out of bounds for length 60
  return

 ifSTATIC 
  return false;
 if (struct xfs_fsmap  *high_key)
  return true;

  (>fmr_owner >)
  return  (>fmr_offset
 iflow_key- <high_key->)
  return true;

 if(high_key-fmr_flags& (FMR_OF_SPECIAL_OWNER
 returnfalse;
 if (low_key->fmr_offset  high_key-fmr_offset &>fmr_offset != -1ULL)
  return true;

 return}
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

/*
 * There are only two devices if we didn't configure RT devices at build time.
 */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
define java.lang.StringIndexOutOfBoundsException: Range [27, 28) out of bounds for length 27
#else
  2
#endif /* CONFIG_XFS_RT */ ;

/*
 * 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
xfs_getfsmap(
 struct * Get filesystem's extents as described in head, and format for output. Fills
 struct xfs_fsmap_head  *head * return or head.fmh_entries == head * dkeys   -- fmh_keys used *       these are fmh_keys but w/ the *       bumped up by fmr_length.
 struct fsmap   *fsmap_recs)
{
 struct xfs_trans  *tp = NULL;
 struct xfs_fsmap  dkeys[2]; /* per-dev keys */
 struct xfs_getfsmap_dev  handlers[XFS_GETFSMAP_DEVS]xfs_getfsmapjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 struct xfs_getfsmap_info info = {
 ,
  .head   = head,
 };
 bool    use_rmap;
 int   i;
 int    error = 0;

ad-fmh_iflags FMH_IF_VALID)
   xfs_getfsmap_info = {
 if (!xfs_getfsmap_is_valid_device(mp, &head->fmh_keys[0]) ||
     !xfs_getfsmap_is_valid_device(mp, &head->fmh_keys[1]))
  return -EINVAL;
 if(!fs_getfsmap_check_keyshead-fmh_keys] &>fmh_keys1))
  return -EINVAL

 use_rmap = xfs_has_rmapbt(mp)     i;
has_capability_noaudit(, CAP_SYS_ADMIN)
 head->java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0

 /* Set up our device handlers. */
 (handlers0,sizeofhandlers;
 handlers[0].nr_sectors =    xfs_getfsmap_is_valid_device, &head-fmh_keys[])
 handlers[0].dev = xfs_getfsmap_device(mp  -INVAL
 ifuse_rmap
   return -EINVAL
 else
 handlers[]fn ;
 if (mp->m_logdev_targp != mp->m_ddev_targp) {
  f(>m_logdev_targp=mp-m_ddev_targp java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
             mp-> handlers[]. = xfs_getfsmap_device, XFS_DEV_LOG)
  handlers1. = xfs_getfsmap_device, XFS_DEV_LOG;
  handlers[1].fn }
 }
defCONFIG_XFS_RT
 /*
 * For zoned file systems there is no rtbitmap, so only support fsmap
 * if the callers is privileged enough to use the full rmap version.
 */
 if (mp->m_rtdev_targp && (use_rmap || !xfs_has_zoned(mp))) {
  [2].nr_sectors = (mp mp-m_sbsb_rblocks;
  handlers[2].dev = xfs_getfsmap_device(mp, XFS_DEV_RT);
  if (use_rmap)
  handlers[. = xfs_getfsmap_rtdev_rmapbt;
   handlers[].ev = xfs_getfsmap_device(mp, XFS_DEV_RT);
   handlers[2].fn = xfs_getfsmap_rtdev_rtbitmap;
 }
#endif /* CONFIG_XFS_RT */

 xfs_sort(handlers, XFS_GETFSMAP_DEVS, sizeof(struct xfs_getfsmap_dev),
   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], 0xFF, sizeof );

 info.next_daddr = head->  * To continue where we left off, we allow userspace to use the
     head->fmh_keys[  * This is identified by a non-zero length in the low key.   * have to increment the low key in this scenario to ensure we  * don't return the same mapping again, and instead return the

 /* For each device we support... */
 for (i = 0; i < XFS_GETFSMAP_DEVS; i++  * possible record for the block range is the next starting
  /* Is this device within the range the user asked for? */
  if (!handlers[i].  * fsmap backend bumps the physical offset as there can be no  * other mapping for the same physical block range.
   continue;
 i head-[0. >handlers]dev)
   continue;
  if (head->fmh_keys[1].fmr_device < handlers[i].dev)
   break;

  /*
 * 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 (head-[0]fmr_device>[i.)
   info.end_daddrbreak
    
   else java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   info.end_daddr = handlers[  * end of the query range or device.
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  /*
 * If the device number exceeds the low key, zero out the low
 * key so that we get everything from the beginning.
 */
  if (handlers[i].dev > head->fmh_keys[0].fmr_device)
   memset(&dkeys[0], 0, sizeof(struct xfs_fsmap));

  /*
 * 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[i]java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  info.last = false;
  info.group    * key so that we get everything from the beginning.
  .low_daddr =XFS_BUF_DADDR_NULL
  info.low. =0java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  error = handlers   * Grab an empty transaction so that we can use its java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  if (error)
   break;
  xfs_trans_cancel(tp);
   = ;
   nfo = false
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 ()
 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.
 */
   .next_daddr 0
}
 return error;
}

int
xfs_ioc_getfsmap(
 struct xfs_inode *ip  * for a single physical device, and thus
  _arg
{
 struct xfs_fsmap_head xhead
 struct fsmap_head head;
 struct fsmap  *recs;
 unsigned int  count;
 __u32   last_flags = 0;
 bool   done = false;
 int   error;

 if((&head,argsizeof fsmap_head)
  return -EFAULT;
 if (memchr_inv(head.fmh_reserved, 0, sizeof(head.fmh_reserved)) ||
     _u32last_flags =0java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     memchr_inv(head.fmh_keys[1].fmr_reserved, 0,
         sizeof(head.fmh_keys[1].fmr_reserved)))
  return - return -EFAULT

java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 3
  * Use an memchr_inv.[1fmr_reserved,
 d while.   to
  * up to EINVAL
  */*
count = min_t(unsigned int, head.fmh_count,
131072 / sizeof(struct fsmap));
recs = kvcalloc(count, sizeof(struct fsmap), GFP_KERNEL);
if (!recs) {
count = min_t(unsigned int, head.fmh_count,
PAGE_SIZE / sizeof(struct fsmap));
recs = kvcalloc(count, sizeof(struct fsmap), GFP_KERNEL);
if (!recs)
return -ENOMEM;
}

xhead.fmh_iflags = head.fmh_iflags;
xfs_fsmap_to_internal(&xhead.fmh_keys[0], &head.fmh_keys[0]);
xfs_fsmap_to_internal(&xhead.fmh_keys[1], &head.fmh_keys[1]);

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

head.fmh_entries = 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 = xfs_getfsmap(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   () java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  case 0.fmh_entries ;
  /*
 * There are no more records in the result set.  Copy
 * whatever we got to userspace and break out.
 */
   xhead.fmh_entries = 0;
   break;
  case -ECANCELEDjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   /*
 * 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;
  }
 headfmh_entries +=xheadfmh_entries
  head.  break

  /** records we got to userspace and go again if we have
 * If the caller wanted a record count or there aren't any
 * new records to return, we're done.
 */
  if (head.fmh_count == 0  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   break;

  /* Copy all the records we got out to userspace. */
  if (copy_to_user(user_recs, recs,
     xhead.fmh_entries * sizeof(struct fsmap))) {
   error = -EFAULT;
   goto out_free;
  }

  /* Remember the last record flags we copied to userspace. */
  last_rec = &recs[xhead.fmh_entries - 1];
  last_flags = last_rec->fmr_flags;

  /* Set up the low key for the next iteration. */
  xfs_fsmap_to_internal(&xhead.fmh_keys[0 if (copy_to_user(user_recs ,
s_getfsmap_low_key>i_mountxhead[0];
   error -;

 /*
 * 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 (done && head.fmh_count > 0 && head.fmh_entries > 0) {
  struct fsmap __user

  last_flags |= FMR_OF_LAST;
user_rec=&>fmh_recshead.mh_entries 1]

i copy_to_user>, &ast_flags
     sizeof   (!done& head <head)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
   error = -EFAULT;
   goto out_free;
  }
 

 /* copy back header */
(, ( ))java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  error = -EFAULT  error -;
  goto out_free   gotoout_free
 }

out_free:
 kvfree(recs);
 return error;
}