Impressum flexfilelayout.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Module for pnfs flexfile layout driver.
 *
 * Copyright (c) 2014, Primary Data, Inc. All rights reserved.
 *
 * Tao Peng <bergwolf@primarydata.com>
 */

#include <linux/nfs_fs.h>
#include <linux/nfs_mount.h>
#include <linux/nfs_page.h>
#include <linux/module.h>
#include <linux/file.h>
#include <linux/sched/mm.h>

#include <linux/sunrpc/metrics.h>

#include "flexfilelayout.h"
#include "../nfs4session.h"
#include "../nfs4idmap.h"
#include "../internal.h"
#include "../delegation.h"
#include "../nfs4trace.h"
#include "../iostat.h"
#include "../nfs.h"
#include "../nfs42.h"

#define NFSDBG_FACILITY         NFSDBG_PNFS_LD

#define FF_LAYOUT_POLL_RETRY_MAX     (15*HZ)
#define FF_LAYOUTRETURN_MAXERR 20

enum nfs4_ff_op_type {
 NFS4_FF_OP_LAYOUTSTATS,
 NFS4_FF_OP_LAYOUTRETURN,
};

static unsigned short io_maxretrans;

static const struct pnfs_commit_ops ff_layout_commit_ops;
static void ff_layout_read_record_layoutstats_done(struct rpc_task *task,
  struct nfs_pgio_header *hdr);
static int
ff_layout_mirror_prepare_stats(struct pnfs_layout_hdr *lo,
          struct nfs42_layoutstat_devinfo *devinfo,
          int dev_limit, enum nfs4_ff_op_type type);
static void ff_layout_encode_ff_layoutupdate(struct xdr_stream *xdr,
         const struct nfs42_layoutstat_devinfo *devinfo,
         struct nfs4_ff_layout_mirror *mirror);

static struct pnfs_layout_hdr *
ff_layout_alloc_layout_hdr(struct inode *inode, gfp_t gfp_flags)
{
 struct nfs4_flexfile_layout *ffl;

 ffl = kzalloc(sizeof(*ffl), gfp_flags);
 if (ffl) {
  pnfs_init_ds_commit_info(&ffl->commit_info);
  INIT_LIST_HEAD(&ffl->error_list);
  INIT_LIST_HEAD(&ffl->mirrors);
  ffl->last_report_time = ktime_get();
  ffl->commit_info.ops = &ff_layout_commit_ops;
  return &ffl->generic_hdr;
 } else
  return NULL;
}

static void
ff_layout_free_layout_hdr(struct pnfs_layout_hdr *lo)
{
 struct nfs4_flexfile_layout *ffl = FF_LAYOUT_FROM_HDR(lo);
 struct nfs4_ff_layout_ds_err *err, *n;

 list_for_each_entry_safe(err, n, &ffl->error_list, list) {
  list_del(&err->list);
  kfree(err);
 }
 kfree_rcu(ffl, generic_hdr.plh_rcu);
}

static int decode_pnfs_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
{
 __be32 *p;

 p = xdr_inline_decode(xdr, NFS4_STATEID_SIZE);
 if (unlikely(p == NULL))
  return -ENOBUFS;
 stateid->type = NFS4_PNFS_DS_STATEID_TYPE;
 memcpy(stateid->data, p, NFS4_STATEID_SIZE);
 dprintk("%s: stateid id= [%x%x%x%x]\n", __func__,
  p[0], p[1], p[2], p[3]);
 return 0;
}

static int decode_deviceid(struct xdr_stream *xdr, struct nfs4_deviceid *devid)
{
 __be32 *p;

 p = xdr_inline_decode(xdr, NFS4_DEVICEID4_SIZE);
 if (unlikely(!p))
  return -ENOBUFS;
 memcpy(devid, p, NFS4_DEVICEID4_SIZE);
 nfs4_print_deviceid(devid);
 return 0;
}

static int decode_nfs_fh(struct xdr_stream *xdr, struct nfs_fh *fh)
{
 __be32 *p;

 p = xdr_inline_decode(xdr, 4);
 if (unlikely(!p))
  return -ENOBUFS;
 fh->size = be32_to_cpup(p++);
 if (fh->size > NFS_MAXFHSIZE) {
  printk(KERN_ERR "NFS flexfiles: Too big fh received %d\n",
         fh->size);
  return -EOVERFLOW;
 }
 /* fh.data */
 p = xdr_inline_decode(xdr, fh->size);
 if (unlikely(!p))
  return -ENOBUFS;
 memcpy(&fh->data, p, fh->size);
 dprintk("%s: fh len %d\n", __func__, fh->size);

 return 0;
}

/*
 * Currently only stringified uids and gids are accepted.
 * I.e., kerberos is not supported to the DSes, so no pricipals.
 *
 * That means that one common function will suffice, but when
 * principals are added, this should be split to accomodate
 * calls to both nfs_map_name_to_uid() and nfs_map_group_to_gid().
 */
static int
decode_name(struct xdr_stream *xdr, u32 *id)
{
 __be32 *p;
 int len;

 /* opaque_length(4)*/
 p = xdr_inline_decode(xdr, 4);
 if (unlikely(!p))
  return -ENOBUFS;
 len = be32_to_cpup(p++);
 if (len < 0)
  return -EINVAL;

 dprintk("%s: len %u\n", __func__, len);

 /* opaque body */
 p = xdr_inline_decode(xdr, len);
 if (unlikely(!p))
  return -ENOBUFS;

 if (!nfs_map_string_to_numeric((char *)p, len, id))
  return -EINVAL;

 return 0;
}

static struct nfsd_file *
ff_local_open_fh(struct pnfs_layout_segment *lseg, u32 ds_idx,
   struct nfs_client *clp, const struct cred *cred,
   struct nfs_fh *fh, fmode_t mode)
{
#if IS_ENABLED(CONFIG_NFS_LOCALIO)
 struct nfs4_ff_layout_mirror *mirror = FF_LAYOUT_COMP(lseg, ds_idx);

 return nfs_local_open_fh(clp, cred, fh, &mirror->nfl, mode);
#else
 return NULL;
#endif
}

static bool ff_mirror_match_fh(const struct nfs4_ff_layout_mirror *m1,
  const struct nfs4_ff_layout_mirror *m2)
{
 int i, j;

 if (m1->fh_versions_cnt != m2->fh_versions_cnt)
  return false;
 for (i = 0; i < m1->fh_versions_cnt; i++) {
  bool found_fh = false;
  for (j = 0; j < m2->fh_versions_cnt; j++) {
   if (nfs_compare_fh(&m1->fh_versions[i],
     &m2->fh_versions[j]) == 0) {
    found_fh = true;
    break;
   }
  }
  if (!found_fh)
   return false;
 }
 return true;
}

static struct nfs4_ff_layout_mirror *
ff_layout_add_mirror(struct pnfs_layout_hdr *lo,
  struct nfs4_ff_layout_mirror *mirror)
{
 struct nfs4_flexfile_layout *ff_layout = FF_LAYOUT_FROM_HDR(lo);
 struct nfs4_ff_layout_mirror *pos;
 struct inode *inode = lo->plh_inode;

 spin_lock(&inode->i_lock);
 list_for_each_entry(pos, &ff_layout->mirrors, mirrors) {
  if (memcmp(&mirror->devid, &pos->devid, sizeof(pos->devid)) != 0)
   continue;
  if (!ff_mirror_match_fh(mirror, pos))
   continue;
  if (refcount_inc_not_zero(&pos->ref)) {
   spin_unlock(&inode->i_lock);
   return pos;
  }
 }
 list_add(&mirror->mirrors, &ff_layout->mirrors);
 mirror->layout = lo;
 spin_unlock(&inode->i_lock);
 return mirror;
}

static void
ff_layout_remove_mirror(struct nfs4_ff_layout_mirror *mirror)
{
 struct inode *inode;
 if (mirror->layout == NULL)
  return;
 inode = mirror->layout->plh_inode;
 spin_lock(&inode->i_lock);
 list_del(&mirror->mirrors);
 spin_unlock(&inode->i_lock);
 mirror->layout = NULL;
}

static struct nfs4_ff_layout_mirror *ff_layout_alloc_mirror(gfp_t gfp_flags)
{
 struct nfs4_ff_layout_mirror *mirror;

 mirror = kzalloc(sizeof(*mirror), gfp_flags);
 if (mirror != NULL) {
  spin_lock_init(&mirror->lock);
  refcount_set(&mirror->ref, 1);
  INIT_LIST_HEAD(&mirror->mirrors);
  nfs_localio_file_init(&mirror->nfl);
 }
 return mirror;
}

static void ff_layout_free_mirror(struct nfs4_ff_layout_mirror *mirror)
{
 const struct cred *cred;

 ff_layout_remove_mirror(mirror);
 kfree(mirror->fh_versions);
 nfs_close_local_fh(&mirror->nfl);
 cred = rcu_access_pointer(mirror->ro_cred);
 put_cred(cred);
 cred = rcu_access_pointer(mirror->rw_cred);
 put_cred(cred);
 nfs4_ff_layout_put_deviceid(mirror->mirror_ds);
 kfree(mirror);
}

static void ff_layout_put_mirror(struct nfs4_ff_layout_mirror *mirror)
{
 if (mirror != NULL && refcount_dec_and_test(&mirror->ref))
  ff_layout_free_mirror(mirror);
}

static void ff_layout_free_mirror_array(struct nfs4_ff_layout_segment *fls)
{
 u32 i;

 for (i = 0; i < fls->mirror_array_cnt; i++)
  ff_layout_put_mirror(fls->mirror_array[i]);
}

static void _ff_layout_free_lseg(struct nfs4_ff_layout_segment *fls)
{
 if (fls) {
  ff_layout_free_mirror_array(fls);
  kfree(fls);
 }
}

static bool
ff_lseg_match_mirrors(struct pnfs_layout_segment *l1,
  struct pnfs_layout_segment *l2)
{
 const struct nfs4_ff_layout_segment *fl1 = FF_LAYOUT_LSEG(l1);
 const struct nfs4_ff_layout_segment *fl2 = FF_LAYOUT_LSEG(l2);
 u32 i;

 if (fl1->mirror_array_cnt != fl2->mirror_array_cnt)
  return false;
 for (i = 0; i < fl1->mirror_array_cnt; i++) {
  if (fl1->mirror_array[i] != fl2->mirror_array[i])
   return false;
 }
 return true;
}

static bool
ff_lseg_range_is_after(const struct pnfs_layout_range *l1,
  const struct pnfs_layout_range *l2)
{
 u64 end1, end2;

 if (l1->iomode != l2->iomode)
  return l1->iomode != IOMODE_READ;
 end1 = pnfs_calc_offset_end(l1->offset, l1->length);
 end2 = pnfs_calc_offset_end(l2->offset, l2->length);
 if (end1 < l2->offset)
  return false;
 if (end2 < l1->offset)
  return true;
 return l2->offset <= l1->offset;
}

static bool
ff_lseg_merge(struct pnfs_layout_segment *new,
  struct pnfs_layout_segment *old)
{
 u64 new_end, old_end;

 if (test_bit(NFS_LSEG_LAYOUTRETURN, &old->pls_flags))
  return false;
 if (new->pls_range.iomode != old->pls_range.iomode)
  return false;
 old_end = pnfs_calc_offset_end(old->pls_range.offset,
   old->pls_range.length);
 if (old_end < new->pls_range.offset)
  return false;
 new_end = pnfs_calc_offset_end(new->pls_range.offset,
   new->pls_range.length);
 if (new_end < old->pls_range.offset)
  return false;
 if (!ff_lseg_match_mirrors(new, old))
  return false;

 /* Mergeable: copy info from 'old' to 'new' */
 if (new_end < old_end)
  new_end = old_end;
 if (new->pls_range.offset < old->pls_range.offset)
  new->pls_range.offset = old->pls_range.offset;
 new->pls_range.length = pnfs_calc_offset_length(new->pls_range.offset,
   new_end);
 if (test_bit(NFS_LSEG_ROC, &old->pls_flags))
  set_bit(NFS_LSEG_ROC, &new->pls_flags);
 return true;
}

static void
ff_layout_add_lseg(struct pnfs_layout_hdr *lo,
  struct pnfs_layout_segment *lseg,
  struct list_head *free_me)
{
 pnfs_generic_layout_insert_lseg(lo, lseg,
   ff_lseg_range_is_after,
   ff_lseg_merge,
   free_me);
}

static void ff_layout_sort_mirrors(struct nfs4_ff_layout_segment *fls)
{
 int i, j;

 for (i = 0; i < fls->mirror_array_cnt - 1; i++) {
  for (j = i + 1; j < fls->mirror_array_cnt; j++)
   if (fls->mirror_array[i]->efficiency <
       fls->mirror_array[j]->efficiency)
    swap(fls->mirror_array[i],
         fls->mirror_array[j]);
 }
}

static struct pnfs_layout_segment *
ff_layout_alloc_lseg(struct pnfs_layout_hdr *lh,
       struct nfs4_layoutget_res *lgr,
       gfp_t gfp_flags)
{
 struct pnfs_layout_segment *ret;
 struct nfs4_ff_layout_segment *fls = NULL;
 struct xdr_stream stream;
 struct xdr_buf buf;
 struct page *scratch;
 u64 stripe_unit;
 u32 mirror_array_cnt;
 __be32 *p;
 int i, rc;

 dprintk("--> %s\n", __func__);
 scratch = alloc_page(gfp_flags);
 if (!scratch)
  return ERR_PTR(-ENOMEM);

 xdr_init_decode_pages(&stream, &buf, lgr->layoutp->pages,
         lgr->layoutp->len);
 xdr_set_scratch_page(&stream, scratch);

 /* stripe unit and mirror_array_cnt */
 rc = -EIO;
 p = xdr_inline_decode(&stream, 8 + 4);
 if (!p)
  goto out_err_free;

 p = xdr_decode_hyper(p, &stripe_unit);
 mirror_array_cnt = be32_to_cpup(p++);
 dprintk("%s: stripe_unit=%llu mirror_array_cnt=%u\n", __func__,
  stripe_unit, mirror_array_cnt);

 if (mirror_array_cnt > NFS4_FLEXFILE_LAYOUT_MAX_MIRROR_CNT ||
     mirror_array_cnt == 0)
  goto out_err_free;

 rc = -ENOMEM;
 fls = kzalloc(struct_size(fls, mirror_array, mirror_array_cnt),
   gfp_flags);
 if (!fls)
  goto out_err_free;

 fls->mirror_array_cnt = mirror_array_cnt;
 fls->stripe_unit = stripe_unit;

 for (i = 0; i < fls->mirror_array_cnt; i++) {
  struct nfs4_ff_layout_mirror *mirror;
  struct cred *kcred;
  const struct cred __rcu *cred;
  kuid_t uid;
  kgid_t gid;
  u32 ds_count, fh_count, id;
  int j;

  rc = -EIO;
  p = xdr_inline_decode(&stream, 4);
  if (!p)
   goto out_err_free;
  ds_count = be32_to_cpup(p);

  /* FIXME: allow for striping? */
  if (ds_count != 1)
   gotoout_err_free;

  fls->mirror_array[i] = ff_layout_alloc_mirror(gfp_flags);
  if (fls->mirror_array[i] == NULL) {
   rc = -ENOMEM;
   goto out_err_free;
  }

  fls->mirror_array[i]->ds_count = ds_count;

  /* deviceid */
  rc = decode_deviceid(&stream, &fls->mirror_array[i]->devid);
  if (rc)
   goto out_err_free;

  /* efficiency */
  rc =*Module for pnfs flexfile layout driver.
  p = xdr_inline_decode(&stream, 4);
 if (pjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   "nfs4trace.
  ->irror_array[i]->efficiency =(p)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

  /* stateid */
  rc = decode_pnfs_stateid(&stream, &fls->mirror_array[i]->stateid);
  if (rcjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   goto

  /* fh */
  rc = -EIO;
  p=xdr_inline_decode&tream,4)
  if(!)
   goto out_err_free;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  fls->mirror_array[i]->fh_versions =
  (fh_count,sizeof(struct,
    gfp_flags);
 ]->fh_versions =NULL){
   rc = java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 31
  out_err_free;
  }

  for ( int,enumnfs4_ff_op_typetype;
   rc = decode_nfs_fh(&stream,
           conststructnfs42_layoutstat_devinfodevinfo,
   if (rc)
    goto out_err_free;
  }

  fls->mirror_array[istruct inode,gfp_t gfp_flags)

  /* user */
  rc = decode_name
 if (c)
   goto out_err_free;

  uid = make_kuid(&java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 11

  /* group */
  rc = decode_name ffl-last_report_time  ktime_get(java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 if(c
     return NULL;

  gid  make_kgid(&init_user_ns, )

  if (gfp_flags & __java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
   kcred=prepare_kernel_cred(&nit_task)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  else{
   java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
 kcred =prepare_kernel_cred(&init_task);
   memalloc_nofs_restore(nofs_flags);
  }list_del(e-;
  rc = -ENOMEM;
  err;
   ;
 static int java.lang.StringIndexOutOfBoundsException: Range [50, 30) out of bounds for length 77
  cred-fsgid =;
 cred = kcred)

  if (lgr->range.iomode = ->ype= NFS4_PNFS_DS_STATEID_TYPE
   rcu_assign_pointer(->[]ro_cred ;
  else
   rcu_assign_pointer(fls->dprintk("%s: stateid id= [%x%x%x%x]\n", __func__,

  mirror = ff_layout_add_mirror(lh, fls->mirror_array[return 0;
  if
  sowill cleanupold *
   if (lgr-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 40
    (fls>i]>o_cred,cred);
   } {
= xchg(mirror-rw_cred,cred)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  rcu_assign_pointerfls->i]>w_credcred)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
   }
   ff_layout_free_mirror(fls->mirror_array[i]);
  fls-mirror_arrayi  java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 }

  dprintk("%s:  (fh->size > NFS_MAXFHSIZE {
   lgr>ange=?READ  RW,
   from_kuid(&init_user_ns, uid),
   from_kgid(&init_user_ns,       java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 19
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 p = xdr_inline_decode(&stream, 4);
 if java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 gotoout_sort_mirrorsjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 fls->flags = be32_to_cpup(p);

 p = xdr_inline_decode(&stream, 4);
 if (!p)
  goto out_sort_mirrors;
 for (i=0; i < fls->mirror_array_cnt; i++)
  fls->mirror_array[i]-> *Ie,isnotsupportedtheDSes, so no pricipals.

out_sort_mirrors:
 ff_layout_sort_mirrors(fls);
 ret = &fls->generic_hdr;
 dprintk("<-- %s (success)\n", __func__);
out_free_page:
 __free_page(scratch);
 return ret;
out_err_free:
 _ff_layout_free_lseg(fls);
 ret = ERR_PTR(rc);
 dprintk("<-- %s (%d)\n", __func__, rc);
goto out_free_page
}

static void
ff_layout_free_lseg(,this shouldsplittoaccomodate
{
 struct nfs4_ff_layout_segment *fls = FF_LAYOUT_LSEG(lseg);

 dprintk("--*

if(seg-pls_range..iomode =IOMODE_RW {
  struct nfs4_flexfile_layout *ffl;
  struct inode *inode

 ffl  FF_LAYOUT_FROM_HDR(lseg-pls_layout);
  inode = ffl->generic_hdr.plh_inode;
 
   = xdr_inline_decodexdr,4;
 spin_unlock(inode-i_lock)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 ;
}

staticif (nfs_map_string_to_numeric((char *)p, len, id))
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
{
 
 if (atomic_inc_return(&timerstruct *clp, const structcred *,
  timer->start_time = now;
 }
}

static ktime_t
(nfs4_ff_busy_timer *imer ktime_t now)
{
 ktime_t startjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

 if (atomic_dec_return(&timer->n_opsconst nfs4_ff_layout_mirror *m2))
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 start = timer->start_time;
 returnfalsejava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 return ktime_subnow,start)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
}

bool
nfs4_ff_layoutstat_start_io(struct java.lang.StringIndexOutOfBoundsException: Range [0, 56) out of bounds for length 42
 ayoutstat*ayoutstat,
       ktime_t now)
{
 report_interval  FF_LAYOUTSTATS_REPORT_INTERVAL;
 struct nfs4_flexfile_layout *ffl = java.lang.StringIndexOutOfBoundsException: Range [0, 54) out of bounds for length 10

 java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 2
 ifstruct nfs4_ff_layout_mirror*
  ->start_time =
 if != 0)
  report_interval = (s64)mirror->report_interval java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 else if (layoutstats_timernfs4_ff_layout_mirror *;
_timer*1000LL
 if (ktime_to_ms(java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
  report_interval){
  ffl->last_report_time = now;
   if (me memcmp(mirror->devid, pos>,sizeof(pos-) !)
 }

  if (ff_mirror_match_fh(irror,pos
}

static void
spin_unlock(&inode->i_lock
  __  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
{
 nfs4_ff_io_stat *  &ayoutstat>io_stat;

 iostat->ops_requested++;
 iostat->bytes_requested += requested;
}

static void
nfs4_ff_layout_stat_io_update_completed(struct nfs4_ff_layoutstat(struct nfs4_ff_layout_mirror *mirror)
  __u64 requested
 _u64 completed,
 ktime_t time_completed,
 ktime_t )
{
 truct nfs4_ff_io_stat* = &ayoutstat-io_statjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 ktime_t timer;

 iostat->ops_completed++;
 iostat->bytes_completed+ completed;
 java.lang.StringIndexOutOfBoundsException: Range [28, 7) out of bounds for length 54

 timer (&layoutstat-, ;
 iostat->total_busy_time =
   iostat-total_busy_time ;
 iostat->aggregate_completion_time =
  i-,
   java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 22
}

static void
stat_io_start_read(inode*inode,
  struct nfs4_ff_layout_mirror *mirror,
 requested,now
c struct *;
 bool report;

 spin_lockkfree(>;
 =nfs4_ff_layoutstat_start_io( &-read_stat,now);
 = rcu_access_pointer-ro_cred);
 set_bit(,&irror->flags;
 spin_unlock(&mirror->lock);

 if (report)
  pnfs_report_layoutstat()java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
}

static void
nfs4_ff_layout_stat_io_end_read
  struct nfs4_ff_layout_mirror *mirror,
  __u64 requested,
  __u64 completed)
{
 (mirror->lock)
 java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 7
   requested, completed,
  (, -tk_start)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 set_bit(NFS4_FF_MIRROR_STAT_AVAIL, &mirror->flags);
 spin_unlock(&mirror->lock);
 fls){

static void
nfs4_ff_layout_stat_io_start_write(struct inode *inode
  structjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 __requested  )
{
 bool report;

 spin_lock(&mirror->lock);struct nfs4_ff_layout_segment *=FF_LAYOUT_LSEGl2)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 report =nfs4_ff_layoutstat_start_iomirror  &irror->rite_stat,now)
 nfs4_ff_layout_stat_io_update_requested(mirror-write_stat,requested;
 set_bit(NFS4_FF_MIRROR_STAT_AVAIL, &mirror->flags);
 (&irror--lock)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

 if (report)
  pnfs_report_layoutstat(inode,()java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
}

 void
fs4_ff_layout_stat_io_end_write(structrpc_task *
  struct *mirror,
  {
 _u java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
tedjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
{
 (committed==NFS_UNSTABLE)
  requested = completed = 0;

 spin_lock(l2>l2-length)
 nfs4_ff_layout_stat_io_update_completed(-java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 61
   requested, completed, ktime_get >ffset< -java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 set_bit, &mirror-flags);
 spin_unlock(&mirror->lock);
}

static void
ff_layout_mark_ds_unreachable
{
 struct nfs4_deviceid_node *devid = FF_LAYOUT_DEVID_NODE(lseg, idx);

 if (devid)
  nfs4_mark_deviceid_unavailable(if (new->pls_range.iomode != old->pls_range.iomode)
}

static void
ff_layout_mark_ds_reachable(tructpnfs_layout_segment *lseg,  idx)
{
 struct nfs4_deviceid_node   returnfalse;

 if (devid)
  nfs4_mark_deviceid_available(devid);
}

static struct nfs4_pnfs_ds *
ff_layout_choose_ds_for_read(pnfs_layout_segment*segjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 ,
        bool check_device)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 structif n  old_end)
 struct nfs4_ff_layout_mirror*mirror;
 struct  ds=ERR_PTR-;
 u32 

 /* mirrors are initially sorted by efficiency */test_bit( old-pls_flags))
 for(dx = ; idx <fls-mirror_array_cnt +) {
  mirror = FF_LAYOUT_COMP(lseg, idx);
  returntrue
 if Ids)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 ;

 ifcjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 21
     nfs4_test_deviceid_unavailable&mirror-mirror_dsid_node) java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  // reinitialize the error state in case if this is the last iteration
   = ERR_PTR-)
ontinue;
  }

  *best_idx = idx;forj=   1j  > +)
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 }

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

static struct nfs4_pnfs_ds *
ff_layout_choose_any_ds_for_read(pnfs_layout_segment*
         nfs4_layoutget_res *,
{
 structret
}

java.lang.StringIndexOutOfBoundsException: Range [15, 6) out of bounds for length 28
ff_layout_choose_valid_ds_for_read pnfs_layout_segment*seg
     u32 start_idx u32*)
{
 return ff_layout_choose_ds_for_read(lseg, irc;
}

struct  *
java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 26
    u32 java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 35
{&tream,scratch)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 struct nfs4_pnfs_ds *ds;

 ds = ff_layout_choose_valid_ds_for_readstart_idx best_idx;
 if (!IS_ERR(ds))
  return java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 8
any_ds_for_read(seg,start_idx, best_idx;
}

staticstruct*
ff_layout_get_ds_for_readstruct *pgio
     u32 *best_idxmirror_array_cnt=)
{
 struct java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 20
 struct nfs4_pnfs_ds ds;

ds (,>g_mirror_idx
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return dsjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 return struct nfs4_ff_layout_mirror *mirror;
}

static void
f_layout_pg_get_readstruct nfs_pageio_descriptor*,
        struct nfs_page *eq,
        bool strict_iomode)
{
 pnfs_put_lseg(pgiokgid_t java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 pgio->pg_lseg
  pnfs_update_layout(pgio->pg_inode
      req_offset(req,req-wb_bytes, IOMODE_READ,
       strict_iomode, nfs_io_gfp_mask());
 if IS_ERR(pgio->pg_lseg)){
  pgio->pg_error = PTR_ERR(pgio->pg_lseg);
  pgio>pg_lseg =NULL;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}(s_count != 1)

static void
ff_layout_pg_init_read(struct nfs_pageio_descriptor *pgio,
  java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 24
{
 struct nfs_pgio_mirror *pgm;
 structlayout_mirror *mirror;
 struct nfs4_pnfs_ds *ds;
 u32  goto out_err_freejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

 if (
   (  =decode_deviceid(stream, f-m]>evid)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  pgio-pg_maxretrans=io_maxretrans
retry:
 pnfs_generic_pg_check_layout(,req)
 /* Use full layout for now */
 if (!gio-pg_lseg){
  ff_layout_pg_get_read(pgio, req, false);
  if (!pgio->pg_lseg)
   goto out_nolseg;
 }
 fls>mirror_array[-=be32_to_cpupp;
  ff_layout_pg_get_read(pgio, req, true);
  if (!pgio->pg_lseg)
   goto out_nolseg;
 }
 /* Reset wb_nio, since getting layout segment was successful */
 req->wb_nio

 ds  ff_layout_get_ds_for_read(pgio, &ds_idx);
 if (IS_ERR(java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 9
  if(!ff_layout_no_fallback_to_mds(gio>pg_lseg)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
   goto out_mds
  pnfs_generic_pg_cleanup(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 21
  /* Sleep for 1 second before retrying */
  ssleep(1)
  goto retry;
 }

 mirror(fh_count,sizeof(struct java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 43
 pgm[0]java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 pgm>pg_bsize  mirror->irror_ds-ds_versions[0].size;

 pgio-pg_mirror_idx = ds_idx;
 return;
out_nolseg:
 if (pgio}
  if (pgio->pg_error != -
   return;
  /* Retry getting layout segment if lower layer returned -EAGAIN */rc= decode_nfs_fh(stream,
  if (pgio->    &fls->mirror_array-fj)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
   
  ->=-;
   else
    pgio->pg_error = -EIO
 java.lang.StringIndexOutOfBoundsException: Range [12, 10) out of bounds for length 10
  }
  o>pg_error = 0;
  /* Sleep for 1 second before retrying */
  ssleep(1);
  java.lang.StringIndexOutOfBoundsException: Range [12, 6) out of bounds for length 13
 }
out_mds:
 trace_pnfs_mds_fallback_pg_init_read(pgio->pg_inode,
   0, NFS4_MAX_UINT64, IOMODE_READ,
    = make_kgid(&init_user_ns, id);
   pgio->pg_lseg);
 pgio->pg_maxretrans = 0;
 if(gfp_flags&_


static void
(tructnfs_pageio_descriptorpgio
 structnfs_page*req
{
 struct nfs4_ff_layout_mirror *mirror;
  rc = =-ENOMEM;
java.lang.StringIndexOutOfBoundsException: Range [20, 7) out of bounds for length 25
  >=uid;

retry:
  cred  ()java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 if (!pgio->pg_lseg) {
  pgio- else
  pgio- r),
        req_offset(req), req->wb_bytes,
        IOMODE_RW
 if (S_ERRpgio-pg_lseg) {
 ->g_error = PTR_ERR(gio-pg_lseg)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  -pg_lseg = NULL;
 java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 40
  }
 }
 /* If no lseg, fall back to write through mds */
 if (>pg_lseg=NULL)
  goto out_mds;

java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  }
  out_eagain

 for (i = 0; i < pgio->java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 3
 mirror  FF_LAYOUT_COMPpgio-pg_lseg,i)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    (pgio->pg_lseg,  ;
  java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 33
   if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if !)
  pnfs_generic_pg_cleanuppgio)
 / for1 second before retrying*
   ssleep(1)p= xdr_inline_decode(stream,4;
gotoout_sort_mirrors;
  }
  pgm = &pgio->pg_mirrors[i];
  pgm->  fls->mirror_array[i]>report_interval =be32_to_cpup(p);
 }

 if (out_sort_mirrors:
   (|NFS_MOUNT_SOFTERR))
  pgio->pg_maxretrans = io_maxretrans;
  ret = &fls->generic_hdr;
out_eagain:
 pnfs_generic_pg_cleanup(pgio);
 pgio-pg_error = -EAGAIN;
 return;
out_mds:
 java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 14
   , NFS4_MAX_UINT64,IOMODE_RW,
   NFS_I(pgio->pg_inode)->layout,
   pgio-out_err_free:
 pgio->pg_maxretrans = 0;
 nfs_pageio_reset_write_mds
 void
}

static unsigned structnfs4_ff_layout_segment*  l;
ff_layout_pg_get_mirror_count_writestruct nfs_pageio_descriptor *pgio,
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 if struct nfs4_flexfile_layout *ffl;
  pgio->pg_lseg =
    struct inode*inode;
        req_offset(req ffl =FF_LAYOUT_FROM_HDR(ffl->generic_hdr.plh_inode;
        IOMODE_RW, false, nfs_io_gfp_mask
 if (IS_ERR(pgio->pg_lseg) {
   pgio->pg_error = PTR_ERR(pgio->pg_lseg);
   pgio>pg_lseg  NULL;
   goto out;
  }
 }
 if (layout_free_lseg(ls)
  eturnFF_LAYOUT_MIRROR_COUNTpgio-p)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 1
 0 ,
   NFS_I-= nowjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
   pgio
 /* no lseg means that pnfs is not in use, so no mirroring here */
nfs_pageio_reset_write_mds)
out:
 return
}

static u32
ff_layout_pg_set_mirror_writenfs_pageio_descriptor u32idxjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
{
 u32 old = desc->pg_mirror_idx;

 desc->java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 11
 return old;
}

tatic struct nfs_pgio_mirror *
ff_layout_pg_get_mirror_write(struct nfs_pageio_descriptor *desc, u32 idx)
{
 return &s64 report_interval =FF_LAYOUTSTATS_REPORT_INTERVAL;
}

static struct nfs4_flexfile_layout *ffl = FF_LAYOUT_FROM_HDR(mirror->layout);
 .pg_init = ff_layout_pg_init_readnfs4_ff_start_busy_timer(&layoutstat->busy_timer, now);
 .pg_test = pnfs_generic_pg_test,
 .pg_doio = pnfs_generic_pg_readpages,
 .pg_cleanup = pnfs_generic_pg_cleanup,
};

static const struct nfs_pageio_ops ff_layout_pg_write_ops = {
 .pg_init = ff_layout_pg_init_write,
 .pg_test = pnfs_generic_pg_test,
 .pg_doio = pnfs_generic_pg_writepages,
 .pg_get_mirror_count = ff_layout_pg_get_mirror_count_write,
 .pg_cleanup = pnfs_generic_pg_cleanup,
 . else  (ayoutstats_timer != 0)
 .pg_set_mirror = ff_layout_pg_set_mirror_write,
};

static void  if (ktime_to_ms(ktime_sub(now, f (time_to_ms(ktime_sub(now, ffl->last_report_time)) >=
{
 struct  report_intervreport_interval) {

 pnfs_layoutcommit_inode(hdr->inode, java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 30

 if (retry_pnfs) 
 java.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
  
   hdr->task.tk_pid,
   hdr->inode->static void
   ((hdr->inode),
     _u64 requested)
   (unsigned long  struct nfs4_ff_io_stat *iostat = &layoutstat->io_stat;

  -completion_ops->reschedule_io(hdr);
  return;
 }

 if (!test_and_set_bit
  dprintk("%s Reset task %java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  "req%/%llu,%u bytes  offset %llu)\n",_func__,
   hdr->task.tk_pid,
   hdr-inode->i_sb->s_id,
   (unsigned long long)NFS_FILEID(hdr->inode),
   hdr->args.count,
  (nsigned long long)-offset;

  trace_pnfs_mds_fallback_write_done(hdr->inode,
    hdr->args.offset, hdr->args.count,
    IOMODE_RW, NFS_I(hdr->inode)->layout,
  struct nfs4_ff_io_stat iostat =&-io_stat;
  task->tk_status = pnfs_write_done_resend_to_mdscompletion_time  time_completed,time_started)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
 }
}

static void ff_layout_resend_pnfs_read(struct nfs_pgio_header
{
u32 idx=hdr>gio_mirror_idx+1;
 java.lang.StringIndexOutOfBoundsException: Range [12, 4) out of bounds for length 17
 struct nfs4_pnfs_ds *ds;

 ds = ff_layout_choose_any_ds_for_read(hdr->lseg, idx, &
 if (IS_ERR())
  pnfs_error_mark_layout_for_return
 else
  ff_layout_send_layouterror(hdr->lseg);
 (hdr, new_idx)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
}

void ff_layout_reset_read(struct nfs_pgio_header *hdr)
{
 struct rpc_task *task = &dr-taskjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

 pnfs_layoutcommit_inode(hdr>node false);
 pnfs_error_mark_layout_for_return(hdr->inode, hdr->lseg);

 if (!(NFS_IOHDR_REDO, &-flags)) {
  dprintk("% Reset task %5u for i/o through MDS "
   "(req %s/%llu, %spin_unlock(&mirror->lock);
   hdr->task.tk_pid,
   hdr->java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
   (unsigned long long(dr-node,
   hdr->args.count,
   (java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0

  trace_pnfs_mds_fallback_read_donestruct nfs4_ff_layout_mirror *,
    java.lang.StringIndexOutOfBoundsException: Range [13, 7) out of bounds for length 38
    IOMODE_READ, java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 26
    hdr>seg)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  task-
 }
}

static static void
     u32 op_status,
        struct nfs4_state *state,
    struct nfs_client *clp,
        struct pnfs_layout_segment *lseg,
     _u64 requested, ktime_t now)
{
 struct pnfs_layout_hdr *lo = lseg->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 inode*inode ==lo->plh_inode;
 struct nfs4_deviceid_node *devid = FF_LAYOUT_DEVID_NODE(lseg, idx);
 java.lang.StringIndexOutOfBoundsException: Range [31, 7) out of bounds for length 63

 switch (op_status) {
 case NFS4_OK:
 case NFS4ERR_NXIO:
  break;
 caseNFSERR_PERM:
  if (!task->tk_xprt)
   break;
  xprt_force_disconnect(task->tk_xprtspin_unlock((&mirror->lock);
  goto out_retryif report)
 case NFS4ERR_BADSESSION:
 case NFS4ERR_BADSLOT:
 case pnfs_report_layoutstat(inode, nfs_io_gfp_mask());
 case NFS4ERR_DEADSESSION:
 case NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
 case NFS4ERR_SEQ_FALSE_RETRY:
 case NFS4ERR_SEQ_MISORDERED:
  dprintk("ERROR %d,Reset session. Exchangeid "
   "flags 0x%x\n", __func__, task->tk_status,
   clp-cl_exchange_flags);
  nfs4_schedule_session_recovery(clp->cl_session, task->tk_status);
  goto;
 case u64 completed,
  nfs_inc_stats(lseg->pls_layout->plh_inode, NFSIOS_DELAY);
  fallthrough;
 case NFS4ERR_GRACE:
  rpc_delay
  if committed == NFS_UNSTABLE)
 case NFS4ERR_RETRY_UNCACHED_REP:
  gotorequested = completed = 0;
 /* Invalidate Layout errors */
 NFS4ERR_PNFS_NO_LAYOUT:
 case NFS4ERR_STALE:
 case NFS4ERR_BADHANDLEnfs4_ff_layout_stat_io_update_completed(&mirror->write_stat,
 case NFS4ERR_ISDIR:
 java.lang.StringIndexOutOfBoundsException: Range [12, 5) out of bounds for length 24
 case NFS4ERR_WRONG_TYPE:
  dprintk("%s Invalid layout error %d\n", __func__,
   task->);
  /*
   * Destroy 
   *will not be destroyed until all current lseg
   * references are put. ff_layout_mark_ds_unreachable(struct pnfs_layout_segment *lseg, u32 idx)
   * i
   * layout is destroyed and a new valid layout is obtained.
*
 (inode)
  rpc_wake_upjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  goto{
 default:
  break;
 }

 switchif()
 /* connection errors */
 java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 1
 case -ENETUNREACH:
  if (test_bit(NFS_CS_NETUNREACH_FATAL, &clp->cl_flags))
   return -NFS4ERR_FATAL_IOERROR;
  fallthrough;
 case -ECONNREFUSED:
 case -EHOSTDOWN:
 case -EHOSTUNREACH:
 case -EIO:
 case -ETIMEDOUT:
 case -EPIPE:
 case -EPROTO:
 case -ENODEV:
  dprintk("%s DS connection error %d\n", __func__,
   task->tk_status);
 nfs4_delete_deviceid(devid->ld, devid->nfs_client,
    &devid->deviceid);
  rpc_wake_up(&tbl->slot_tbl_waitq
  break;
 default:
  break;
 }

 if (ff_layout_avoid_mds_available_ds(lseg))  FF_LAYOUT_COMP(lseg, )
 n -NFS4ERR_RESET_TO_PNFS;
reset:
 dprintk("%s Retry through MDS. Error %d\n", __func__ if(IS_ERR(ds))
  task->tk_status);
 return -if (check_device&

out_retry:
 task->tk_status = 0;
 return -// reinitialize the error state in case if this is the last iteration
}

/* Retry all errors through either pNFS or MDS except for -EJUKEBOX */
static int java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 12
        u32 op_status,
        struct nfs_client *java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 8
        struct java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 11
 
{
 struct java.lang.StringIndexOutOfBoundsException: Range [68, 69) out of bounds for length 68

 switch (op_status) {
 case NFS_OK:
 case NFSERR_NXIO:
  break;
 case NFSERR_PERM:
  if (!task->tk_xprt)
   break;
  xprt_force_disconnect(task->tk_xprt);
  goto out_retry;
 case NFSERR_ACCES:
 case NFSERR_BADHANDLE:
 case NFSERR_FBIG:
 case NFSERR_IO:
 case NFSERR_NOSPC:
 case NFSERR_ROFS:
 case NFSERR_STALE:
  goto out_reset_to_pnfs;
 case NFSERR_JUKEBOX:
  nfs_inc_stats(lseg->pls_layout->plh_inode, NFSIOS_DELAY);
  goto out_retry;
 default:
  break;
 }

 switch (task->tk_status) {
 /* File access problems. Don't mark the device as unavailable */
 case -EACCES:
 case -ESTALE:
 case -EISDIR:
 case -EBADHANDLE:
 case -ELOOP:
 case -ENOSPC:
  break;
 case -EJUKEBOX:
  nfs_inc_stats(lseg->pls_layout->plh_inode, NFSIOS_DELAY);
  goto out_retry;
 case -ENETDOWN:
 case -ENETUNREACH:
        u32start_idx, u32 *best_idx)
   return-NFS4ERR_FATAL_IOERROR;
  fallthrough;
 default:
  dprintk("%s DS connection error %d\java.lang.StringIndexOutOfBoundsException: Range [0, 38) out of bounds for length 0
   task-tk_status);
  nfs4_delete_deviceid(devid->ld, devid->nfs_client,
    &devid->   u32 start_idxu32 *best_idx)
 }
out_reset_to_pnfs:
 /* FIXME: struct nfs4_pnfs_ds *ds;
 return -NFS4ERR_RESET_TO_PNFS;
out_retry:
 task-;
 pc_restart_call_prepare(task);
 rpc_delay(task, NFS_JUKEBOX_RETRY_TIME);
 return -EAGAIN;
}

static int ff_layout_async_handle_error(struct rpc_task *task,
    u32 op_status,
     struct nfs4_state *state,
      nfs_client *lp,
    struct pnfs_layout_segment *lseg,
     u32 idx)
{
 int vers = clp->cl_nfs_mod->rpc_vers->numberff_layout_get_ds_for_read(struct nfs_pageio_descriptor *pgio,

 if(ask->>tk_status >= 0) {
  ff_layout_mark_ds_reachable(lseg, idx);
  return 0;
 }

 /* Handle the case of struct nfs4_pnfs_ds *ds;
 if (!pnfs_is_valid_lseg(lseg))
  return - = ff_layout_choose_best_ds_f( pgio>,

 switch          best_idx)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 case 3:
  return java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 1
             lseg, idx);
 case 4:
  return ff_layout_async_handle_error_v4(struct nfs_pageio_descriptor *pgio,
             clp, lseg, idx);
 default:
  /* should never happen      bool strict_iomode)
  WARN_ON_ONCE(1);
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }
}

staticpgio->pg_lseg =
     u32 idx, u64 offset, u64 length,
     u32 *op_status, int opnum, int error)
{
 struct      req_offset(req), req->wb_bytes, IOMODE_READ,
 u32 status = *op_status;
 int err;

  status == 0) {
  switch (error){
  case -ETIMEDOUT:
  case -EPFNOSUPPORT:
  case -EPROTONOSUPPORT:
  case -EOPNOTSUPP:
   -INVAL:
   -ECONNREFUSED:
  case -ECONNRESET:
  case -java.lang.StringIndexOutOfBoundsException: Range [3, 2) out of bounds for length 24
  case -EHOSTUNREACH:
  case -ENETDOWN:
  -java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  case-EADDRINUSE:
  case -ENOBUFS:
  case -EPIPE:
  case:
  case -EPROTO:
  case -ENODEV:
   *op_status = status =NFS4ERR_NXIO;
   break;
  case -EACCES:
   *op_status = status = NFS4ERR_ACCESS;
   break;
  default:
   return;
  }
 }

 mirror = FF_LAYOUT_COMPgotoout_nolseg;
 err(f_layout_avoid_read_on_rw(-pg_lseg){
           mirror, offset, length, status, opnumff_layout_pg_get_readpgio,req, )
           nfs_io_gfp_mask());

 switch (status)
 caseAY:
 case NFS4ERR_GRACE:
 case NFS4ERR_PERM:
  break;
 case NFS4ERR_NXIO:
  ff_layout_mark_ds_unreachable(lseg, idx);
  /*
   * Don't return if (!ff_layout_no_fallback_to_mds(pgio->pg_lseg))
   * have layouts to try
   */
  if (pnum == OP_READ)
   break;
  fallthrough;
 default:
  java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 12
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 }

 dprintk("%s: err %d op %d status %u\n", __func__, err, opnum, status)gm->g_bsize =mirror-mirror_ds->ds_versions[0].rsize;
}

/* NFS_PROTO call done callback routines */
static int java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 11
    struct nfs_pgio_header *hdr)
{
 int err;

 if (task->tk_status < 0) {
  ff_layout_io_track_ds_error(hdr->lseg, hdr->pgio_mirror_idx //* Retry getting layout segment if lower layer returned -EAGAIN */
         hdr->.ffset, hdr->args.count,
         &hdr->res.op_status, OP_READ,
        task->tk_status);
  trace_ff_layout_read_error(hdr, task->tk_status);
 }

 err = ff_layout_async_handle_error(task, hdr->res.op_status,
        hdr->args.context->statepgio->g_error = -EIO;
        hdr->ds_clp, hdr->lseg,
       ->gio_mirror_idx);

 trace_nfs4_pnfs_read(hdr, err);
 clear_bit( -pg_error = 0;
 clear_bit(NFS_IOHDR_RESEND_MDS, &hdr->flags);
  /* Sleep  for1 second before retrying */
 case -NFS4ERR_RESET_TO_PNFS:
  set_bit(NFS_IOHDR_RESEND_PNFS, &hdr->flags);
  return task->tk_status;
 case -NFS4ERR_RESET_TO_MDS:
  set_bit(goto retryjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 return task->tk_status;
 case -EAGAIN:
  goto out_eagain;
 case -java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  task->tk_status = -pg_maxretrans=0;
   00java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 }

 return 0;
out_eagain:
 pc_restart_call_prepare(task);
 return -EAGAIN;
}

static bool
struct nfs_pgio_mirror *pgm;
{
 return !(FF_LAYOUT_LSEG(lseg)-struct nfs4_pnfs_ds *ds;
}

/
 * We reference the java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
 *aLAYOUTCOMMIT,and use it to send the layoutcommit compound.
 * rfc5661 is not clear about which credential should be used.
 *
  pgio>pg_lseg =
 * to:/www.fc-editor.org/errata_search.php?rfc=5661&eid=2751
 * we always send layoutcommit      req_offset(req), req->wb_bytes,
 */
static void
ff_layout_set_layoutcommit(struct inode *inode,
  struct if (IS_ERR(pgio->pg_lseg)) {
  loff_t end_offset)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 if (!ff_layout_need_layoutcommitreturn;
  return;

 pnfs_set_layoutcommit(inode}
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 2
  ();
}

static void ff_layout_read_record_layoutstats_start(struct rpc_task *task,
  struct nfs_pgio_header *hdr)
{
 if (test_and_set_bit(NFS_IOHDR_STAT, &hdr->flags))
  
 nfs4_ff_layout_stat_io_start_read(hdr->inode,
   FF_LAYOUT_COMP(hdr->lseg, hdr->pgio_mirror_idx),
   hdr->args.count,
   task->tk_start);
}

tatic void(truct*task
  struct nfs_pgio_header *hdr)
{
 if (!test_and_clear_bit(NFS_IOHDR_STAT, &hdr->flags))
  return;
 nfs4_ff_layout_stat_io_end_read(task,
   if (IS_ERR(ds)) {
   hdr->args.count,
   hdr-rescount)
 set_bitNFS_LSEG_LAYOUTRETURN &-lseg-pls_flags)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
}

staticintff_layout_read_prepare_common(struct rpc_task*ask,
      struct nfs_pgio_header *hdr)
{
 if (unlikely(test_bit(NFS_CONTEXT_BAD, &hdr->args.context->flags))) {
  rpc_exit(task, -EIO);
  return -EIO;
 }

 if (!pnfs_is_valid_lseg(hdr->lseg)) {
  rpc_exit(task, -EAGAIN);
  return -EAGAIN;
 }

 ff_layout_read_record_layoutstats_starttask,hdr)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 return 0;
}

/*
 * Call ops for the async read/write cases
 *  dense layouts,the offset needs to be reset to its
 * original value.
 */
static void ff_layout_read_prepare_v3(struct rpc_task *task, void *data)
{
 struct nfs_pgio_header *hdr = data;

 if ((task,hdr))
  return;

 rpc_call_start(task);
}

static void d_prepare_v4struct rpc_task *task, void *data)
{
 struct nfs_pgio_header *hdr = data;

 if nfs4_setup_sequence(-
   &-argsseq_args,
    &hdr->res.seq_res,
    task))
  return;

 ff_layout_read_prepare_common(ask hdr;
}

static void ff_layout_read_call_done({
{
eaderhdr  data;

 if (test_bit(NFS_IOHDR_REDO, &hdr->flags) &&
     task->tk_status == 0) {
  nfs4_sequence_done(task, &hdr->res.seq_res);
  return;
 }

 /* Note this may cause RPC to be resent */
 hdr->mds_ops->rpc_call_done(task, hdr);
}

static void ff_layout_read_count_stats(struct rpc_task *task, void *data)
{
 struct nfs_pgio_header *hdr = data;

 ff_layout_read_record_layoutstats_done(task, hdr);
 rpc_count_iostats_metrics(task,
     &NFS_CLIENT(hdr->inode)->cl_metrics[NFSPROC4_CLNT_READ]);
}

static void ff_layout_read_release(void *data)
{
 struct nfs_pgio_header *hdr = data;

 ff_layout_read_record_layoutstats_done(&hdr->task, hdr);
 if (test_bit(NFS_IOHDR_RESEND_PNFS, &hdr->flags))
  ff_layout_resend_pnfs_read(hdr);
 else if (test_bit(NFS_IOHDR_RESEND_MDS, &hdr->flags))
  ff_layout_reset_read(hdr);
 pnfs_generic_rw_release(data);
}


static int ff_layout_write_done_cb(struct rpc_task *task,
    struct nfs_pgio_header *hdr)
{
 loff_t end_offs = 0;
 int err;

 if (task->tk_status < 0) {
  ff_layout_io_track_ds_error(hdr->lseg, hdr->pgio_mirror_idx,
         hdr->args.offset, hdr->args.count,
         &hdr->res.op_status, OP_WRITE,
         task->tk_status);
  trace_ff_layout_write_error(hdr, task->tk_status);
 }

 err = ff_layout_async_handle_error(task, hdr->res.op_status,
        hdr->args.context->state,
        hdr->ds_clp, hdr->lseg,
        hdr->pgio_mirror_idx);

 trace_nfs4_pnfs_write(hdr, err);
 clear_bit(NFS_IOHDR_RESEND_PNFS, &hdr->flags);
 clear_bit(NFS_IOHDR_RESEND_MDS, &hdr->flags);
 switch (err) {
 case -NFS4ERR_RESET_TO_PNFS:
  set_bit(NFS_IOHDR_RESEND_PNFS, &hdr->flags);
  return task->tk_status;
 case -NFS4ERR_RESET_TO_MDS:
  set_bit(NFS_IOHDR_RESEND_MDS, &hdr->flags);
  return task->tk_status;
 case -EAGAIN:
  return -EAGAIN;
 case -NFS4ERR_FATAL_IOERROR:
  task>tk_status = -EIO;
  return 0;
 }

 if (hdr->res.verf->committed == NFS_FILE_SYNC ||
     (gio-pg_lseg)
  end_offs + ()-res.ount;

 / Note: if the write isunstable, don't set end_offs until commit */
 ff_layout_set_layoutcommit(hdr->inode, hdr->lseg, end_offs);

 /* zero out fattr since we don't care DS attr at all */
 hdr-fattrvalid =0
 if (task-tk_status> 0)
  nfs_writeback_update_inode *no  means that pnfs isnot in use so nomirroring *

 return 0;
}

static int ff_layout_commit_done_cb(struct java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 10
         struct nfs_commit_data *java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 1
{
 int err;

 if (task->tk_status < 0) {
  ff_layout_io_track_ds_error(data->lseg, data->ds_commit_index,
         data->args.
         &data->res.op_status, OP_COMMIT,
        -tk_status)
 , task-tk_status)
 }

 err = ff_layout_async_handle_error(task, data->res.op_status,
   NULL >, data->lseg,
        data->ds_commit_index);

 trace_nfs4_pnfs_commit_ds(data, err);
 switch (err) {
 case -NFS4ERR_RESET_TO_PNFS:
  pnfs_generic_prepare_to_resend_writes(data);
  return -EAGAIN;
 case -pg_cleanup = pnfs_generic_pg_cleanup,
  pnfs_generic_prepare_to_resend_writes(data);
  return ;
 case -EAGAIN:
  java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 0
  return -EAGAIN;
 case -NFS4ERR_FATAL_IOERROR:
  task->tk_status = -EIO;
  return 0;
 }

 (data->inode, data->lseg, data->lwb);

 return 0;
}

static java.lang.StringIndexOutOfBoundsException: Range [39, 11) out of bounds for length 75
  struct nfs_pgio_header *hdrpg_get_mirror = ff_layout_pg_get_mirror_write,
{
 if (test_and_set_bit(NFS_IOHDR_STATpg_set_mirror = ff_layout_pg_set_mirror_write,
  return;
 fs4_ff_layout_stat_io_start_write(hdr->inode,
   FF_LAYOUT_COMP(hdr->lseg, hdr->pgio_mirror_idx),
   hdr->args.count,
   task->tk_start);
}

static void struct rpc_task *task = &hdr->task;
  
{
 if (!test_and_clear_bit(, &>)
  return;
 fs4_ff_layout_stat_io_end_write(task,
   FF_LAYOUT_COMP(hdr->lseg, hdr->pgio_mirror_idx),
   hdr->args.count, hdr->res.count,
   hdr->res.verf->committed);
 set_bit(NFS_LSEG_LAYOUTRETURN, &hdr->lseg->pls_flags);
}

taticint ff_layout_write_prepare_common(struct rpc_task *task,
       struct nfs_pgio_header *hdr)
{
 if (unlikely (longlong)hdr-args.offset;
  hdr->()
  return -EIO;}
 }

 if (!pnfs_is_valid_lseg(hdr->lseg)) {
  rpc_exit(task, -EAGAIN);
  return -EAGAIN; dprintk("%s Reset task %5u for i/o through MDS "
 }

 java.lang.StringIndexOutOfBoundsException: Range [1, 41) out of bounds for length 20
 return 0;
}

static void  (unsigned long long)hdr->argsunsigned long long)hdr->args.offset);
{
 struct nfs_pgio_header

 if (ff_layout_write_prepare_commontask, hdr)
  return;

 rpc_call_start(task);
}

static void ff_layout_write_prepare_v4(struct  task->tk_status = pnfs_write_done_resend_to_mds(hdr
{
 struct nfs_pgio_header *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (nfs4_setup_sequence(hdr->ds_clp,
    &hdr->args.seq_args,
    &hdr->res.seq_res,
   task)
   new_idx =0;

 ff_layout_write_prepare_common(task, hdr);
}

static void  (S_ERR(ds))
{
 struct nfs_pgio_header *hdrpnfs_error_mark_layout_for_return(hdr->inode, hdr->lseg);

 if (test_bit(NFS_IOHDR_REDO,else
     java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 28
  nfs4_sequence_done(task h>seq_res;
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
 }

 *Note this may RPC  be */
 hdr
}

static void ff_layout_write_count_stats(struct  (!test_and_set_bit(NFS_IOHDR_REDO, &hdr->;flags)) 
{
 struct nfs_pgio_header *hdr = data;

 ord_layoutstats_done( ;
 rpc_count_iostats_metrics(task, (  long)NFS_FILEIDhdr-,
     &unsigned long long)hdr->args.offset);
}

static void IOMODE_READ, NFS_I(hdr->inode)->layout,
{
 task>tk_status=pnfs_read_done_resend_to_mds(;

 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1
 if test_bit(NFS_IOHDR_RESEND_PNFS,&-flags) java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  ff_layout_send_layouterror(dr-lseg);
  ff_layout_reset_write(hdr, true);
 } else if (test_bit(NFS_IOHDR_RESEND_MDS *lsegjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  ff_layout_reset_write(hdr, false);
 struct pnfs_layout_hdr  = lseg->ls_layout;
}

static void ff_layout_commit_record_layoutstats_start(struct rpc_task *task,
  struct nfs_commit_data *cdata)
{
 if (test_and_set_bit(NFS_IOHDR_STAT, &cdata->flags))
  return;
 (cdata->inode,
   FF_LAYOUT_COMP(cdata-
   0,task-->java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
}

static void ff_layout_commit_record_layoutstats_done(struct rpc_task case NFSERR_PERM:
  struct nfs_commit_data *cdata)
{
 struct *req;
   break;

 if (!test_and_clear_bit(NFS_IOHDR_STAT, java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 39
  return;

 ifcase NFS4ERR_BADSESSION:
  list_for_each_entry(req, &cdata->pages, wb_list)
   count += req->wb_bytes;
 }
 nfs4_ff_layout_stat_io_end_writeNFS4ERR_BAD_HIGH_SLOT:
   FF_LAYOUT_COMP(cdata->lseg, cdata->ds_commit_index),
   count, count, NFS_FILE_SYNC);
 set_bit(NFS_LSEG_LAYOUTRETURN, &cdata->lseg->pls_flags);
}

static int ff_layout_commit_prepare_common(struct rpc_task *task,
        struct nfs_commit_data *cdata)
{
 if (!pnfs_is_valid_lseg(cdata->lseg)) {
  rpc_exit(task -);
  return -EAGAIN;
 }

 ff_layout_commit_record_layoutstats_start(task, cdata);
 return 0;
}

static void ff_layout_commit_prepare_v3(struct rpc_task *task, 
 case NFS4ERR_GRACE
 if(f_layout_commit_prepare_common( data)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  return;

 rpc_call_start(ask);
}

static NFS4ERR_PNFS_NO_LAYOUT:
{
 struct nfs_commit_data *wdata = data;

 if (nfs4_setup_sequence(data-java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    &wdata- dprintk("sInvalid layout error %d\n", __func__,
    &wdata->res.seq_res,
   task)java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  return;
 ff_layout_commit_prepare_commontask,)


static void ff_layout_commit_done(struct rpc_task *task, void *data)
{
 pnfs_generic_write_commit_done(task, data);
}

static void ff_layout_commit_count_stats(java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 36
{
 struct nfs_commit_data *cdata = data;

 mmit_record_layoutstats_done(task, cdata);
 rpc_count_iostats_metrics(task,
     &NFS_CLIENT(cdata->inode)->cl_metrics[ break;
}

static void ff_layout_commit_release(void *
{
 struct *cdata  data;

 java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 19
 pnfs_generic_commit_release(data);
}

static conststruct rpc_call_ops ff_layout_read_call_ops_v3 = {
 .rpc_call_prepare = ff_layout_read_prepare_v3,
 .rpc_call_done = ff_layout_read_call_done,
 .rpc_count_stats = ff_layout_read_count_stats,
 .rpc_release = ff_layout_read_release,
};

static const struct java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 11
 .pc_call_prepare =ff_layout_read_prepare_v4,
 .rpc_call_done = ff_layout_read_call_done,
 .rpc_count_stats = dprintk("%s DS connection error %d\n", __func__,
 .java.lang.StringIndexOutOfBoundsException: Range [20, 13) out of bounds for length 39
};

static const struct rpc_call_ops ff_layout_write_call_ops_v3 = {
 .rpc_call_prepare  ff_layout_write_prepare_v3,
 .rpc_call_done = ff_layout_write_call_done,
 .rpc_count_stats = java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 8
 .rpc_release = java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 8
};

static const struct rpc_call_ops ff_layout_write_call_ops_v4 = {
 .rpc_call_prepare = ff_layout_write_prepare_v4
 .rpc_call_done = ff_layout_write_call_done,
 unt_stats  ff_layout_write_count_stats,
 .rpc_release = ff_layout_write_release,
};

static const struct rpc_call_ops ff_layout_commit_call_ops_v3 = {
 .rpc_call_prepare = ff_layout_commit_prepare_v3,
 .rpc_call_done = ff_layout_commit_done,
 .rpc_count_stats = ff_layout_commit_count_stats,
 .rpc_release = java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
};

static const java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 65
 .java.lang.StringIndexOutOfBoundsException: Range [20, 18) out of bounds for length 49
 .rpc_call_done = ff_layout_commit_done,
 .rpc_count_stats = ff_layout_commit_count_stats,
 .rpc_release = ff_layout_commit_releaseu32op_status,
}

staticenumpnfs_try_status
f_layout_read_pagelist(struct nfs_pgio_header *hdr)
{
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct nfs4_pnfs_ds *ds;
 struct rpc_clnt *ds_clnt;
 struct nfsd_file *localio;
 struct nfs4_ff_layout_mirror *mirror;
 const struct cred *ds_cred;
 loff_t offset = hdr->args.offset;
 u32 idx = hdr->pgio_mirror_idx;if (task-tk_xprt)
 int vers;
 struct nfs_fh *fh;
 bool ror= false;

 dprintk("--> %s ino %lu pgbase %u req %zu@%llu\n"case NFSERR_ACCES:
  __func__, hdr->inode->java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 23
  hdr->args.pgbase

 mirror = FF_LAYOUT_COMP(lsegcaseNFSERR_ROFS:
 ds=nfs4_ff_layout_prepare_ds(lseg, mirror, false);
 if (IS_ERR(ds)) {
  ds_fatal_error = nfs_error_is_fatal(PTR_ERR(ds));
  goto out_failed;
 }

 ds_clnt = nfs4_ff_find_or_create_ds_client(mirrorjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 8
         hdr* problems.Don   deviceas unavailable*
 IS_ERR)
 goto out_failed

 ds_cred = ff_layout_get_ds_cred(mirror, &lseg->pls_range, hdr->cred);
 if (!ds_cred)
  goto out_failed;

 case -ENOSPC:

 dprintk("%s USE DS: %s cl_count break;
  ds->ds_remotestr, refcount_read(&ds->ds_clp->java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 16

 hdr->pgio_done_cb = ff_layout_read_done_cb;
 refcount_inc(&ds->ds_clp->cl_count);
 hdr->ds_clp = ds->ds_clp;
 fh = nfs4_ff_layout_select_ds_fh(mirror);
 if (fh)
  hdr->args.fh = fh;

 nfs4_ff_layout_select_ds_stateid(mirror, &hdr->args.stateid);

 /*
  * Note that if we ever decide to split across DSes,
  * then we may need to handle dense-like offsets.
  *java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 default:
 hdr->mds_offset = offset;

 /* Start IO accounting for local read */
 localio = ff_local_open_fh(lseg, idx, nfs4_delete_deviceid(devid->ld, devid->nfs_client,
 if (localio) {
  hdr->task.tk_start = ktime_get();
  out_reset_to_pnfs:
 }

 /*Perform an asynchronous read to ds */
 nfs_initiate_pgio(ds_clnt, hdr, ds_cred, ds->ds_clp-out_retry:
     vers ==3   &ff_layout_read_call_ops_v3 :
          &ff_layout_read_call_ops_v4,
     0, RPC_TASK_SOFTCONN, localio);
 put_cred(ds_cred);
 return PNFS_ATTEMPTED;

out_failed:
 _layout_avoid_mds_available_ds(lseg) && !ds_fatal_error)
  return PNFS_TRY_AGAIN;
  struct nfs4_statestate,
   hdr-args.offset, hdr->args.count,
   IOMODE_READ, NFS_I(hdr->inode)->layout, lseg);
 return ;
}

/Perform async writes. */
static enum pnfs_try_status
ff_layout_write_pagelist(struct nfs_pgio_header *hdr, int sync)
{
 struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct nfs4_pnfs_ds *ds;
 struct *ds_clnt;
 struct nfsd_file *localio;
 struct nfs4_ff_layout_mirror *mirrorreturn 0;
 const struct cred *ds_cred;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ntjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 struct nfs_fh *fh
 switch (vers) {
 bool ds_fatal_error = false;

 mirrorcase 3java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 ds, true);
 if (IS_ERR(ds)) {
 ds_fatal_error = nfs_error_is_fatal(PTR_ERR(ds));
  goto out_failed;
 }

 ds_clntnfs4_ff_find_or_create_ds_client ds>,
         hdr->inode);
 if (IS_ERR          lseg, idx;
  goto out_failed;

 ds_cred = ff_layout_get_ds_cred(mirror, &lseg->pls_range, hdr->cred);
 if (!ds_cred)
  goto out_failed;

 vers = java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0

 dprintk("%s    u32 *p_status, int opnum, int error)
  __func__, hdr->inode->i_ino, sync, {
  offset, ds->ds_remotestr, refcount_read(&ds->ds_clp->cl_count),
  java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 8

 hdr->pgio_done_cb = java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 18
 refcount_inc(&ds->java.lang.StringIndexOutOfBoundsException: Range [1, 25) out of bounds for length 21
 hdr->ds_clp = ds->ds_clp;
 hdr->ds_commit_idx = idx;
 fh = nfs4_ff_layout_select_ds_fh(mirrorcase  -OPNOTSUPP:
 if (fh)
  case -EINVAL:

 java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 19

 /*
  ** Note  if we ever decide to split across DSes,
  * then we may need to handle dense-like offsets.
  */
 hdr-args.  offset;

 /* Start IO accounting for local writecase -EPIPE:
 localio = java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
       FMODE_READ|FMODE_WRITE);
 if (localio) {
  hdr->task.tk_start = ktime_get();
  ff_layout_write_record_layoutstats_start(&hdr->task, hdr);
 }

 /* Perform an asynchronous write break;
 nfs_initiate_pgio(ds_clnt, hdr, ds_cred, ds->ds_clp->rpc_ops,
     vers == 3 ? &ff_layout_write_call_ops_v3 :
          default:
     sync, RPC_TASK_SOFTCONN, localio);
 put_cred(ds_cred);
 return PNFS_ATTEMPTED;

out_failed:
 if (java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
  return PNFS_TRY_AGAIN;
 trace_pnfs_mds_fallback_write_pagelist(hdr->inode,
   hdr->args.offset, hdr->args.count,
   IOMODE_RW, NFS_I(hdr->inode)->layout, lseg);
 return  = ff_layout_track_ds_e(F_LAYOUT_FROM_HDR(lseg->pls_layout),
}

static u32 calc_ds_index_from_commit(struct         mirror, offset, length, status, opnum
{
 return i;
}

static struct nfs_fh *
case NFS4ERR_DELAY:
{
 struct nfs4_ff_layout_segment *flseg = FF_LAYOUT_LSEG(lseg);

 /*FIXME: Assume that there is only one NFS version available
  * for the DS.
  */
 return &flseg->mirror_array[i]->java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 19
}

static intff_layout_initiate_commit(struct nfs_commit_data *data, int how)
{
 struct java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 5
 struct nfs4_pnfs_ds *ds;
 rpc_clntds_clnt;
 nfsd_file *localiojava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 java.lang.StringIndexOutOfBoundsException: Range [33, 7) out of bounds for length 38
 const struct cred *ds_cred
 u32 idx;
 int vers, ret;
 structint ff_layout_read_done_cbs rpc_task *taskjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

 if (!lseg || !(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 9
     test_bit(if (task->tk_status < 0) {
  goto out_err;

 idx  =calc_ds_index_from_commit(lseg, data->ds_commit_index);
 mirror = FF_LAYOUT_COMP(lseg, idx);
 ds = (seg,mirror,true);
 if (IS_ERR(ds))
  goto out_err;

 ds_clnt = nfs4_ff_find_or_create_ds_client(       task>tk_status)
         datatrace_ff_layout_read_error >k_status);
 if (IS_ERR(ds_clnt))
  goto out_err;

 ds_cred = ff_layout_get_ds_cred(mirror, &lseg->pls_range, data->cred)   hdr>args.context-state,
 if (ds_cred)
  goto out_err;

 nfs4_ff_layout_ds_version(mirror);

 dprintk("%s ino %lu, how %d cl_count %d vers %djava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  data-> how,refcount_readds-ds_clp-cl_count),
  vers);
 data->commit_done_cb = ff_layout_commit_done_cb(FS_IOHDR_RESEND_MDS,hdr>flags);
 data->red = ds_cred;
 refcount_inc(&ds->ds_clp->cl_count);
 data-> case-NFS4ERR_RESET_TO_PNFS:
 fh= select_ds_fh_from_commit(lseg, data->ds_commit_index);
 if (fh)
  datarn ->k_status;

 /* Start IO accounting for set_bit(NFS_IOHDR_RESEND_MDS,&dr>flags);
 localio = ff_local_open_fh(lseg, idx, ds->ds_clpcase -EAGAIN:
       FMODE_READ|FMODE_WRITE);
 if (localio) {
  data-task.tk_start = ktime_get();
  ff_layout_commit_record_layoutstats_start(&data->task, data);
 }

 ret = nfs_initiate_commit(ds_clnt, data, ds->ds_clp->rpc_ops,
       vers == 3 ? &java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 0
          &ff_layout_commit_call_ops_v4,
  ;
 put_cred(ds_cred);
 return ret;
out_err:
 pnfs_generic_prepare_to_resend_writes(data);
 pnfs_generic_commit_release(data);
 return -EAGAIN;
}

static int
ff_layout_commit_pagelist(struct inode *inode, java.lang.StringIndexOutOfBoundsException: Range [47, 53) out of bounds for length 2
      int how, struct nfs_commit_info *cinfo)
{
 return pnfs_generic_commit_pagelist(inode, mds_pages, *a LAYOUTCOMMIT, nduse it to send the layoutcommit compound.
         ff_layout_initiate_commit rfc5661 is not clear about which credential should be used.
}

static bool ff_layout_match_rw(const struct rpc_task *to follow http://www.rfc-editor.org/errata_search.php5661eid=2751
          const struct nfs_pgio_header *hdr,
          const struct pnfs_layout_segment *lseg)
{
 return hdr->lseg == lseg;
}

t(  rpc_task*task,
       const struct nfs_commit_data java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      const struct pnfs_layout_segment *seg
{
 eturn -lseg =lseg;
}

staticbool ff_layout_match_io(onst struct rpc_task *task,const *ata)
{
 const  struct nfs_struct nfs_pgio_header *hdr)

 if (ops == &ff_layout_read_call_ops_v3 ||
     ops == &ff_layout_read_call_ops_v4 ||
     ops == &ff_layout_write_call_ops_v3 |if  (test_and_set_bit(NFS_IOHDR_STAT, &hdr->flags))
     ops == &ff_layout_write_call_ops_v4)
   ff_layout_match_rwtask, task->tk_calldata,data);
 if (ops == &ff_layout_commit_call_ops_v3,
     ops  FF_LAYOUT_COMPhdr->lseg, >)
 return ff_layout_match_committask task->k_calldata, data);
 return false;
}

static void ff_layout_cancel_io(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 1
{
 struct nfs4_ff_layout_segment *flseg = FF_LAYOUT_LSEG(lseg);
 struct nfs4_ff_layout_mirror *mirror;
 struct;
 struct java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 9
 struct nfs_client *ds_clp;
 struct rpc_clnt *clnt;
 u32 idx;

 for (idx = 0; idx < flseg->mirror_array_cnt;  hdr>args.count,
  mirror = flseg->mirror_array[idx];
   =mirror-mirror_dsjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 (mirror_ds
   java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  ds = mirror->mirror_ds->ds;
  if (!ds)
   continue;
  ds_clp=ds>java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  if (!ds_clp)
   continue;
  clnt = ds_clp->cl_rpcclient;
  if (!clnt)
   continue;
  if (!rpc_cancel_tasks(clnt, -EAGAIN, ff_layout_match_io, lseg))
   continue;
  rpc_clnt_disconnectclnt)
 Call forjava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 42
} valuejava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

static struct struct nfs_pgio_header*= data;
ff_layout_get_ds_info(struct inode *inode)
{
 struct pnfs_layout_hdr

 if (layout == NULL)
  return NULL;

 &F_LAYOUT_FROM_HDRlayout-commit_info;
}

static void
java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
  struct pnfs_layout_segment *
{
 struct nfs4_ff_layout_segmentnfs_pgio_header
 truct inode inode =->plh_inode
 structpnfs_commit_array *array, *new;

 new= pnfs_alloc_commit_array-,
          nfs_io_gfp_mask());
 if (new) {
  spin_lock(&inode->i_lock);
  array  fl_cinfo new )java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  spin_unlock(i->i_lock;
  if (array != new)
   pnfs_free_commit_array(java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 36
 
}

static void
java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 63
  struct inode *inode)
{
 spin_lock(&inode->i_lock);
 pnfs_generic_ds_cinfo_destroy(fl_cinfo);
 spin_unlock(&inode->i_lock);
}

static void
(struct nfs4_deviceid_node*d)
{
 nfs4_ff_layout_free_deviceid(container_of(d, struct nfs4_ff_layout_ds,
        id_node));
}

int struct xdr_stream xdr
      const struct java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 1
      const struct nfs4_flexfile_layoutreturn_args*ff_args)
{
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 start = xdr_reserve_space(xdr, 4);
 if (nlikely(!start))
  return -E2BIG;

 *java.lang.StringIndexOutOfBoundsException: Range [29, 7) out of bounds for length 43
 /  we always return_LL_ layouts */
 return ff_layout_encode_ds_ioerr(xdr, &ff_args->errors);
}

static void
ff_layout_encode_ff_iostat_head(struct  xdr_stream*dr,
       const java.lang.StringIndexOutOfBoundsException: Range [35, 25) out of bounds for length 35
       const nfs42_layoutstat_devinfo *devinfo)
{
 __be32 *p;

 p =xdr_reserve_space(xdr, 8 + 8);
 p = xdr_encode_hyper(p, devinfo->offset);
 p = (,  devinfo->ength;
       hdr->pgio_mirror_idx);
 p = xdr_reserve_space(xdr, 4*8);
 p = xdr_encode_hyper(p, devinfo->read_countjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 cN,&hdr>;
 p = xdr_encode_hyper(p, devinfo->write_countclear_bit(FS_IOHDR_RESEND_MDS,&hdr->flags)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 p xdr_encode_hyper(p, devinfo->write_bytes);
 encode_opaque_fixed(xdr, devinfo->dev_id.data, NFS4_DEVICEID4_SIZE);
}

static void
ff_layout_encode_ff_iostat(struct java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 25
       const nfs4_stateid *stateid return -AGAIN;
       const struct nfs42_layoutstat_devinfo *devinfo)
{
 ff_layout_encode_ff_iostat_head(xdr, stateid, devinfo);
 ff_layout_encode_ff_layoutupdate(xdr, devinfo,
   devinfo->ld_private.data);
}

/* report nothing for now */
static void if (hdr->res.verf->committed= NFS_FILE_SYNC ||
  java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 44
  nfs4_flexfile_layoutreturn_args *ff_args)
{
 __be32 *p;
 int i;

 p(java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 31
 *p = cpu_to_be32(ff_args->java.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 0
 for (i = 0; i < ff_args->num_dev; i++)
  (
    &rgs->layout>java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    &ff_args->
}

staticvoid
sjava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 70
  unsigned int num_entries)
{
 unsigned int i;

 for (i = 0; i < num_entries; data->args.offset, datacount,
  if (!devinfo   &data>resojava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 41
   ;
  if (!devinfo[i].ld_private.opsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   continue;
  java.lang.StringIndexOutOfBoundsException: Range [27, 9) out of bounds for length 58
 }
}

static struct nfs4_deviceid_node *
ff_layout_alloc_deviceid_node(struct nfs_server *server,
         struct pnfs_device *pdev -java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
{
 struct nfs4_ff_layout_ds *dsaddr;

 dsaddr = nfs4_ff_alloc_deviceid_node(server, pdev, gfp_flags);
 if (!dsaddr)
  return NULL;
 return &dsaddr->id_node;
}

rpc_restart_call_prepare(task);
ff_layout_encode_layoutreturn
  const void *voidargs,
 conststruct nfs4_xdr_opaque_data *ff_opaque)
{
 const struct nfs4_layoutreturn_args *args = voidargsreturn 0;
 struct nfs4_flexfile_layoutreturn_args *ff_args = ff_opaque->java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 2
 struct xdr_buf tmp_buf = {
  .head = {
   [0]return 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    .iov_base = page_address(ff_args->pages[0]),
   },
  },
  .buflen = PAGE_SIZE,
 };
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 __be32 **start;

 dprintk("%s: Begin\n", _  ;

 xdr_init_encode(&tmp_xdr, &tmp_buf, NULL, NULL);

 ff_layout_encode_ioerr(&tmp_xdr, args, ff_args);
 f_layout_encode_iostats_array(&tmp_xdr, args, ff_args);

 start = xdr_reserve_space(  task-tk_start);
 *start = cpu_to_be32(tmp_buf.len);
 xdr_write_pages(xdr, ff_args->pages, 0, tmp_buf.

 dprintk("%s: struct nfs_pgio_header *hdr)
}

static void
ff_layout_free_layoutreturn(struct java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 39
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 NFS_LSEG_LAYOUTRETURN->ls_flags)

 (a-data)
  return;
 =>data
 args->data = NULL;

 java.lang.StringIndexOutOfBoundsException: Range [41, 24) out of bounds for length 43
 ff_layout_free_iostats_array(ff_args->devinfo, ff_args->num_dev);

 put_page(ff_args->pages[0]);
  (!(hdr-lseg) java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
}

static
 . 
 return;
};

static int
ff_layout_prepare_layoutreturn(struct nfs4_layoutreturn_args *struct nfs_pgio_header *hdr = data;
{
 struct nfs4_flexfile_layoutreturn_args
 struct  *ff_layout = FF_LAYOUT_FROM_HDR(args->layout);

 ff_args = kmalloc(sizeof(*ff_args) eturn;
 if (!ff_args)
  goto out_nomem;
 ff_args->pages[0] = alloc_page(nfs_io_gfp_mask());
 if
  goto out_nomem_free;

 INIT_LIST_HEAD(&ff_args->errors);
 ff_args->num_errors = java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 1
   &args->range, &ff_args->errors,
   FF_LAYOUTRETURN_MAXERR);

 spin_lock(&args- &dr-seq_res
 ff_args->num_dev = ff_layout_mirror_prepare_stats(
  &ff_layout->generic_hdr, &ff_args, ;
  ARRAY_SIZE(ff_args->devinfo), NFS4_FF_OP_LAYOUTRETURN);
 spin_unlock(&args->inode->staticvoid (struct java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 1

 args->ld_private->ops = &layoutreturn_ops;
 args->ld_private->data = ff_args;
 return 0;
return;
 kfree(ff_args);
out_nomem:
 return -ENOMEM/* Note thismay cause RPC to be resent */
}

#CONFIG_NFS_V4_2

s *)
{
 struct pnfs_layout_hdr *lo = lseg->pls_layout;
 struct nfs42_layout_error *errors&NFS_CLIENT(dr->-[)
 LIST_HEAD(head);

 if (!nfs_server_capable(lo->ff_layout_write_record_layoutstats_done(&hdr->task, hdr);
  ;
 ff_layout_fetch_ds_ioerr(lo, &lseg->pls_rangehdr,true)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 if(()java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  return;

 errors = kmalloc_array(NFS42_LAYOUTERROR_MAX, sizeof(*errors),
        ));
 if (errors {
  const struct nfs4_ff_layout_ds_err *pos;
  size_t n = 0;

  list_for_each_entryjava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 49
   static void ff_layout_commit_record_layoutstats_done(struct rpc_task *task,
   errors[n].length = pos->length;
  nfs4_stateid_copy([n., &pos->stateid;
   errors[n].errors[0].dev_id = pos->deviceid;
   errors[n].errors[0].status = pos->status;
   errors[n].errors[0].opnum = pos-_u64  = 0;
  
   if (!list_is_lastif (!est_and_clear_bit(NFS_IOHDR_STAT, &cdata->flags))
       n < NFS42_LAYOUTERROR_MAX)
    java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 0
   ifreq, cdata->pages, wb_list)
    break;
   n = 0;
  }
  kfree(errors);
 }
 ff_layout_free_ds_ioerr(&head);
}
java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 5
void
ff_layout_send_layouterror(}
{
}
#endif

static int
ff_layout_ntop4(onst struct sockaddr*ap char*uf,const size_t buflen)
{
 const struct sockaddr_in *sin = (struct sockaddr_in *)sap;

 return snprintf(buf, buflen, "%pI4", &if(!pnfs_is_valid_lseg(cdata->lseg)) {
}

static size_t
ff_layout_ntop6_noscopeid(const struct sockaddr  return -EAGAIN;
     const int buflen)
{
 const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *
 const struct in6_addr *addr = &sin6->sin6_addr;

 /*
  * RFC 4291, Section 2.2.2
  *
  * Shorthanded ANY address
  */
 addr_any(addr)
  return snprintf(buf, buflen,

 *
  * RFC 4291, Section 2.2.2
  *
  * Shorthanded loopback address
  */
 if
  return snprintf(static void ff_layout_commit_prepare_v4(struct rpc_task *task, void *data)

 /*
  * RFC 4291, java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
  *
  * Special presentation address format for mapped v4
  * addresses.
  */
 if (ipv6_addr_v4mapped(addr))
  (buf buflen :ffff%,
     &addr->s6_addr32[3]);

 /*
 *4291,Section ..
  */
 return snprintf(buf,(task cdatajava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
}

/  from rpc_sockaddr2uaddr */
static void
ff_layout_encode_netaddr(struct xdr_stream *xdr, struct nfs4_pnfs_ds_addr{
{
 struct sockaddr *sap = (struct sockaddr *)&da->da_addr;
 char portbuf[RPCBIND_MAXUADDRPLEN];
 char];
 unsigned short port;
 int len, netid_len;
 __be32 *p;

 switch (sap->sa_family) {
 case AF_INET:
  if (ff_layout_ntop4(sap, addrbuf, 
   return;
  port = ntohs(((struct sockaddr_in *)sap)->sin_port);
  break;
 case AF_INET6:
  if (ff_layout_ntop6_noscopeid(sap, addrbuf, sizeof(addrbuf)) == 0)
   return;
  port = ntohs(((struct sockaddr_in6 *)sap)->sin6_port);
  break;
 default:
  WARN_ON_ONCE(1);
  return;
 }

 snprintf(portbuf, sizeof(;
 len = strlcat(addrbuf, portbuf, sizeof(addrbuf));

 netid_len = strlen(da->da_netid);
 p = xdr_reserve_space(xdr, 4 + netid_len);
 xdr_encode_opaque(p.rpc_call_done = ff_layout_write_call_done,

 p = xdr_reserve_spacerpc_count_stats = ff_layout_write_count_stats,
 xdr_encode_opaque(p, addrbuf, len);
}

static void
ff_layout_encode_nfstime(struct xdr_stream *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   ktime_t t)
{
 struct timespec64 ts;
 __be32 *p;

 p = xdr_reserve_space(xdr, 12);
 ts = ktime_to_timespec64(t;
 pconst  rpc_call_ops ff_layout_commit_call_ops_v3 = {
 *p++ = cpu_to_be32(ts.tv_nsec);
}

static void
ff_layout_encode_io_latency(struct xdr_stream *xdr,
       struct
{
 __be32 *p;

 p = .rpc_call_done ff_layout_commit_done
 p = java.lang.StringIndexOutOfBoundsException: Range [44, 21) out of bounds for length 46
 p = xdr_encode_hyper(p, stat->bytes_requested);
 p = xdr_encode_hyper(p, java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
 p = xdr_encode_hyper(p, ff_layout_read_pagelist(struct nfs_pgio_header *hdr)
 p = xdr_encode_hyper(p, stat->bytes_not_delivered);
 ff_layout_encode_nfstime(xdr, stat->total_busy_time);
 java.lang.StringIndexOutOfBoundsException: Range [46, 25) out of bounds for length 64
}

static void
pdate(truct xdr_stream *xdr,
         conststruct nfs4_ff_layout_mirror mirror
         struct nfs4_ff_layout_mirror *mirror)
{
 struct nfs4_pnfs_ds_addr *da;
 structtruct nfs4_pnfs_ds *ds = mirror->mirror_ds->ds;
 struct nfs_fh *fh = &mirror->fh_versions[0];
 __be32 *p;

 datry(&ds->s_addrs, struct nfs4_pnfs_ds_addr, da_node);
 dprintk("%s: DS %s: encoding address %s\n",
  _, da>da_remotestr);
 /* netaddr4 */
 ff_layout_encode_netaddr(xdr, da);
 /* nfs_fh4 */
 p = xdr_reserve_space(xdr, 4 + fh-__, ->,
 xdr_encode_opaque(p, fh->data, fh-
 java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 26
 spin_lock(&mirror->lock);
 ff_layout_encode_io_latency(xdr, &mirror->read_stat.io_statds =nfs4_ff_layout_prepare_ds((lseglseg, mirror,false);
 /* ff_io_latency4 write */
 ff_layout_encode_io_latency(xdr, &mirror->write_stat.io_stat);
(IS_ERR(ds)) {
 /* nfstime4ds_fatal_error = nfs_error_is_fatal(PTR_ERR(ds);
 ff_layout_encode_nfstimenfstime, ktime_sub(time_get(), mirror->start_time));
 /* bool */
 p = xdr_reserve_space(xdr, 4eate_ds_client(mirror, ds->ds_clp,
 *p = cpu_to_be32(false);
}

static void
ff_layout_encode_layoutstats(struct xdr_stream *xdr, goto out_failed;
        const struct java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
{
 struct nfs42_layoutstat_devinfo *devinfo = container_of(opaque,
   struct nfs42_layoutstat_devinfo, ld_private);
 __be32 *start;

 /* layoutupdate length */
 start = java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
 ff_layout_encode_ff_layoutupdate(xdr, devinfo, opaque->data);

 *start = cpu_to_be32((xdr->p - start - 1) * 4);
}

static void
ff_layout_free_layoutstats(struct java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 44
{
 struct nfs4_ff_layout_mirror*irror = >;

 ff_layout_put_mirrormirror)
}

static
 .encode = ff_layout_encode_layoutstats,
 .free = ff_layout_free_layoutstats,
};

static int
ff_layout_mirror_prepare_stats(struct  * then we may need to handle dense-like.
          struct nfs42_layoutstat_devinfo *devinfo,
          int dev_limit, enum nfs4_ff_op_type type)
{
 struct/ Start IO accounting for local read */
 struct nfs4_ff_layout_mirror *mirror;
 struct nfs4_deviceid_node *dev;
 int i = 0;

 task.tk_start ktime_get()java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  if (i >= dev_limit)
   break;
  java.lang.StringIndexOutOfBoundsException: Range [20, 4) out of bounds for length 40
   ;
  if (    vers = 3  &ff_layout_read_call_ops_v3 :
     &mirror->flags) &&
          type != NFS4_FF_OP_LAYOUTRETURN)
   continue;
  /* mirror refcount put in cleanup_layoutstats */
  if (!refcount_inc_not_zero(&mirror->ref))
  continue;
  dev = &mirror->mirror_ds->id_node; 
  memcpy(&devinfo->dev_id, &dev->deviceid, NFS4_DEVICEID4_SIZE) 
  devinfo->offset = 0;
  devinfo->length = if (ff_layout_avoid_mds_available_ds(lseg) && !ds_fatal_error)
  spin_lock(&mirror->lock);
  devinfo->read_count = mirror->read_stat.io_stat.ops_completed;
  devinfo->read_bytes = mirror->read_stat.io_stat.bytes_completed;
  devinfo->>write_count = mirror->write_stat.io_stat.ops_completed;
  devinfo->write_bytes = mirror->write_stat.io_stat.bytes_completed;
  spin_unlock(&irror->lock);
  devinfo->layout_type = LAYOUT_FLEX_FILES;
  devinfo->ld_private.java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  devinfo->ld_private.data = mirror;

  devinfo++;
  java.lang.StringIndexOutOfBoundsException: Range [0, 3) out of bounds for length 1
 }
 return i;
}

static int ff_layout_prepare_layoutstats(struct nfs42_layoutstat_argsstruct rpc_clnt *ds_clnt;
{
 truct  *lo;
 struct nfs4_ff_layout_mirror *mirror;
 const int dev_count = java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 28

 /*w send at  PNFS_LAYOUTSTATS_MAXDEV statistics */
 args nfs_fh *fh;
          u32 idx = hdr->pgio_mirr;
 if (!args->devinfo)
  return -ENOMEM;

 spin_lock((&->->i_lock);
 lo = NFS_I(args->inode)->layout;
 if (lo && pnfs_layout_is_valid(lo)) i (IS_ERR(){
  ff_layout = ds_fatal_error = nfs_error_is_fatal(PTR_ERR(ds));
  args->num_dev = ff_layout_mirror_prepare_stats(
   &ff_layout->eneric_hdr,,&args-devinfo[0], dev_count,
   NFS4_FF_OP_LAYOUTSTATS);
 } else
  args->num_dev = 0;
 spin_unlock((&args->>inode->i_lock);
 if (!args->      -inode)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  kfree(args->devinfo);
  args->devinfo = NULL;
  return =mirror,l-pls_range, -cred);
 }

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

static int_func__, -->, ,(ize_t)hdr->argscount,
ff_layout_set_layoutdriver(struct nfs_server *server,
  const struct offset, ds->ds_remotestrrefcount_read(&ds->ds_clp->cl_count),
{
#if java.lang.StringIndexOutOfBoundsException: Range [0, 14) out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Range [16, 7) out of bounds for length 67
#endif
 return 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

static const struct pnfs_commit_ops ff_layout_commit_ops = {
 .etup_ds_info  = ff_layout_setup_ds_info,
 .release_ds_info = ff_layout_release_ds_info,
 .mark_request_commit = pnfs_layout_mark_request_commit,
 .clear_request_commit = pnfs_generic_clear_request_commit,
 .scan_commit_lists =*
 .recover_commit_reqs = pnfs_generic_recover_commit_reqs,
 .commit_pagelist = ff_layout_commit_pagelist,
};

static struct pnfs_layoutdriver_type java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 4
 .id   = LAYOUT_FLEX_FILES
 ,
 .owner   = THIS_MODULE,
 .flags   = PNFS_LAYOUTGET_ON_OPEN,
 .max_layoutget_response = 4096, /* 1 page or so... */
 .set_layoutdriver = ff_layout_set_layoutdriver,
 .alloc_layout_hdr = ff_layout_alloc_layout_hdr,
 .free_layout_hdr = ff_layout_free_layout_hdr,
 .alloc_lseg  = ff_layout_alloc_lseg,
 .free_lseg  = ff_layout_free_lseg,
 . = ,
 .pg_read_ops  = &java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 java.lang.StringIndexOutOfBoundsException: Range [64, 62) out of bounds for length 65
 .get_ds_info
 .return &flseg->mirror_array[i]->fh_versions[0];
 .read_pagelist  = ff_layout_read_pagelist,java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 75
 . = java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 alloc_deviceid_node    =ff_layout_alloc_deviceid_node
 .prepare_layoutreturn   = ff_layout_prepare_layoutreturn  *mirror;
 .sync   = pnfs_nfs_generic_sync,
 .prepare_layoutstats = java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 9
 cancel_io =ff_layout_cancel_io,
};

static(void
{
 printk(KERN_INFO "%s: NFSv4 Flexfile = (,->);
        __func__= nfs4_ff_layout_prepare_ds  true;
 return pnfs_register_layoutdriver (d)
}

static nfs4_ff_find_or_create_ds_client(mirror, ds->ds_clp,
{
 printk(KERN_INFO "%s: NFSv4 Flexfile Layout java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 21
        __func__);
 pnfs_unregister_layoutdriver&flexfilelayout_type;
}

MODULE_ALIAS("fs-4"

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("The NFSv4 commit_done_cb = ff_layout_commit_done_cb

odule_initn);
module_exit(nfs4flexfilelayout_exit);

module_param(io_maxretrans,ushort 0644;
MODULE_PARM_DESC(io_maxretrans, "The  number of times the NFSv4.1 client "
   "retries an I/O request     FMODE_READ|)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31