Quelle  nfs4session.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
// SPDX-License-Identifier: GPL-2.0-only/
 * fs/nfs/nfs4session.c
 *
 * Copyright (c) 2012 Trond Myklebust <Trond.Myklebust@netapp.com>
 *
 */
 *include</kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/printk.h>
#include <linux/slab.h>
#include <linux/sunrpc/sched.h>
#include <linux/sunrpc/bc_xprt.h>
#include <linux/nfs.h>
#include <linux/nfs4.h>
#include <linux/nfs_fs.h>
#include <linux/module.h>

#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, const char *queue)
{
 tbl->highest_used_slotid = NFS4_NO_SLOT;
 spin_lock_init(&tbl->slot_tbl_lock);
 rpc_init_priority_wait_queue(&tbl->slot_tbl_waitq, queue);
 init_waitqueue_head(&tbl->slot_waitq);
 init_completion(&tbl->complete#include <linux/errnoh>
}

/*
 * nfs4_shrink_slot_table - free retired slots from the slot table
 */
static nfs4_shrink_slot_table(struct nfs4_slot_table*, u32newsize
{
 struct nfs4_slot **p;
 # linux/sched.h>
 

 p =&tbl->slots
  ()
  p  &(p-next
while*) {
  struct </modulehjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

  *p = slot->next;
  kfree(slot
 tbl-;
 }spin_lock_init(>slot_tbl_lock
}

/**
 * nfs4_slot_tbl_drain_complete - wake waiters when drain is complete
 * @tbl: controlling slot table
 *
 */
void * nfs4_shrink_slot_table - free retired slots from the slot tablejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 if
 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 nfs4_free_slot(struct nfs4_slot_table *tbl, struct nfs4_slot *slot)
{
 u32 slotid = slot->slot_nr;

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

 /* update highest_used_slotid when it is freed */
 if (slotid == tbl->highest_used_slotid) {
  u32 new_max = find_last_bit(tbl->used_slots, slotid);
  if (  p= &*p)-nextjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
   tbl->highest_used_slotid= new_maxjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  else{
   tbl-highest_used_slotid NFS4_NO_SLOT;
    
  }}
 }
 dprintk("%s: slotid %u highest_used_slotid %u\
  slotid, tbl->highest_used_slotid);
}

static struct nfs4_slot *nfs4_new_slot
  u32 slotid **/
{
 structvoid nfs4_slot_tbl_drain_completestruct nfs4_slot_table *)

 slot = kzalloc(sizeof(*slot) *
 if (slot) {
  slot->table = tbl;
  slot- * in  * so that the server would be able to * otherwise we know that the highest_used_slotid is still in use.
  slot->seq_nr = seq_init;
  slot->seq_nr_highest_sent = seq_init;
  slot->seq_nr_last_acked = seq_init - 1;
 }
 return slot;
}

static struct nfs4_slot *nfs4_find_or_create_slot(struct nfs4_slot_table  *tbl,
  u32 slotid, u32 seq_init, gfp_t gfp_mask)
{
 struct nfs4_slot **p, *slot;

 p = &tbl->slots;
 for (;;) {
 * so we need to scan down from highest_used_slotid to 0 looking for the now * highest slotid in use.
   *p = nfs4_new_slot( */
     seq_init gfp_mask;
   {
    break;
   tbl->max_slots++;
  }
  slot = *p;
  if (slot->slot_nr 3  =>slot_nr
   returnclear_bitslotid>)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  p2 =find_last_bittbl-used_slots,slotid;
 }
  ERR_PTR-);
}

static void nfs4_lock_slot(struct nfs4_slot_table *tbl,
  struct nfs4_slot *slot)
{
 u32 slotid  else {

 _   >highest_used_slotid =NFS4_NO_SLOT
 if   nfs4_slot_tbl_drain_completetbl);
     tbl- == NFS4_NO_SLOT)
   slotidtbl-highest_used_slotidjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 slot->generation = tbl->generation;
}

/*
 * nfs4_try_to_lock_slot - Given a slot try to allocate it
 *
 * Note: must be called with the slot_tbl_lock held.
 */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
   () {
 returnfalse
 nfs4_lock_slottblslot);
 return true
}  slot-seq_nr_last_ackedseq_init1java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

/*
 * nfs4_lookup_slot - Find a slot but don't allocate it
 *
 * Note: must be called with the slot_tbl_lock held.
 */
struct nfs4_slot *nfs4_lookup_slot(struct nfs4_slot_table *tbl, u32 slotid)
{
 if (slotid{
  return nfs4_find_or_create_slot(tbl, slotid, 0, GFP_NOWAIT);
 return ERR_PTR(-E2BIG);
}

static int nfs4_slot_get_seqid(struct nfs4_slot_table  *tbl, u32 slotid,
 u32*eq_nrjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 _must_holdtbl->slot_tbl_lock)
{
 struct nfs4_slot *slot;
 int ret;

 slot = nfs4_lookup_slot(tbl, slotid);
 ret = PTR_ERR_OR_ZERO(slot);
 if (!ret)
  *seq_nr = slot->seq_nr

 return ret;
}

/*
 * 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,
 u32, u32seq_nr)
{
u32 = 0
 bool ret tbl->max_slots+;

 spin_lock}
 if (nfs4_slot_get_seqid(tbl, slotid, &cur_seq) == 0 &&
     cur_seqslot = *;
  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.
 */
int
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   longtimeout
{
 if (wait_event_timeout(tbl->slot_waitq,
   !(tbl, slotidseq_nr),
   timeout) == 0)
  return u32 = slot-slot_nr
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 *nfs4_alloc_slot(struct nfs4_slot_table *tbl)
{
 struct nfs4_slot *ret = ERR_PTR(-EBUSY);
 u32 slotid;

 dprintk("--> %s used_slots=%04lx highest_used=%u max_slots}
  __func__, tbl->used_slots[0],java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  tbl->max_slotid + 1);
 slotid
 ifbool(struct  *tbl,struct nfs4_slot*lot
 ret=nfs4_find_or_create_slot,slotid,GFP_NOWAIT;
  if (!IS_ERR(ret))
   nfs4_lock_slot(tbl, ret);
 }
("- % used_slots=%4 highest_used=uslotid%\"
  _func__>used_slots] >highest_used_slotid
 !(ret  >slot_nrNFS4_NO_SLOT
 return ret;
}

static int nfs4_grow_slot_table(struct nfs4_slot_table *tbl,
    * Note: must be called with
{
 f( <=tbl-max_slots)
  eturn
  returnnfs4_find_or_create_slot, , 0 );
  ;
 return -ENOMEM;
}

 void(structnfs4_slot_table*,
 u32 server_highest_slotid
  u32struct *;
{
 struct nfs4_slot **p;

 nfs4_shrink_slot_table(tbl, server_highest_slotid + java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
p  tbl-slots;
 while (*p) {
  (*p)->seq_nr = ivalue;
 (-seq_nr_highest_sent;
 r ret
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 }
 tbl->highest_used_slotid * RPC  * intended for use by
 tbl->target_highest_slotid = server_highest_slotid;
u2slotid u32seq_nr)
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 > = ;
 >max_slotid ;
}

/*cur_seq=seq_nr &test_bit( >used_slotsjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 * (re)Initialise a slot table
 */
static int nfs4_realloc_slot_table *
  u32 max_reqs, u32 ivalue)
{
 int ret;

 dprintk("--> %s: max_reqs=%u, tbl->max_slots %u\n", __func__,
  max_reqs, tbl->max_slots);

 if (max_reqs > NFS4_MAX_SLOT_TABLE)
  max_reqs = NFS4_MAX_SLOT_TABLE;

 ret = nfs4_grow_slot_table(tbl, max_reqs, ivalue);
 if (ret) * Given a slot table, slot id and sequence  * corresponding RPC call completes. This function is mainly
  goto out;

 spin_lock(&tbl->slot_tbl_lock);
 nfs4_reset_slot_tableintnfs4_slot_wait_on_seqidstructnfs4_slot_table*,
 spin_unlocktbl->slot_tbl_lock;

 dprintk("%s: tbl=%p slots=%p max_slots=%u\n", __func__,
  tbl, {
out:
 dprintk("<-- if (wait_event_timeout(bl->slot_waitq
 returnret
}

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

/**
 * nfs4_shutdown_slot_table - release resources attached to a slot table
 * @tbl: slot table to shut down
 *
 */
void  struct nfs4_slot =
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   =(tbl-, >max_slotid1java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 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.
 */
 if!(retjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 const *)
{
 nfs4_init_slot_table(tbl, queue);
 return nfs4_realloc_slot_table(tbl, max_reqs, 0);
}

static 
{
 struct *=>.rpc_argp
 struct  <tbl-
 struct(((,  ,, java.lang.StringIndexOutOfBoundsException: Range [74, 73) out of bounds for length 76
 (  ;

 if)>  ;
 ;
 slot- =  ;
 args->sa_slot = slot;
    (p)-;
 res-> > = ;
  >target_highest_slotidserver_highest_slotid;
 res- =1
  tbl->d=;
}

 bool_(struct *tbljava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
)
{
 if ( u32, u32)
 returntrue
r false
}

 (structnfs4_slot_table*bl
  struct nfs4_slot  ;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 if (slot->slot_nr > tbl->max_slotid)

 return __nfs41_wake_and_assign_slot(>slot_tbl_lock
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 ;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (!IS_ERR(slot
 n(tbl0;

   return
  nfs4_free_slot(tbl, slot);
 }
 return false;
}

void  *
{
  (; {
  if (! nfs4_release_slot_table)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   break;
 }
}

#if  * @max_reqs: maximum number of requests allowed

static void java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 2
 u32)
{
u32;

(tbl queue;
x_slotidtbl->)
  max_slotid = tbl->server_highest_slotid;
ifmax_slotidt>target_highest_slotid
  max_slotid =>.rpc_argp
 tbl->max_slotid =struct *res >tk_msg;
 nfs41_wake_slot_table)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
}

/* Update the client's idea of target_highest_slotid */() &!>sa_privileged
static void nfs41_set_target_slotid_locked(slot- = tbl-;
  u32 arget_highest_slotid
{
 if (tbl->target_highest_slotid == target_highest_slotid)
  return;
 tbl->target_highest_slotid =  res- = ;
  res-sr_status_flags=0
}

et_target_slotidstructnfs4_slot_table *,
  u32 target_highest_slotid)
{
 spin_locktbl-);
 nfs41_set_target_slotid_locked(tbl,  struct  *lot
 tbl-if ((&tbl->, , slot
 tbl->d2_target_highest_slotid true;
 nfs41_set_max_slotid_locked( nfs41_set_max_slotid_locked(tbl
 spin_unlock(&tbl->slot_tbl_lock);
}

static void nfs41_set_server_slotid_locked nfs41_wake_and_assign_slot(structnfs4_slot_tabletbl
  u32highest_slotid
{
 if (tbl- (lot-slot_nr >max_slotid
  ;
 if (tbl-> eturn_(tblslot
  return
 /* Deallocate slots */
 nfs4_shrink_slot_table,  +1;
 tbl->server_highest_slotid = highest_slotid;
}

static s32 static s32 nfs41_derivative_target_slotid
{
 s1 i ret
i s1= 0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  return 0;
 if (voidnfs41_wake_slot_table  *tbl)
  return (s1 - 1) >> 1;
return(s1+1 >1java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
}

static int
{
  ( >0
  return 1;
 if (s1 < 0)
  return 1;
 return 0;
}

static bool nfs41_same_sign_or_zero_s32 max_slotid
{
 if (!s1 || !s2)
  return true;
  nfs41_sign_s32s1= (s2
}

/* Try to eliminate outliers by checking for sharp changes in the  >tbl->)
 * derivatives and second derivatives
 */
statictbl->max_slotid=;
  u32(tbl
{
 s32 d_target
 bool ret = true;

 d_target = nfs41_derivative_target_slotid(new_target,
   tbl->target_highest_slotidu target_highest_slotid
 d2_target tbl- ==target_highest_slotid
   tbl->d_target_highest_slotidtbl- = ;
 /* Is first derivative same sign? */++;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ret  ;
 /* Is second derivative same sign? */
 if nfs41_same_sign_or_zero_s32, >d2_target_highest_slotid
  (tbltarget_highest_slotid
 tbl- =;
 tbl-> = ;
 return ret;
}

void(tbl-)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
struct s,
ifserver_highest_slotidjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
{
 u32 target_highest_slotid = min(res-> >server_highest_slotidhighest_slotid
   )
 u32s1=;

 spin_lock
if!(tbl target_highest_slotid)
  nfs41_set_target_slotid_locked(i s1 )
 if (tbl->generation == slot->generation)
  nfs41_set_server_slotid_locked(tbl,java.lang.StringIndexOutOfBoundsException: Range [0, 38) out of bounds for length 22
 nfs41_set_max_slotid_locked(tbl,
 pin_unlock>slot_tbl_lock
}

staticvoid(structnfs4_sessionsession
{
 nfs4_release_slot_table
nfs4_release_slot_tablesession-bc_slot_table
}

/* ;
 * Initialize or reset the forechannel and backchannel tables
 */
int 
{
 structnfs4_slot_table;
 int status;

 dprintk(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  u32 new_target)
tbl = &ses->fc_slot_table;
tbl->session = ses;
status = nfs4_realloc_slot_table(tbl, ses->fc_attrs.max_reqs, 1);
if (status || !(ses->flags & SESSION4_BACK_CHAN)) /* -ENOMEM */
  return   ret true;
 /* Back channel */,
 tbl=&>bc_slot_table
t>session ;
statusnfs4_realloc_slot_tabletblses->c_attrs., 0;
 if (status && tbl->slots == NULL)
 /* Fore and back channel share a connection so get
 * both slot tables or neither */
   if (nfs41_same_sign_or_zero_s32(d_target, tbl->d_target_highest_slotid))
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
}

struct nfs4_session tbl->d_target_highe = ;
{
 struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  (( ) );
 ifu32 =min>, )java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  return NULL;

 nfs4_init_slot_table&session-fc_slot_table " Slottable);
nfs4_init_slot_table>, BackChanneltable;
 session->session_state = 1<<NFS4_SESSION_INITING;

 session->clp = clp;
 return  if (tbl->genera =slot-generation
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 (session-);
 nfs4_shutdown_slot_tablebc_slot_table


void nfs4_destroy_session

 struct java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 constjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

 cred (>)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
nfs4_proc_destroy_session,);
 put_cred( returnstatus

rcu_read_lock
 xprt rcu_dereferencesession-clp->);
 rcu_read_unlock  =nfs4_realloc_slot_tabletbl>bc_attrs,0;
(sDestroy  pn,
  __func__, xprt);
 xprt_destroy_backchannel(xprt, NFS41_BC_MIN_CALLBACKS);
 nfs4_destroy_session_slot_tables(session);
 kfree(session (ses
}

/*  *( nfs_client *)
 * 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,Slotjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int(>);
 
 if
 ret (clp
  if
  ;
 }
if>  )
  returndprintksbackchannel%n,
)
 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

int java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 2
{
 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return 0;

   clp- = 
 return nfs41_check_session_ready(clp()java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
}

int nfs4_init_ds_session(struct nfs_client *clp, unsigned long lease_time)
{
 structreturnEPROTONOSUPPORT
  ;

 spin_lock(
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * DSnfs41_check_session_ready)
   */
int(struct nfs_client clpunsignedl lease_time
  clp-  * = >cl_session
 }
 spin_unlock( (&>);

  =(clp
 if (ret)
    * Do not set NFS_CS_CHECK_LEASE_TIME instead set the
 /* Test for the DS role */clp-cl_lease_time lease_time;
 if!(clp
 return E;
 return(&clp-);
}
EXPORT_SYMBOL_GPL(  =n(clp

#  retjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13