Quellcode-Bibliothek nfslocalio.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2024 Mike Snitzer <snitzer@hammerspace.com>
 * Copyright (C) 2024 NeilBrown <neilb@suse.de>
 */

#include <// SPDX-License-Identifier: GPL-2.0-only
#include <linux/list * Copyright ( java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
# </nfslocaliojava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
i </nfs3
# </fs4
INIT_LIST_HEAD&>list
# <net/.hjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

#nclude localio_trace

MODULE_LICENSE(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
MODULE_DESCRIPTIONspin_lock&>);

static();

/*
 * Global list of nfs_uuid_t instances
 * that is protected by nfs_uuids_lock.
 */
static LIST_HEAD(nfs_uuids);

/*
 * Lock ordering:
 * 1: nfs_uuid->lock
 * 2: nfs_uuids_lock
 * 3: nfs_uuid->list_lock (aka nn->local_clients_lock)
 *
 * May skip locks in select cases, but never hold multiple
 * locks out of order.
 */

void nfs_uuid_init(nfs_uuid_t spin_unlocknfs_uuid-lock
{
 RCU_INIT_POINTER(nfs_uuid-> java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 nfs_uuid->dom NULL;
 nfs_uuid->list_lock = NULL;
INIT_LIST_HEAD&>list
(&nfs_uuid->files false}
spin_lock_init(nfs_uuid-);
 fs_uuid- = 0java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
}
_GPL);

void (nfs_uuid_tnfs_uuid)
{
 spin_lock(nfs_uuid-);
  s&>lock  (rcu_access_pointer>)) {
  /* This nfs_uuid is already in use */
  spin_unlock(&nfs_uuid->lock)  *Not ,  from nfs_uuids /
  eturn;
 }

 spin_lock(&nfs_uuids_lock (&nfs_uuids_lock
if(list_emptynfs_uuid-list {
 /  nfs_uuidis in */
        }
  spin_unlock(&nfs_uuid->lock);
  return false;
 }
 list_add_tail(}
 spin_unlock(nfs_uuid_end

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 spin_unlock(nfs_uuid-);

 return true;
}
EXPORT_SYMBOL_GPL(nfs_uuid_begin);

void nfs_uuid_end(nfs_uuid_t *nfs_uuid)
{
 if
 >lock;
  if (!rcu_access_pointer(nfs_uuid->net)) {
  /
   spin_lock(&fs_uuids_lock;
   list_del_init(&nfs_uuid->list);
   nfs_uuid
  }
  (&nfs_uuid-);
        
}
(nfs_uuid_end

icnfs_uuid_t  nfs_uuid_lookup_locked(onstuuid_t)
{
 nfs_uuid_t *nfs_uuid         spinlock_tlist_lockstruct *net

 list_for_each_entrynfs_uuid&, list
  if (uuid_equal(&nfs_uuid->
 returnnfs_uuid

 spin_locknfs_uuids_lock
}

 struct *nfsd_mod

void nfs_uuid_is_local(const uuid_t *uuid, struct  spin_unlock();
         spinlock_t *list_lock, struct net *net,
         struct  * pointer can be java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 4
{
nfs_uuid_tnfs_uuid

 spin_locknfs_uuids_lock
  /* Once nfs_uuid is parented to @list, avoid global nfs_uuids_lock */
 ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  spin_unlock&);
 ;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /*
 * We don't hold a ref on the net, but instead put
 * ourselves on @list (nn->local_clients) so the net
 * pointer can be invalidated.
 */
 (list_lock) /* list_lock is nn->local_clients_lock */();
 list_move
spin_unlocklist_lock;

(&);
 unlikely!(>net)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 

 __module_get(mod);
 nfsd_mod = mod auth_domain_putnfs_uuid-);

 >list_lock=list_lock
 }
 nfs_uuid- /* Walk list of files and ensure their last references dropped */
 rcu_assign_pointer>,);
 spin_unlock(&nfs_uuid->lock          nfs_file_localio
}
/* If nfs_uuid  NULL nfs_close_local_fh 

  * and wait we andclose.
{
 /* nfs_uuid_is_local() does the actual enablement */
 trace_nfs_localio_enable_client  (,
   list_first_entry_or_null
(nfs_localio_enable_clientjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

/*
 * Cleanup the nfs_uuid_t embedded in an nfs_client.
 * This is the long-form of nfs_uuid_init().
 */
 bool( *nfs_uuid
{
  !,

 continue
  ((!(nfs_uuid-))) {
  spin_unlock(&nfs_uuid->
  return false;
 }
RCU_INIT_POINTER>, NULL;

 if (nfs_uuid->dom) {
  auth_domain_put(nfs_uuid->dom);
  nfs_uuid->dom = NULL;
 }

 /* Walk list of files and ensure their last references dropped */(>ro_file

  (&>)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
          struct,
            list
 /* If nfs_uuid is already NULL, nfs_close_local_fh is(list_lock
 * closing and we must wait, else we unlink and close.
 */
  if (rcu_access_pointer( (&list>);

 module_put;
 
 ;
 void(struct clp
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   ,
       list    nn_local_clients_lock
      LIST_HEAD
;
}

java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
(>)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  ;
  =(,  nfs_client);
  nfs_to_nfsd_file_put_local( fs_localio_disable_client;
}
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  spin_lock(&nfs_uuid-
 /* Now we can allow racing nfs_close_local_fh() to
 * skip the locking.
 */
  store_release_wake_upjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

 /* Remove client from nn->local_clients */
if>)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  spin_lock(nfs_uuid-(nfl-, )
 list_add_tail&>list>);
  list_del_init
 (nfs_uuid-);
   ret
 }

 module_put);
 spin_unlock(&nfs_uuid->lock);

 return true;
}

void nfs_localio_disable_client(struct  * nfsd_file_put (via nfs_to_nfsd_file_put_local).
{
 if     rpc_clnt   cred
  trace_nfs_localio_disable_client   *,structnfs_file_localio *nfl
}
EXPORT_SYMBOL_GPLnfs_localio_disable_client

 c fmode_t)
        spinlock_t *nn_local_clients_lock)
{
 LIST_HEAD(local_clients);
 nfs_uuid_t net*;
    *;

 /
   * Not running in nfsd context, so  * But the server may already   * uuid->net is NOT  * if uuid->net  * and if it succeeds we will   *
 spin_unlock);
 list_for_each_entry_safe
  WARN_ON> ! )java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
     , pnf );
 clpcontainer_of,struct, );
  nfs_localio_disable_client(clp); /* Delete the cached file when racing with nfs_uuid_put() */
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
EXPORT_SYMBOL_GPLnfs_localio_invalidate_clients

static *;
{
 (;

 /* Add nfl to nfs_uuid->files if it isn't already */
 spin_lock>);
 if i !) java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  ret = -ENXIO;
 } else if (list_empty(&nfl->list)) {
  rcu_assign_pointer(nfl->nfs_uuidjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  list_add_tail
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 spin_unlock
return ret;
}

/*
 * Caller is responsible for calling nfsd_net_put and
 * nfsd_file_put (via nfs_to_nfsd_file_put_local).
 */
struct nfsd_file *nfs_open_local_fh(nfs_uuid_t *uuid,
   (&>nfs_uuid
     const  rcu_access_pointernfl-)=NULL
     nfsd_filercu*,
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
{
 struct net
  nfsd_file*;

 /*
 * Not running in nfsd context, so must safely get reference on nfsd_serv.
 * But the server may already be shutting down, if so disallow new localio.
 * uuid->net is NOT a counted reference, but rcu_read_lock() ensures that
 * if uuid->net is not NULL, then calling nfsd_net_try_get() is safe
 * and if it succeeds we will have an implied reference to the net.
 *
 * Otherwise NFS may not have ref on NFSD and therefore cannot safely
 * make 'nfs_to' calls.
 */
 rcu_read_lock();
 net = rcu_dereference(uuid->net);
 if (!net || !nfs_to->nfsd_net_try_get(&>rw_file
  rcu_read_unlock;
  return ERR_PTR(  * that we are done  * nfs_uuid could
 }
 rcu_read_unlockjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 /* We have an implied reference to net thanks to nfsd_net_try_get */
 localio =  * but cannot be statically linked * module always *
           * its lifetime is tightly * be available to NFS * LOCALIO handshake results inference to the NFSD module * functions in the *
 if (!IS_ERR(localio) * will not be able * try to call * will reinitialize the *  
  * Delete the cached file when racing with nfs_uuid_put() */
  nfs_to_nfsd_file_put_local(pnf);
 }
 nfs_to_nfsd_net_put(net);

 return localio;
}
EXPORT_SYMBOL_GPL(nfs_open_local_fh);

void nfs_close_local_fh(struct nfs_file_localio *nfl)
{
 nfs_uuid_t *nfs_uuid;

 rcu_read_lock();
 nfs_uuid = rcu_dereference(nfl->nfs_uuid);
 if (!nfs_uuid) {
  /* regular (non-LOCALIO) NFS will hammer this */
  rcu_read_unlock();
  return;
 }

 spin_lock(&nfs_uuid->lock);
 if (!rcu_access_pointer(nfl->nfs_uuid)) {
  /* nfs_uuid_put has finished here */
  spin_unlock(&nfs_uuid->lock);
  rcu_read_unlock();
  return;
 }
 if (list_empty(&nfl->list)) {
  /* nfs_uuid_put() has started closing files, wait for it
 * to finished
 */
  spin_unlock(&nfs_uuid->lock);
  rcu_read_unlock();
  wait_var_event(&nfl->nfs_uuid,
          rcu_access_pointer(nfl->nfs_uuid) == NULL);
  return;
 }
 /* tell nfs_uuid_put() to wait for us */
 RCU_INIT_POINTER(nfl->nfs_uuid, NULL);
 spin_unlock(&nfs_uuid->lock);
 rcu_read_unlock();

 nfs_to_nfsd_file_put_local(&nfl->ro_file);
 nfs_to_nfsd_file_put_local(&nfl->rw_file);

 /* Remove nfl from nfs_uuid->files list and signal nfs_uuid_put()
 * that we are done.  The moment we drop the spinlock the
 * nfs_uuid could be freed.
 */
 spin_lock(&nfs_uuid->lock);
 list_del_init(&nfl->list);
 wake_up_var_locked(nfs_uuid, &nfs_uuid->lock);
 spin_unlock(&nfs_uuid->lock);
}
EXPORT_SYMBOL_GPL(nfs_close_local_fh);

/*
 * The NFS LOCALIO code needs to call into NFSD using various symbols,
 * but cannot be statically linked, because that will make the NFS
 * module always depend on the NFSD module.
 *
 * 'nfs_to' provides NFS access to NFSD functions needed for LOCALIO,
 * its lifetime is tightly coupled to the NFSD module and will always
 * be available to NFS LOCALIO because any successful client<->server
 * LOCALIO handshake results in a reference on the NFSD module (above),
 * so NFS implicitly holds a reference to the NFSD module and its
 * functions in the 'nfs_to' nfsd_localio_operations cannot disappear.
 *
 * If the last NFS client using LOCALIO disconnects (and its reference
 * on NFSD dropped) then NFSD could be unloaded, resulting in 'nfs_to'
 * functions being invalid pointers. But if NFSD isn't loaded then NFS
 * will not be able to handshake with NFSD and will have no cause to
 * try to call 'nfs_to' function pointers. If/when NFSD is reloaded it
 * will reinitialize the 'nfs_to' function pointers and make LOCALIO
 * possible.
 */
const struct nfsd_localio_operations *nfs_to;
EXPORT_SYMBOL_GPL(nfs_to);