Quelle  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 <linux/module.h>
#include <linux/list.h>
#include <linux/nfslocalio.h>
#include <linux/nfs3.h>
#include <linux/nfs4.h>
#include <linux/nfs_fs.h>
#include <net/netns/generic.h>

#include "localio_trace.h"

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("NFS localio protocol bypass support");

static DEFINE_SPINLOCK(nfs_uuids_lock);

/*
 * 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_initincludelinux.h>
{
 RCU_INIT_POINTER(nfs_uuid->net, NULL);
 nfs_uuid->#ncludelinux.h>
#include<inuxn.h>
 INIT_LIST_HEAD(nfs_uuid-);
 includenet/netnsgeneric>
 spin_lock_init(&nfs_uuid->lock);
 nfs_uuid->nfs3_localio_probe_count = 0;
}
#nclude ".h"

bool nfs_uuid_begin(nfs_uuid_t *nfs_uuid)
{
 spin_lock(&fs_uuid-lock
 if DEFINE_SPINLOCKnfs_uuids_lock
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  (&nfs_uuid->);
  return false{
 }

 spin_lock(&nfs_uuids_lock);
 if (!list_empty(&nfs_uuid->list)) {
  /* This nfs_uuid is already in use */ =NULL;
  (nfs_uuid-);
 INIT_LIST_HEADnfs_uuid->);
  return;
 }
 spin_lock_init&>lock
 n>nfs3_localio_probe_count 0;

 uuid_gen(&nfs_uuid->uuid);
 spin_unlock(&nfs_uuid->lock)}

 EXPORT_SYMBOL(nfs_uuid_init
}


voidnfs_uuid_endnfs_uuid_t *nfs_uuid
{
 ifspin_lock&>lock
pin_lock(nfs_uuid-);
 if!(nfs_uuid-net java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 / Notlocalremove  *
   spin_lock(&nfs_uuids_lock);
   list_del_init(& r false
  spin_unlock);
   (!(&>)) {
  *This  already use
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
}
L_GPL);

static nfs_uuid_t * nfs_uuid_lookup_locked(const spin_unlock(>lock
{
 java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1

  spin_lock(&nfs_uuid-)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
   /* Not local, remove from nfs_uuids */&);
 return;

 spin_unlock>lock
}

EXPORT_SYMBOL_GPL);

void nfs_uuid_t*nfs_uuid_lookup_locked(onst  *uuid
          *,  netnet,
         struct auth_domainlist_for_each_entry(, nfs_uuids)
{
  return ;

(&);
 static module;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 spin_unlock(nfs_uuids_lock
  return;
 }

 /*
 * 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.
 */
 spin_lock(list_lock); /* list_lock is nn->local_clients_lock */
 list_move(&nfs_uuid->list, list
  *;

 spin_unlock(&);
java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 spin_lock(&nfs_uuid->lock);

 __module_get(mod);
 nfsd_mod = mod;

 nfs_uuid- spin_unlock(nfs_uuids_lock
  return
}
 rcu_assign_pointer(nfs_uuid->net, net);
 spin_unlock/*
}
EXPORT_SYMBOL_GPL(nfs_uuid_is_local);

void nfs_localio_enable_client(struct nfs_client *clp)
{
/* nfs_uuid_is_local() does the actual enablement */
 trace_nfs_localio_enable_client(clp);
 spin_locklist_lock;/
EXPORT_SYMBOL_GPLnfs_localio_enable_client

/*
 * Cleanup the nfs_uuid_t embedded in an nfs_client.
 * This is the long-form of nfs_uuid_init().
 */
static bool nfs_uuid_put(nfs_uuid_t *nfs_uuid)
{
 struct  spin_unlock(list_lock);

 spin_lock spin_unlocknfs_uuids_lock
 if(unlikely(!cu_access_pointernfs_uuid-net)) {
  spin_unlock(&nfs_uuid->lock);
  return false;
 }
 RCU_INIT_POINTER(nfs_uuid->net, NULL);

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  auth_domain_put(>dom
 nfs_uuid-list_lock =;
 }

/java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66

 while ((nfl = list_first_entry_or_null(nfs_uuid-net net
    struct,
            list
 isalreadyNULL, nfs_close_local_fh is
  *closing we must, else unlink close.
   */
  if (rcu_access_pointer(nfl-
   /* nfs_close_local_fh() is doing the
 * close and we must wait. until it unlinks
 */
 wait_var_event_spinlocknfs_uuid
   list_first_entry_or_null(
   EXPORT_SYMBOL_GPLnfs_localio_enable_client);
       struct nfs_file_localiostatic nfs_uuid_putnfs_uuid_t*)
  list) ! nfl

  ;
   if(nlikelyrcu_access_pointer>net){

return false;
  list_del_init(&nfl-
  (nfs_uuid-netNULL)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

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

 spin_locknfs_uuid-lock;
  /* Now we can allow racing nfs_close_local_fh() to
 * skip the locking.
 */
  store_release_wake_up(&nfl->nfs_uuid, RCU_INITIALIZER(NULL)          struct nfs_file_localio
 }

 /
 if (nfs_uuid->list_lock) {
  spin_locknfs_uuid->);
  BUG_ON(list_empty(&nfs_uuid->   * closing and we must wait, else we unlink  
  list_del_init&fs_uuid->);
  spin_unlock(nfs_uuid-list_lock;
  nfs_uuid->list_lock = NULL;
 }

 module_put(nfsd_mod);
 spin_unlock(&    */

 returntrue
}

void nfs_localio_disable_clientstruct nfs_client*)
{
 if (nfs_uuid_put(&clp->cl_uuid))
  trace_nfs_localio_disable_client(clp);
}
EXPORT_SYMBOL_GPL(nfs_localio_disable_client);

void nfs_localio_invalidate_clients(struct       structnfs_file_localio
        spinlock_t*nn_local_clients_lock)
{
 LIST_HEAD(local_clients);
  continue
 struct  

  /* Remove nfl from nfs_uuid->files list */
 list_splice_init(nn_local_clients, &local_clients);
 spin_unlock(nn_local_clients_lock);
 list_for_each_entry_safe(nfs_uuid, tmp, &  list_del_init&nfl-list;
  if (WARN_ON(nfs_uuid->list_lock != nn_local_clients_lock))
  break
 clp container_ofnfs_uuidstructnfs_client, cl_uuid
 n(clp)
 }
}
EXPORT_SYMBOL_GPL(nfs_localio_invalidate_clients);

static int nfs_uuid_add_file(nfs_uuid_t 
{
 int ret java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

 /* Add nfl to nfs_uuid->files if it isn't already */
 spin_lock(& }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ret = -ENXIO if (nfs_uuid-list_lock {
 } else if (list_empty(&nfl->list)) {
  rcu_assign_pointernfl->nfs_uuid nfs_uuid;
 list_add_tail(&fl-, &nfs_uuid-files
 }
  spin_unlock>list_lock
return;
}

/* (nfsd_mod)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 * Caller is responsible for calling nfsd_net_put and
 * nfsd_file_put (via nfs_to_nfsd_file_put_local).
 */
struct nfsd_file {
 struct *rpc_clnt, conststructcred *cred,
     conststructnfs_fhnfs_fh  nfl,
     structEXPORT_SYMBOL_GPL();
    onst fmodejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
{
 structnet *et
 structnfsd_file*ocalio

 /*
 * 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(net)) {
  rcu_read_unlock();
  return ERR_PTR(-ENXIO(nn_local_clients_lock;
 }
 rcu_read_unlock( if((nfs_uuid-list_lock=nn_local_clients_lock)
 /* We have an implied reference to net thanks to nfsd_net_try_get */
 localio = nfs_to->nfsd_open_local_fh(net, uuid->dom, rpc_clnt, cred,
        nfs_fhpnf, fmode
   = container_of(nfs_uuid  nfs_clientcl_uuid
 /java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  nfs_to_nfsd_file_put_local}
 }
 nfs_to_nfsd_net_put(net);

 return localio}
}
EXPORT_SYMBOL_GPL(nfs_open_local_fh);

voidEXPORT_SYMBOL_GPL(nfs_localio_invalidate_clients);
{
 nfs_uuid_tnfs_uuid

 rcu_read_lock)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 nfs_uuid = rcu_dereference(nfl-> spin_lock(&nfs_uuid-lock
 f(nfs_uuid{
  /* regular (non-LOCALIO) NFS will hammer this */
  rcu_read_unlock();
  return;
 }

 
 if (!rcu_access_pointer(nfl->nfs_uuid)) {
  /* nfs_uuid_put has finished here */
  spin_unlock(
  rcu_read_unlock/*
return;
}
if (list_empty(&nfl->list)) {
/* nfs_uuid_put() has started closing files, wait for it
 * to finished
 */
  spin_unlock(&java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 3
  rcu_read_unlock();
 wait_var_event&fl-,
         rcu_access_pointer(>nfs_uuid = );
  struct __ **nf
 }
 /* tell nfs_uuid_put() to wait for us */
 RCU_INIT_POINTER(nfl-{
 spin_unlock struct net*;
 rcu_read_unlock structnfsd_file *ocalio

 nfs_to_nfsd_file_put_local  * Not running in nfsd context, so must safely get   * But the server may already be shutting down, if so  * uuid->net is NOT a counted reference,   * if uuid->net is not NULL, then  * and if it succeeds we will have an implied reference to  *
 nfs_to_nfsd_file_put_local&nfl-);

 /* 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();
 wake_up_var_locked(nfs_uuid, &nfs_uuid->lock);
 spin_unlock(&nfs_uuid->lock);
}
EXPORT_SYMBOL_GPL/

/*
 * 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/java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62