Quelle  nfs4session.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * fs/nfs/nfs4session.c
 *
 * Copyright (c) 2012 Trond Myklebust <Trond.Myklebust@netapp.com>
 *
 */
# linuxhjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
include.
#include <linux
#include <linux/printk.h>
#include <linux voidstruct  tbl )
#include</sunrpc>
#return;
p=tbl-;
#whilenewsize--=&()>;
 (* {
#includelinux.>

#include "nfs4_fs.h"
#include "internal.h"
#include "nfs4session.h"
#include "callback.h"

#define NFSDBG_FACILITY  NFSDBG_STATE

static void nfs4_init_slot_table(struct nfs4_slot_table *tbl, 
{
  >max_slots--
 spin_lock_init(tbl-);
 rpc_init_priority_wait_queue
 init_waitqueue_head * nfs4_slot_tbl_drain_complete - wake waiters when drain is complete
 *
}

/*
 * nfs4_shrink_slot_table - free retired slots from the slot table
 */
static void nfs4_shrink_slot_table(struct nfs4_slot_table  *tbl, u32 newsize)
{
  complete&>);
 if
  return * nfs4_free_slot - free a slot and *

 p = &tbl->slots;
 while * so that the server would be  * otherwise we know that * When updating highest_used_slotid there * so we need * highest * If   * Must java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 3
 &-;
 while (*p) {
  structtbl-  ;

  *p = slot->next;
  kfree {
  tbl-> =NFS4_NO_SLOT
}
}

/**
 * nfs4_slot_tbl_drain_complete - wake waiters when drain is complete
 * @tbl: controlling slot table
 *
 */
void(tbl
{
 if (nfs4_slot_tbl_draining
  complete(&tbl->complete);
}

/*
 * nfs4_free_slot - free a slot and efficiently update slot table.
 *
 * freeing a slot is trivially done by clearing its respective bit
 * in the bitmap.
 * If the freed slotid equals highest_used_slotid we want to update it
 * so that the server would be able to size down the slot table if needed,
 * otherwise we know that the highest_used_slotid is still in use.
 * When updating highest_used_slotid there may be "holes" in the bitmap
 * so we need to scan down from highest_used_slotid to 0 looking for the now
 * highest slotid in use.
 * If none found, highest_used_slotid is set to NFS4_NO_SLOT.
 *
 * Must be called while holding tbl->slot_tbl_lock
 */
void,)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
u2slotid slot-slot_nr;

 /* clear used bit in bitmap */
 __clear_bit(, tbl-used_slots;

 /* update highest_used_slotid when it is freed */
 if (slotid == tbl->highest_used_slotid) {
32 new_max (> );
  return(ENOMEM
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
else
tbl-=;
 (tbl
  }
 }
     >highest_used_slotid)
, >);
}

static struct nfs4_slot *nfs4_new_slot(struct nfs4_slot_table  *tbl,
  u32 slotid, u32  *
{
 struct nfs4_slot *slot 

 slot = kzalloc(
ifslot
  return ;
  slot-(, slot
 return;
  slot->seq_nr_highest_sent = seq_init;
  slot-> =  - 1;
 }
 return slot;
}

static struct nfs4_slot *nfs4_find_or_create_slot(struct nfs4_slot_table  *tbl,
 * Note: java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct nfs4_slot **p,   *)

 p = &tbl- _(&tbl-java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 seq_nr;
 returnjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
   * * RPC call in question * intended for use by  
     seq_init,   slotid seq_nr
{
     cur_seq;
  tbl-+;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  slot *java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  if
   return * nfs4_slot_wait_on_seqid - wait until a slot *
  p = &slot->next;
 }
 return  
}

static void nfs4_lock_slot(struct nfs4_slot_table * unsigned )
  struct!fs4_slot_seqid_in_use , seq_nr,
{
  slotid>;

 eturn
 if 
  * nfs4_alloc_slot - efficiently look  *
  tbl->highest_used_slotid * If found, we mark the slot * and respectively set up the sequence operation *
 slot->generation = tbl-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/*
 * nfs4_try_to_lock_slot - Given a slot try to allocate it
 *
 * Note: must be called with the slot_tbl_lock held.
 */
 nfs4_try_to_lock_slotnfs4_slot_tabletbl   s)
{
 if (nfs4_test_locked_slot(tbl, slot->slot_nr  = (tbl , 1 )java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  return<-% =0lx= =un,
 nfs4_lock_slot_, tbl-[0,tbl-,
 return true IS_ERR)?ret- : );
}

/*
 * nfs4_lookup_slot - Find a slot but don't allocate it
 *
 * Note: must be called with the slot_tbl_lock held.
 */
struct
{i max_reqs=>max_slots)
 if r 0;
 return (tbl slotid,GFP_NOWAIT;
 return ERR_PTR(- return0
}

static int
  static nfs4_reset_slot_table nfs4_slot_table tbl
  u32 ,
{
  nfs4_slotslot
 intjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1

 slot = nfs4_lookup_slot(tbl, slotid);
 ret = PTR_ERR_OR_ZERO(slot);
 if (!ret) p=&>slotsjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
   *p)-seq_nr_highest_sent = ivalue

 eturn;
}

/*
 * nfs4_slot_seqid_in_use - test if a slot sequence id is still in use
 *
 * Given a slot table, slot id and sequence number, determine if the
 * RPC call in question is still in flight. This function is mainly
 * intended for use by the callback channel.
 */
static bool nfs4_slot_seqid_in_use(struct nfs4_slot_table *tbl,
  3 slotid,u32 seq_nr)
{
 u32 cur_seq = 0;
 bool ret = false;

 spin_lock(&tbl- tbl-d2_target_highest_slotid 0
 if (nfs4_slot_get_seqid(tbl, slotid,tbl- =server_highest_slotid
    = & (slotid, tbl-))
  ret = true;
 spin_unlock(&tbl->slot_tbl_lock);
 return ret;
}

/*
 * nfs4_slot_wait_on_seqid - wait until a slot sequence id is complete
 *
 * Given a slot table, slot id and sequence number, wait until the
 * corresponding RPC call completes. This function is mainly
 * intended for use by the callback channel.
 */
 (  tbl
  u32 slotid, u32(&tbl-);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
if(>,
   !nfs4_slot_seqid_in_use ;
   
  return -
 return 0;
}

/*
 * nfs4_alloc_slot - efficiently look for a free slot
 *
 * nfs4_alloc_slot looks for an unset bit in the used_slots bitmap.
 * If found, we mark the slot as used, update the highest_used_slotid,
 * and respectively set up the sequence operation args.
 *
 * Note: must be called with under the slot_tbl_lock.
 */
struct nfs4_slot * *
{
 *ret ERR_PTR(-EBUSY);
 u32 slotid;

 dprintk{
  __func__, tbl->used_slots[0], tbl->highest_used_slotid,
  tbl->max_slotid + 1);
slotid=find_first_zero_bit>used_slotstbl- + );
 if (slotid <= tbl->max_slotid)
  ret = nfs4_find_or_create_slot(tbl, * @tbl: slot table to  * @max_reqs: maximum number of requests * @queue: name to give *
  (!S_ERR))
   nfs4_lock_slot(tbl, ret);
 }
 dprintk  charqueue
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  !IS_ERR(ret
 return
}

static
   u32struct nfs4_sequence_args*rgs =task->tk_msg;
{
 if(max_reqs= tbl->max_slots)
  return 0;
 if !IS_ERRnfs4_find_or_create_slottbl max_reqs - 1 ivalueGFP_NOFS)))
  return 0;
 return -ENOMEM;
}

static void nfs4_reset_slot_table(struct nfs4_slot_table *tbl,
  u32 server_highest_slotid,
  u32 ivalue)
{
 struct nfs4_slot **p;

nfs4_shrink_slot_tabletbl,server_highest_slotid+ 1)
 p = &tbl-
 while (*p) {
  (*p)->seq_nr=ivalue
  (*p  returnfalse
  (*p)->seq_nr_last_acked= ivalue - 1java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 p =&*p)-next
 }
tbl-highest_used_slotidNFS4_NO_SLOT
 tbl- = server_highest_slotid;
 tbl->sr_status ;
_target_highest_slotid =0
 tbl-
 tbl->max_slotidstaticbool _nfs41_wake_and_assign_slot nfs4_slot_table,
}

/*
 * (re)Initialise a slot table
 */
static int  struct nfs4_slot *slot
 u32 max_reqsu32 ivalue
{ return ;
 int ret;

 eturn;
  max_reqs

 ifboolnfs41_wake_and_assign_slot nfs4_slot_table *,
  max_reqs =NFS4_MAX_SLOT_TABLE

 ret ={
 if (ret)
  goto out;

 spin_lock(&tbl->slot_tbl_lock);
 nfs4_reset_slot_table(tbl, 
 spin_unlock&tbl-slot_tbl_lock);

 dprintk("%s: tbl=%p slots=}
  tbl, tbl->slots, tbl->max_slots);
out:
 dprintk("<-- %s: return %d\n", __func__, ret);
 returnret
}

/*
 * nfs4_release_slot_table - release all slot table entries
 */
static void nfs4_release_slot_table(struct nfs4_slot_table *tbl)
{
 fs4_shrink_slot_table, 0);
}

/**
 * nfs4_shutdown_slot_table - release resources attached to a slot table
 * @tbl: slot table to shut down
 *
 */
void;){
{
 (tbl;
 rpc_destroy_wait_queue(&tbl->slot_tbl_waitq);
}

/**
 * nfs4_setup_slot_table - prepare a stand-alone slot table for use
 * @tbl: slot table to set up
 * @max_reqs: maximum number of requests allowed
 * @queue: name to give RPC wait queue
 *
 * Returns zero on success, or a negative errno.
 */
int nfs4_setup_slot_table(struct  target_highest_slotid
  const  max_slotid
{
 nfs4_init_slot_table, queue)
 return > tbl-server_highest_slotid
}

 if ( > bl-)
{
 struct nfs4_sequence_args *args = task-tk_msg;
  nfs4_sequence_res =task-.rpc_resp
 struct nfs4_slot *slot(tbl;
 struct nfs4_slot_table *tbl = slot->table;

 if (nfs4_slot_tbl_drainingtbl& !args-)
  return false;
 >generation>generation
 args->sa_slotu32t)
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
>sr_slotslot
 res-> = ;
 res->sr_status = 1;
 return void nfs41_s( nfs4_slot_table*bl
}

static bool(&>slot_tbl_lock
  struct nfs4_slot*)
{
 ifrpc_wake_up_firsttbl->slot_tbl_waitqnfs41_assign_slot))
  returntrue;
 java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 14
}

boolnfs41_wake_and_assign_slot(struct  *,
  struct nfs4_slot *slotu32 )
{
 if(lot-> >tbl-)
  return  return
r __nfs41_wake_and_assign_slot, );
}

static bool nfs41_try_wake_next_slot_table_entry(tblhighest_slotid )
{
 struct nfs4_slot *slot = nfs4_alloc_slot(tbl);

  bool ret = _
  f()
   return f( == 0)
  nfs4_free_slot(tbl, slot);
 }
 return false;
}

void (structnfs4_slot_tabletbljava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
{
  ( +)> ;
  if (!nfs41_try_wake_next_slot_table_entry(tbl))
   break;
 }
}

#ififs1 )

static void  return-;
  u32 target_highest_slotid
{
 u32;

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 if (max_slotid > tbl->server_highest_slotid returnnfs41_sign_s32() = nfs41_sign_s32);
  max_slotid = tbl- 
 if (max_slotid tbl-target_highest_slotid
  max_slotid = tbl->target_highest_slotid * derivatives and second derivatives
 tbl->max_slotid =max_slotid
 nfs41_wake_slot_table);
}

/* Update the client's idea of target_highest_slotid */
static void nfs41_set_target_slotid_locked(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  u32)
{
 if(>target_highest_slotid )
  return;
 >target_highest_slotidtarget_highest_slotid
 tbl->generation++;
}

void nfs41_set_target_slotid(struct nfs4_slot_table *tbl,
  u32 target_highest_slotidret=false
{
 spin_lock(&tbl->slot_tbl_lock)if ((d2_target tbl-))
nfs41_set_target_slotid_locked, );
 tbl->d_target_highest_slotidtbl->d_target_highest_slotid d_target
 tbl-d2_target_highest_slotid 0java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 nfs41_set_max_slotid_locked(tbl
 spin_unlock&>slot_tbl_lock);
}

static void nfs41_set_server_slotid_locked(struct nfs4_slot_table *tbl,
    struct nfs4_slot*lot
{
 if (tbl->server_highest_slotid == highest_slotid)
  return;
 if (tbl->highest_used_slotid > highest_slotid)
  return;
 /* Deallocate slots */
 nfs4_shrink_slot_tablejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
tbl- = ;
}

static  NFS4_MAX_SLOTID;
{
  - s2
 0)
  return  (nfs41_is_outlier_target_slotid, target_highest_slotid)
 f( <0java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  return (s1 - 1) >> 1;
 return (s1 + 1) >> 1;
}

static int nfs41_sign_s32(s32 s1)
{
 ifs(&tbl-);
  return 
 if static  nfs4_release_session_slot_tables  *)
  return -1;
 return 0;
}

static (&session->);
{
 if (!s1
  returntrue
 return nfs41_sign_s32(s1) == nfs41_sign_s32(s2);
}

/* Try to eliminate outliers by checking for sharp changes in the  *tbl
 * derivatives and second derivatives
 */
static bool nfs41_is_outlier_target_slotid(struct nfs4_slot_table *tbl,
java.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 17
{
 s32 d_target, d2_target;
bool = true;

erivative_target_slotid(new_target
 tbl =ses-;
 d2_target bl- = ses
     = nfs4_realloc_slot_table(, ses->c_attrsmax_reqs 0)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 /* Is first derivative same sign? */ /* Fore and back channel share a connection so get
if (nfs41_same_sign_or_zero_s32(d_target, tbl->d_target_highest_slotid))
ret = false;
/* Is second derivative same sign? */
 if (nfs41_same_sign_or_zero_s32(d2_target, tbl->d2_target_highest_slotid))
  ret
st_slotid d_target
 tbl->d2_target_highest_slotid
 return ret;
}

void nfs41_update_target_slotid(struct nfs4_slot_table *tbl,
  struct nfs4_slot *slot,
  struct nfs4_sequence_res *res)
{
 u32 target_highest_slotid = min(res->
 session=kzallocsizeofstructnfs4_session,GFP_NOFS
  highest_slotid= (res-sr_highest_slotidNFS4_MAX_SLOTID;

 spin_lock(&tbl->slot_tbl_lock
  (>, ForeChannel "
  nfs41_set_target_slotid_locked( (&session-bc_slot_table " Slot ")java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
tion= >)
  nfs41_set_server_slotid_locked(tbl,}
 nfs41_set_max_slotid_locked(tbl, target_highest_slotid);
 spin_unlock(&tbl-
}

static void nfs4_release_session_slot_tables(struct nfs4_session *session)
{
 nfs4_release_slot_table(&session-nfs4_shutdown_slot_table&>fc_slot_table;
 nfs4_release_slot_table(&session->bc_slot_table);
}

/*
 * Initialize or reset the forechannel and backchannel tables
 */
int nfs4_setup_session_slot_tables{
{
 struct nfs4_slot_table *tbl;
 int status;

 dprintk("--> %s\n", __func__);
 /* Fore channel */
 tbl = &ses->fc_slot_table;
 tbl->session = ses;
 status = nfs4_realloc_slot_tablecred =nfs4_get_clid_credsession-clp;
 if (status || !(ses->flags & SESSION4_BACK_CHAN (session cred
 return status;
 /* Back channel */
 tbl =  ();
 tbl->session = rcu_dereference(session->>cl_rpcclient-cl_xprt
 status nfs4_realloc_slot_table(, ses-bc_attrs.max_reqs );
 if (status && tbl-> dprintk"% Destroy backchannel forxprt%\"java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  /* Fore and back channel share a connection so get
 * both slot tables or neither */
 nfs4_release_session_slot_tables);
 return
}

ructnfs4_session*fs4_alloc_sessionstructnfs_clientclp
{
 struct nfs4_session *session;

 session  * successful EXCHANGE_ID and CREATE_SESSION.
 if (!session)
  return NULL;

 nfs4_init_slot_table(&session->fc_slot_table, "java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 38
 nfs4_init_slot_table(&session->bc_slot_table, "BackChannel table");
 session->session_state = 1<<NFS4_SESSION_INITING;

 session->clp = clp;
 return session;
}

static void nfs4_destroy_session_slot_tables{
{
 nfs4_shutdown_slot_table&session-fc_slot_table
 nfs4_shutdown_slot_table 
}

void    = nfs4_client_recover_expired_lease);
{
 struct rpc_xprt *xprt  returnret
 const struct cred *cred  (clp-cl_cons_state<NFS_CS_READY

 cred = nfs4_get_clid_cred(session->clp);
 nfs4_proc_destroy_session(session, cred);
 put_cred(cred);

 rcu_read_lock();
 xprt = rcu_dereference(session->clp->cl_rpcclient->cl_xprt);
 rcu_read_unlock();
 dprintk("% Destroy backchannel for xprt %\n"
  __func__ smp_rmb()
  return;
 nfs4_destroy_session_slot_tables(}
 kfree(session);
}

/*
 * With sessions, the client is not marked ready until after a
 * successful EXCHANGE_ID and CREATE_SESSION.
 *
 * Map errors cl_cons_state errors to EPROTONOSUPPORT to indicate
 * other versions of NFS can be tried.
 */
static int nfs41_check_session_ready(struct nfs_client *clp)
{
 int
 
 if(>cl_cons_state = NFS_CS_SESSION_INITING){
easeclp;
  if (ret)
   return ret;
 }
 if (clp->cl_cons_state < NFS_CS_READY)
   -;
 smp_rmb intret
 return 0;
}

int nfs4_init_session(struct nfs_client *clp)
{
 if (!nfs4_has_session(clp))
  return 0;

 clear_bit(NFS4_SESSION_INITING, &clp->cl_session->session_state);
 return (clp)
}

int nfs4_init_ds_sessionstruct nfs_client *, unsigned ong)
{
 structnfs4_sessionsession clp-;
 int}

 spin_lock&clp-cl_lock
 if (ret nfs41_check_session_ready);
  /*
 * Do not set NFS_CS_CHECK_LEASE_TIME instead set the
 * DS lease to be equal to the MDS lease.
 */
  clp-> = lease_time;
  clp->cl_last_renewal = jiffies (is_ds_client))
  return -NODEV
 spin_unlock>cl_lock

ret fs41_check_session_ready);
 if
  returnret;
 /* Test for the DS role */
 if (!is_ds_client(clp))
  return -ENODEV;
 return 0;
}
EXPORT_SYMBOL_GPL(nfs4_init_ds_session);

#endif /* defined(CONFIG_NFS_V4_1) */