2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2001 The Regents of the University of Michigan.
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Kendrick Smith <kmsmith@umich.edu>
|
|
|
|
* Andy Adamson <kandros@umich.edu>
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
*
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. Neither the name of the University nor the names of its
|
|
|
|
* contributors may be used to endorse or promote products derived
|
|
|
|
* from this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
|
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
|
* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
|
|
|
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
|
|
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2008-02-16 01:37:31 +03:00
|
|
|
#include <linux/file.h>
|
2010-09-18 17:09:31 +04:00
|
|
|
#include <linux/fs.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 11:04:11 +03:00
|
|
|
#include <linux/slab.h>
|
2005-06-24 09:04:32 +04:00
|
|
|
#include <linux/namei.h>
|
2007-07-17 15:04:39 +04:00
|
|
|
#include <linux/swap.h>
|
2011-07-13 18:50:48 +04:00
|
|
|
#include <linux/pagemap.h>
|
2012-05-29 21:56:37 +04:00
|
|
|
#include <linux/ratelimit.h>
|
2008-12-24 00:17:15 +03:00
|
|
|
#include <linux/sunrpc/svcauth_gss.h>
|
2013-02-04 21:50:00 +04:00
|
|
|
#include <linux/sunrpc/addr.h>
|
2014-12-10 18:33:11 +03:00
|
|
|
#include <linux/jhash.h>
|
2019-06-19 19:39:46 +03:00
|
|
|
#include <linux/string_helpers.h>
|
2021-03-20 01:38:04 +03:00
|
|
|
#include <linux/fsnotify.h>
|
2021-05-21 22:09:37 +03:00
|
|
|
#include <linux/nfs_ssc.h>
|
2009-12-03 21:30:56 +03:00
|
|
|
#include "xdr4.h"
|
2013-04-09 19:34:36 +04:00
|
|
|
#include "xdr4cb.h"
|
2009-11-05 02:12:35 +03:00
|
|
|
#include "vfs.h"
|
2012-04-26 00:49:18 +04:00
|
|
|
#include "current_stateid.h"
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2012-07-25 16:56:58 +04:00
|
|
|
#include "netns.h"
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 15:11:59 +04:00
|
|
|
#include "pnfs.h"
|
2019-08-18 21:18:52 +03:00
|
|
|
#include "filecache.h"
|
2020-04-05 18:42:29 +03:00
|
|
|
#include "trace.h"
|
2012-07-25 16:56:58 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#define NFSDDBG_FACILITY NFSDDBG_PROC
|
|
|
|
|
2011-12-13 00:00:35 +04:00
|
|
|
#define all_ones {{~0,~0},~0}
|
|
|
|
static const stateid_t one_stateid = {
|
|
|
|
.si_generation = ~0,
|
|
|
|
.si_opaque = all_ones,
|
|
|
|
};
|
|
|
|
static const stateid_t zero_stateid = {
|
|
|
|
/* all fields zero */
|
|
|
|
};
|
2012-02-14 01:55:23 +04:00
|
|
|
static const stateid_t currentstateid = {
|
|
|
|
.si_generation = 1,
|
|
|
|
};
|
2017-11-03 15:00:12 +03:00
|
|
|
static const stateid_t close_stateid = {
|
|
|
|
.si_generation = 0xffffffffU,
|
|
|
|
};
|
2011-12-13 00:00:35 +04:00
|
|
|
|
2009-04-03 09:28:28 +04:00
|
|
|
static u64 current_sessionid = 1;
|
2005-06-24 09:04:03 +04:00
|
|
|
|
2011-12-13 00:00:35 +04:00
|
|
|
#define ZERO_STATEID(stateid) (!memcmp((stateid), &zero_stateid, sizeof(stateid_t)))
|
|
|
|
#define ONE_STATEID(stateid) (!memcmp((stateid), &one_stateid, sizeof(stateid_t)))
|
2012-02-14 01:55:23 +04:00
|
|
|
#define CURRENT_STATEID(stateid) (!memcmp((stateid), ¤tstateid, sizeof(stateid_t)))
|
2017-11-09 21:41:10 +03:00
|
|
|
#define CLOSE_STATEID(stateid) (!memcmp((stateid), &close_stateid, sizeof(stateid_t)))
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* forward declarations */
|
2014-07-24 00:17:41 +04:00
|
|
|
static bool check_for_locks(struct nfs4_file *fp, struct nfs4_lockowner *lowner);
|
2014-07-30 05:34:06 +04:00
|
|
|
static void nfs4_free_ol_stateid(struct nfs4_stid *stid);
|
2019-03-27 01:06:28 +03:00
|
|
|
void nfsd4_end_grace(struct nfsd_net *nn);
|
2019-10-04 23:34:26 +03:00
|
|
|
static void _free_cpntf_state_locked(struct nfsd_net *nn, struct nfs4_cpntf_state *cps);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2009-02-23 01:51:34 +03:00
|
|
|
/* Locking: */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Currently used for the del_recall_lru and file hash table. In an
|
|
|
|
* effort to decrease the scope of the client_mutex, this spinlock may
|
|
|
|
* eventually cover more:
|
|
|
|
*/
|
2014-05-30 17:09:30 +04:00
|
|
|
static DEFINE_SPINLOCK(state_lock);
|
2009-02-23 01:51:34 +03:00
|
|
|
|
2017-11-09 01:29:51 +03:00
|
|
|
enum nfsd4_st_mutex_lock_subclass {
|
|
|
|
OPEN_STATEID_MUTEX = 0,
|
|
|
|
LOCK_STATEID_MUTEX = 1,
|
|
|
|
};
|
|
|
|
|
2014-07-30 05:34:33 +04:00
|
|
|
/*
|
|
|
|
* A waitqueue for all in-progress 4.0 CLOSE operations that are waiting for
|
|
|
|
* the refcount on the open stateid to drop.
|
|
|
|
*/
|
|
|
|
static DECLARE_WAIT_QUEUE_HEAD(close_wq);
|
|
|
|
|
2019-06-19 19:43:11 +03:00
|
|
|
/*
|
|
|
|
* A waitqueue where a writer to clients/#/ctl destroying a client can
|
|
|
|
* wait for cl_rpc_users to drop to 0 and then for the client to be
|
|
|
|
* unhashed.
|
|
|
|
*/
|
|
|
|
static DECLARE_WAIT_QUEUE_HEAD(expiry_wq);
|
|
|
|
|
2018-03-16 16:47:22 +03:00
|
|
|
static struct kmem_cache *client_slab;
|
2014-05-21 18:43:03 +04:00
|
|
|
static struct kmem_cache *openowner_slab;
|
|
|
|
static struct kmem_cache *lockowner_slab;
|
|
|
|
static struct kmem_cache *file_slab;
|
|
|
|
static struct kmem_cache *stateid_slab;
|
|
|
|
static struct kmem_cache *deleg_slab;
|
2015-04-27 15:50:14 +03:00
|
|
|
static struct kmem_cache *odstate_slab;
|
2005-06-24 09:03:01 +04:00
|
|
|
|
2013-03-19 20:05:39 +04:00
|
|
|
static void free_session(struct nfsd4_session *);
|
2012-02-24 05:40:52 +04:00
|
|
|
|
2015-11-22 00:57:39 +03:00
|
|
|
static const struct nfsd4_callback_ops nfsd4_cb_recall_ops;
|
2016-09-16 23:28:24 +03:00
|
|
|
static const struct nfsd4_callback_ops nfsd4_cb_notify_lock_ops;
|
2014-09-24 14:19:19 +04:00
|
|
|
|
2013-06-18 22:26:02 +04:00
|
|
|
static bool is_session_dead(struct nfsd4_session *ses)
|
2013-03-19 20:05:39 +04:00
|
|
|
{
|
2013-06-18 22:26:02 +04:00
|
|
|
return ses->se_flags & NFS4_SESSION_DEAD;
|
2013-03-19 20:05:39 +04:00
|
|
|
}
|
|
|
|
|
2013-06-18 22:26:02 +04:00
|
|
|
static __be32 mark_session_dead_locked(struct nfsd4_session *ses, int ref_held_by_me)
|
2012-02-24 05:40:52 +04:00
|
|
|
{
|
2013-06-18 22:26:02 +04:00
|
|
|
if (atomic_read(&ses->se_ref) > ref_held_by_me)
|
2013-03-19 20:05:39 +04:00
|
|
|
return nfserr_jukebox;
|
|
|
|
ses->se_flags |= NFS4_SESSION_DEAD;
|
|
|
|
return nfs_ok;
|
2012-02-24 05:40:52 +04:00
|
|
|
}
|
|
|
|
|
2013-04-02 06:23:49 +04:00
|
|
|
static bool is_client_expired(struct nfs4_client *clp)
|
|
|
|
{
|
|
|
|
return clp->cl_time == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32 get_client_locked(struct nfs4_client *clp)
|
|
|
|
{
|
2014-07-30 16:27:10 +04:00
|
|
|
struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
|
|
|
|
|
|
|
|
lockdep_assert_held(&nn->client_lock);
|
|
|
|
|
2013-04-02 06:23:49 +04:00
|
|
|
if (is_client_expired(clp))
|
|
|
|
return nfserr_expired;
|
2019-03-20 18:54:11 +03:00
|
|
|
atomic_inc(&clp->cl_rpc_users);
|
2013-04-02 06:23:49 +04:00
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* must be called under the client_lock */
|
|
|
|
static inline void
|
|
|
|
renew_client_locked(struct nfs4_client *clp)
|
|
|
|
{
|
|
|
|
struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
|
|
|
|
|
|
|
|
if (is_client_expired(clp)) {
|
|
|
|
WARN_ON(1);
|
|
|
|
printk("%s: client (clientid %08x/%08x) already expired\n",
|
|
|
|
__func__,
|
|
|
|
clp->cl_clientid.cl_boot,
|
|
|
|
clp->cl_clientid.cl_id);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_move_tail(&clp->cl_lru, &nn->client_lru);
|
2019-11-04 18:31:52 +03:00
|
|
|
clp->cl_time = ktime_get_boottime_seconds();
|
2013-04-02 06:23:49 +04:00
|
|
|
}
|
|
|
|
|
2013-04-17 06:14:15 +04:00
|
|
|
static void put_client_renew_locked(struct nfs4_client *clp)
|
2013-04-02 06:23:49 +04:00
|
|
|
{
|
2014-07-30 16:27:10 +04:00
|
|
|
struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
|
|
|
|
|
|
|
|
lockdep_assert_held(&nn->client_lock);
|
|
|
|
|
2019-03-20 18:54:11 +03:00
|
|
|
if (!atomic_dec_and_test(&clp->cl_rpc_users))
|
2013-04-02 06:23:49 +04:00
|
|
|
return;
|
|
|
|
if (!is_client_expired(clp))
|
|
|
|
renew_client_locked(clp);
|
2019-06-19 19:43:11 +03:00
|
|
|
else
|
|
|
|
wake_up_all(&expiry_wq);
|
2013-04-02 06:23:49 +04:00
|
|
|
}
|
|
|
|
|
2014-06-30 19:48:44 +04:00
|
|
|
static void put_client_renew(struct nfs4_client *clp)
|
|
|
|
{
|
|
|
|
struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
|
|
|
|
|
2019-03-20 18:54:11 +03:00
|
|
|
if (!atomic_dec_and_lock(&clp->cl_rpc_users, &nn->client_lock))
|
2014-07-08 22:02:50 +04:00
|
|
|
return;
|
|
|
|
if (!is_client_expired(clp))
|
|
|
|
renew_client_locked(clp);
|
2019-06-19 19:43:11 +03:00
|
|
|
else
|
|
|
|
wake_up_all(&expiry_wq);
|
2014-06-30 19:48:44 +04:00
|
|
|
spin_unlock(&nn->client_lock);
|
|
|
|
}
|
|
|
|
|
2014-06-30 19:48:42 +04:00
|
|
|
static __be32 nfsd4_get_session_locked(struct nfsd4_session *ses)
|
|
|
|
{
|
|
|
|
__be32 status;
|
|
|
|
|
|
|
|
if (is_session_dead(ses))
|
|
|
|
return nfserr_badsession;
|
|
|
|
status = get_client_locked(ses->se_client);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
atomic_inc(&ses->se_ref);
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nfsd4_put_session_locked(struct nfsd4_session *ses)
|
|
|
|
{
|
|
|
|
struct nfs4_client *clp = ses->se_client;
|
2014-07-30 16:27:10 +04:00
|
|
|
struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
|
|
|
|
|
|
|
|
lockdep_assert_held(&nn->client_lock);
|
2014-06-30 19:48:42 +04:00
|
|
|
|
|
|
|
if (atomic_dec_and_test(&ses->se_ref) && is_session_dead(ses))
|
|
|
|
free_session(ses);
|
|
|
|
put_client_renew_locked(clp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nfsd4_put_session(struct nfsd4_session *ses)
|
|
|
|
{
|
|
|
|
struct nfs4_client *clp = ses->se_client;
|
|
|
|
struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
|
|
|
|
|
|
|
|
spin_lock(&nn->client_lock);
|
|
|
|
nfsd4_put_session_locked(ses);
|
|
|
|
spin_unlock(&nn->client_lock);
|
|
|
|
}
|
|
|
|
|
2016-09-16 23:28:24 +03:00
|
|
|
static struct nfsd4_blocked_lock *
|
|
|
|
find_blocked_lock(struct nfs4_lockowner *lo, struct knfsd_fh *fh,
|
|
|
|
struct nfsd_net *nn)
|
|
|
|
{
|
|
|
|
struct nfsd4_blocked_lock *cur, *found = NULL;
|
|
|
|
|
2016-10-20 16:34:31 +03:00
|
|
|
spin_lock(&nn->blocked_locks_lock);
|
2016-09-16 23:28:24 +03:00
|
|
|
list_for_each_entry(cur, &lo->lo_blocked, nbl_list) {
|
|
|
|
if (fh_match(fh, &cur->nbl_fh)) {
|
|
|
|
list_del_init(&cur->nbl_list);
|
2016-09-16 23:28:25 +03:00
|
|
|
list_del_init(&cur->nbl_lru);
|
2016-09-16 23:28:24 +03:00
|
|
|
found = cur;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2016-10-20 16:34:31 +03:00
|
|
|
spin_unlock(&nn->blocked_locks_lock);
|
2016-09-16 23:28:24 +03:00
|
|
|
if (found)
|
2018-11-30 02:04:08 +03:00
|
|
|
locks_delete_block(&found->nbl_lock);
|
2016-09-16 23:28:24 +03:00
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct nfsd4_blocked_lock *
|
|
|
|
find_or_allocate_block(struct nfs4_lockowner *lo, struct knfsd_fh *fh,
|
|
|
|
struct nfsd_net *nn)
|
|
|
|
{
|
|
|
|
struct nfsd4_blocked_lock *nbl;
|
|
|
|
|
|
|
|
nbl = find_blocked_lock(lo, fh, nn);
|
|
|
|
if (!nbl) {
|
|
|
|
nbl= kmalloc(sizeof(*nbl), GFP_KERNEL);
|
|
|
|
if (nbl) {
|
2020-03-27 07:50:40 +03:00
|
|
|
INIT_LIST_HEAD(&nbl->nbl_list);
|
|
|
|
INIT_LIST_HEAD(&nbl->nbl_lru);
|
2016-09-16 23:28:24 +03:00
|
|
|
fh_copy_shallow(&nbl->nbl_fh, fh);
|
|
|
|
locks_init_lock(&nbl->nbl_lock);
|
|
|
|
nfsd4_init_cb(&nbl->nbl_cb, lo->lo_owner.so_client,
|
|
|
|
&nfsd4_cb_notify_lock_ops,
|
|
|
|
NFSPROC4_CLNT_CB_NOTIFY_LOCK);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nbl;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
free_blocked_lock(struct nfsd4_blocked_lock *nbl)
|
|
|
|
{
|
2019-04-22 19:34:23 +03:00
|
|
|
locks_delete_block(&nbl->nbl_lock);
|
2016-09-16 23:28:24 +03:00
|
|
|
locks_release_private(&nbl->nbl_lock);
|
|
|
|
kfree(nbl);
|
|
|
|
}
|
|
|
|
|
2018-03-16 18:32:02 +03:00
|
|
|
static void
|
|
|
|
remove_blocked_locks(struct nfs4_lockowner *lo)
|
|
|
|
{
|
|
|
|
struct nfs4_client *clp = lo->lo_owner.so_client;
|
|
|
|
struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
|
|
|
|
struct nfsd4_blocked_lock *nbl;
|
|
|
|
LIST_HEAD(reaplist);
|
|
|
|
|
|
|
|
/* Dequeue all blocked locks */
|
|
|
|
spin_lock(&nn->blocked_locks_lock);
|
|
|
|
while (!list_empty(&lo->lo_blocked)) {
|
|
|
|
nbl = list_first_entry(&lo->lo_blocked,
|
|
|
|
struct nfsd4_blocked_lock,
|
|
|
|
nbl_list);
|
|
|
|
list_del_init(&nbl->nbl_list);
|
|
|
|
list_move(&nbl->nbl_lru, &reaplist);
|
|
|
|
}
|
|
|
|
spin_unlock(&nn->blocked_locks_lock);
|
|
|
|
|
|
|
|
/* Now free them */
|
|
|
|
while (!list_empty(&reaplist)) {
|
|
|
|
nbl = list_first_entry(&reaplist, struct nfsd4_blocked_lock,
|
|
|
|
nbl_lru);
|
|
|
|
list_del_init(&nbl->nbl_lru);
|
|
|
|
free_blocked_lock(nbl);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-22 19:34:24 +03:00
|
|
|
static void
|
|
|
|
nfsd4_cb_notify_lock_prepare(struct nfsd4_callback *cb)
|
|
|
|
{
|
|
|
|
struct nfsd4_blocked_lock *nbl = container_of(cb,
|
|
|
|
struct nfsd4_blocked_lock, nbl_cb);
|
|
|
|
locks_delete_block(&nbl->nbl_lock);
|
|
|
|
}
|
|
|
|
|
2016-09-16 23:28:24 +03:00
|
|
|
static int
|
|
|
|
nfsd4_cb_notify_lock_done(struct nfsd4_callback *cb, struct rpc_task *task)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Since this is just an optimization, we don't try very hard if it
|
|
|
|
* turns out not to succeed. We'll requeue it on NFS4ERR_DELAY, and
|
|
|
|
* just quit trying on anything else.
|
|
|
|
*/
|
|
|
|
switch (task->tk_status) {
|
|
|
|
case -NFS4ERR_DELAY:
|
|
|
|
rpc_delay(task, 1 * HZ);
|
|
|
|
return 0;
|
|
|
|
default:
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
nfsd4_cb_notify_lock_release(struct nfsd4_callback *cb)
|
|
|
|
{
|
|
|
|
struct nfsd4_blocked_lock *nbl = container_of(cb,
|
|
|
|
struct nfsd4_blocked_lock, nbl_cb);
|
|
|
|
|
|
|
|
free_blocked_lock(nbl);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct nfsd4_callback_ops nfsd4_cb_notify_lock_ops = {
|
2019-04-22 19:34:24 +03:00
|
|
|
.prepare = nfsd4_cb_notify_lock_prepare,
|
2016-09-16 23:28:24 +03:00
|
|
|
.done = nfsd4_cb_notify_lock_done,
|
|
|
|
.release = nfsd4_cb_notify_lock_release,
|
|
|
|
};
|
|
|
|
|
2021-04-16 21:00:17 +03:00
|
|
|
/*
|
|
|
|
* We store the NONE, READ, WRITE, and BOTH bits separately in the
|
|
|
|
* st_{access,deny}_bmap field of the stateid, in order to track not
|
|
|
|
* only what share bits are currently in force, but also what
|
|
|
|
* combinations of share bits previous opens have used. This allows us
|
|
|
|
* to enforce the recommendation of rfc 3530 14.2.19 that the server
|
|
|
|
* return an error if the client attempt to downgrade to a combination
|
|
|
|
* of share bits not explicable by closing some of its previous opens.
|
|
|
|
*
|
|
|
|
* XXX: This enforcement is actually incomplete, since we don't keep
|
|
|
|
* track of access/deny bit combinations; so, e.g., we allow:
|
|
|
|
*
|
|
|
|
* OPEN allow read, deny write
|
|
|
|
* OPEN allow both, deny none
|
|
|
|
* DOWNGRADE allow read, deny none
|
|
|
|
*
|
|
|
|
* which we should reject.
|
|
|
|
*/
|
|
|
|
static unsigned int
|
|
|
|
bmap_to_share_mode(unsigned long bmap)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
unsigned int access = 0;
|
|
|
|
|
|
|
|
for (i = 1; i < 4; i++) {
|
|
|
|
if (test_bit(i, &bmap))
|
|
|
|
access |= i;
|
|
|
|
}
|
|
|
|
return access;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set share access for a given stateid */
|
|
|
|
static inline void
|
|
|
|
set_access(u32 access, struct nfs4_ol_stateid *stp)
|
|
|
|
{
|
|
|
|
unsigned char mask = 1 << access;
|
|
|
|
|
|
|
|
WARN_ON_ONCE(access > NFS4_SHARE_ACCESS_BOTH);
|
|
|
|
stp->st_access_bmap |= mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* clear share access for a given stateid */
|
|
|
|
static inline void
|
|
|
|
clear_access(u32 access, struct nfs4_ol_stateid *stp)
|
|
|
|
{
|
|
|
|
unsigned char mask = 1 << access;
|
|
|
|
|
|
|
|
WARN_ON_ONCE(access > NFS4_SHARE_ACCESS_BOTH);
|
|
|
|
stp->st_access_bmap &= ~mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* test whether a given stateid has access */
|
|
|
|
static inline bool
|
|
|
|
test_access(u32 access, struct nfs4_ol_stateid *stp)
|
|
|
|
{
|
|
|
|
unsigned char mask = 1 << access;
|
|
|
|
|
|
|
|
return (bool)(stp->st_access_bmap & mask);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set share deny for a given stateid */
|
|
|
|
static inline void
|
|
|
|
set_deny(u32 deny, struct nfs4_ol_stateid *stp)
|
|
|
|
{
|
|
|
|
unsigned char mask = 1 << deny;
|
|
|
|
|
|
|
|
WARN_ON_ONCE(deny > NFS4_SHARE_DENY_BOTH);
|
|
|
|
stp->st_deny_bmap |= mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* clear share deny for a given stateid */
|
|
|
|
static inline void
|
|
|
|
clear_deny(u32 deny, struct nfs4_ol_stateid *stp)
|
|
|
|
{
|
|
|
|
unsigned char mask = 1 << deny;
|
|
|
|
|
|
|
|
WARN_ON_ONCE(deny > NFS4_SHARE_DENY_BOTH);
|
|
|
|
stp->st_deny_bmap &= ~mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* test whether a given stateid is denying specific access */
|
|
|
|
static inline bool
|
|
|
|
test_deny(u32 deny, struct nfs4_ol_stateid *stp)
|
|
|
|
{
|
|
|
|
unsigned char mask = 1 << deny;
|
|
|
|
|
|
|
|
return (bool)(stp->st_deny_bmap & mask);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nfs4_access_to_omode(u32 access)
|
|
|
|
{
|
|
|
|
switch (access & NFS4_SHARE_ACCESS_BOTH) {
|
|
|
|
case NFS4_SHARE_ACCESS_READ:
|
|
|
|
return O_RDONLY;
|
|
|
|
case NFS4_SHARE_ACCESS_WRITE:
|
|
|
|
return O_WRONLY;
|
|
|
|
case NFS4_SHARE_ACCESS_BOTH:
|
|
|
|
return O_RDWR;
|
|
|
|
}
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
return O_RDONLY;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
access_permit_read(struct nfs4_ol_stateid *stp)
|
|
|
|
{
|
|
|
|
return test_access(NFS4_SHARE_ACCESS_READ, stp) ||
|
|
|
|
test_access(NFS4_SHARE_ACCESS_BOTH, stp) ||
|
|
|
|
test_access(NFS4_SHARE_ACCESS_WRITE, stp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
access_permit_write(struct nfs4_ol_stateid *stp)
|
|
|
|
{
|
|
|
|
return test_access(NFS4_SHARE_ACCESS_WRITE, stp) ||
|
|
|
|
test_access(NFS4_SHARE_ACCESS_BOTH, stp);
|
|
|
|
}
|
|
|
|
|
2014-08-22 18:18:43 +04:00
|
|
|
static inline struct nfs4_stateowner *
|
|
|
|
nfs4_get_stateowner(struct nfs4_stateowner *sop)
|
|
|
|
{
|
|
|
|
atomic_inc(&sop->so_count);
|
|
|
|
return sop;
|
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:34 +04:00
|
|
|
static int
|
2014-07-30 05:34:36 +04:00
|
|
|
same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner)
|
2014-07-30 05:34:34 +04:00
|
|
|
{
|
|
|
|
return (sop->so_owner.len == owner->len) &&
|
2014-07-30 05:34:36 +04:00
|
|
|
0 == memcmp(sop->so_owner.data, owner->data, owner->len);
|
2014-07-30 05:34:34 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct nfs4_openowner *
|
|
|
|
find_openstateowner_str_locked(unsigned int hashval, struct nfsd4_open *open,
|
2014-07-30 05:34:36 +04:00
|
|
|
struct nfs4_client *clp)
|
2014-07-30 05:34:34 +04:00
|
|
|
{
|
|
|
|
struct nfs4_stateowner *so;
|
|
|
|
|
2014-07-30 05:34:36 +04:00
|
|
|
lockdep_assert_held(&clp->cl_lock);
|
2014-07-30 05:34:34 +04:00
|
|
|
|
2014-07-30 05:34:36 +04:00
|
|
|
list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[hashval],
|
|
|
|
so_strhash) {
|
2014-07-30 05:34:34 +04:00
|
|
|
if (!so->so_is_open_owner)
|
|
|
|
continue;
|
2014-08-22 18:18:43 +04:00
|
|
|
if (same_owner_str(so, &open->op_owner))
|
|
|
|
return openowner(nfs4_get_stateowner(so));
|
2014-07-30 05:34:34 +04:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct nfs4_openowner *
|
|
|
|
find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open,
|
2014-07-30 05:34:36 +04:00
|
|
|
struct nfs4_client *clp)
|
2014-07-30 05:34:34 +04:00
|
|
|
{
|
|
|
|
struct nfs4_openowner *oo;
|
|
|
|
|
2014-07-30 05:34:36 +04:00
|
|
|
spin_lock(&clp->cl_lock);
|
|
|
|
oo = find_openstateowner_str_locked(hashval, open, clp);
|
|
|
|
spin_unlock(&clp->cl_lock);
|
2014-07-30 05:34:34 +04:00
|
|
|
return oo;
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
static inline u32
|
|
|
|
opaque_hashval(const void *ptr, int nbytes)
|
|
|
|
{
|
|
|
|
unsigned char *cptr = (unsigned char *) ptr;
|
|
|
|
|
|
|
|
u32 x = 0;
|
|
|
|
while (nbytes--) {
|
|
|
|
x *= 37;
|
|
|
|
x += *cptr++;
|
|
|
|
}
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
2014-10-23 16:01:02 +04:00
|
|
|
static void nfsd4_free_file_rcu(struct rcu_head *rcu)
|
2011-10-14 00:00:16 +04:00
|
|
|
{
|
2014-10-23 16:01:02 +04:00
|
|
|
struct nfs4_file *fp = container_of(rcu, struct nfs4_file, fi_rcu);
|
|
|
|
|
|
|
|
kmem_cache_free(file_slab, fp);
|
2011-10-14 00:00:16 +04:00
|
|
|
}
|
|
|
|
|
2014-08-14 10:50:16 +04:00
|
|
|
void
|
2005-06-24 09:03:10 +04:00
|
|
|
put_nfs4_file(struct nfs4_file *fi)
|
|
|
|
{
|
2014-07-16 18:31:57 +04:00
|
|
|
might_lock(&state_lock);
|
|
|
|
|
2017-10-20 12:53:30 +03:00
|
|
|
if (refcount_dec_and_lock(&fi->fi_ref, &state_lock)) {
|
2014-10-23 16:01:02 +04:00
|
|
|
hlist_del_rcu(&fi->fi_hash);
|
2014-05-30 17:09:30 +04:00
|
|
|
spin_unlock(&state_lock);
|
2015-04-27 15:50:14 +03:00
|
|
|
WARN_ON_ONCE(!list_empty(&fi->fi_clnt_odstate));
|
2014-10-23 16:01:02 +04:00
|
|
|
WARN_ON_ONCE(!list_empty(&fi->fi_delegations));
|
|
|
|
call_rcu(&fi->fi_rcu, nfsd4_free_file_rcu);
|
2009-02-23 01:51:34 +03:00
|
|
|
}
|
2005-06-24 09:03:10 +04:00
|
|
|
}
|
|
|
|
|
2019-08-18 21:18:53 +03:00
|
|
|
static struct nfsd_file *
|
2014-07-10 22:07:26 +04:00
|
|
|
__nfs4_get_fd(struct nfs4_file *f, int oflag)
|
|
|
|
{
|
|
|
|
if (f->fi_fds[oflag])
|
2019-08-18 21:18:53 +03:00
|
|
|
return nfsd_file_get(f->fi_fds[oflag]);
|
2014-07-10 22:07:26 +04:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2019-08-18 21:18:53 +03:00
|
|
|
static struct nfsd_file *
|
2014-07-10 22:07:26 +04:00
|
|
|
find_writeable_file_locked(struct nfs4_file *f)
|
|
|
|
{
|
2019-08-18 21:18:53 +03:00
|
|
|
struct nfsd_file *ret;
|
2014-07-10 22:07:26 +04:00
|
|
|
|
|
|
|
lockdep_assert_held(&f->fi_lock);
|
|
|
|
|
|
|
|
ret = __nfs4_get_fd(f, O_WRONLY);
|
|
|
|
if (!ret)
|
|
|
|
ret = __nfs4_get_fd(f, O_RDWR);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-08-18 21:18:53 +03:00
|
|
|
static struct nfsd_file *
|
2014-07-10 22:07:26 +04:00
|
|
|
find_writeable_file(struct nfs4_file *f)
|
|
|
|
{
|
2019-08-18 21:18:53 +03:00
|
|
|
struct nfsd_file *ret;
|
2014-07-10 22:07:26 +04:00
|
|
|
|
|
|
|
spin_lock(&f->fi_lock);
|
|
|
|
ret = find_writeable_file_locked(f);
|
|
|
|
spin_unlock(&f->fi_lock);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-08-18 21:18:53 +03:00
|
|
|
static struct nfsd_file *
|
|
|
|
find_readable_file_locked(struct nfs4_file *f)
|
2014-07-10 22:07:26 +04:00
|
|
|
{
|
2019-08-18 21:18:53 +03:00
|
|
|
struct nfsd_file *ret;
|
2014-07-10 22:07:26 +04:00
|
|
|
|
|
|
|
lockdep_assert_held(&f->fi_lock);
|
|
|
|
|
|
|
|
ret = __nfs4_get_fd(f, O_RDONLY);
|
|
|
|
if (!ret)
|
|
|
|
ret = __nfs4_get_fd(f, O_RDWR);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-08-18 21:18:53 +03:00
|
|
|
static struct nfsd_file *
|
2014-07-10 22:07:26 +04:00
|
|
|
find_readable_file(struct nfs4_file *f)
|
|
|
|
{
|
2019-08-18 21:18:53 +03:00
|
|
|
struct nfsd_file *ret;
|
2014-07-10 22:07:26 +04:00
|
|
|
|
|
|
|
spin_lock(&f->fi_lock);
|
|
|
|
ret = find_readable_file_locked(f);
|
|
|
|
spin_unlock(&f->fi_lock);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-08-18 21:18:53 +03:00
|
|
|
struct nfsd_file *
|
2014-07-10 22:07:26 +04:00
|
|
|
find_any_file(struct nfs4_file *f)
|
|
|
|
{
|
2019-08-18 21:18:53 +03:00
|
|
|
struct nfsd_file *ret;
|
2014-07-10 22:07:26 +04:00
|
|
|
|
2020-03-02 02:21:38 +03:00
|
|
|
if (!f)
|
|
|
|
return NULL;
|
2014-07-10 22:07:26 +04:00
|
|
|
spin_lock(&f->fi_lock);
|
|
|
|
ret = __nfs4_get_fd(f, O_RDWR);
|
|
|
|
if (!ret) {
|
|
|
|
ret = __nfs4_get_fd(f, O_WRONLY);
|
|
|
|
if (!ret)
|
|
|
|
ret = __nfs4_get_fd(f, O_RDONLY);
|
|
|
|
}
|
|
|
|
spin_unlock(&f->fi_lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2020-07-15 20:31:36 +03:00
|
|
|
static struct nfsd_file *find_deleg_file(struct nfs4_file *f)
|
|
|
|
{
|
|
|
|
struct nfsd_file *ret = NULL;
|
|
|
|
|
|
|
|
spin_lock(&f->fi_lock);
|
|
|
|
if (f->fi_deleg_file)
|
|
|
|
ret = nfsd_file_get(f->fi_deleg_file);
|
|
|
|
spin_unlock(&f->fi_lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-07-25 15:34:22 +04:00
|
|
|
static atomic_long_t num_delegations;
|
2013-02-23 04:35:47 +04:00
|
|
|
unsigned long max_delegations;
|
2006-04-11 09:55:41 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Open owner state (share locks)
|
|
|
|
*/
|
|
|
|
|
2011-11-08 02:23:30 +04:00
|
|
|
/* hash tables for lock and open owners */
|
|
|
|
#define OWNER_HASH_BITS 8
|
|
|
|
#define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS)
|
|
|
|
#define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1)
|
2006-04-11 09:55:41 +04:00
|
|
|
|
2014-07-30 05:34:36 +04:00
|
|
|
static unsigned int ownerstr_hashval(struct xdr_netobj *ownername)
|
2011-07-31 07:46:29 +04:00
|
|
|
{
|
|
|
|
unsigned int ret;
|
|
|
|
|
|
|
|
ret = opaque_hashval(ownername->data, ownername->len);
|
2011-11-08 02:23:30 +04:00
|
|
|
return ret & OWNER_HASH_MASK;
|
2011-07-31 07:46:29 +04:00
|
|
|
}
|
2006-04-11 09:55:41 +04:00
|
|
|
|
|
|
|
/* hash table for nfs4_file */
|
|
|
|
#define FILE_HASH_BITS 8
|
|
|
|
#define FILE_HASH_SIZE (1 << FILE_HASH_BITS)
|
2011-01-14 12:35:59 +03:00
|
|
|
|
2021-04-16 21:00:15 +03:00
|
|
|
static unsigned int file_hashval(struct svc_fh *fh)
|
2011-07-31 07:46:29 +04:00
|
|
|
{
|
2021-04-16 21:00:15 +03:00
|
|
|
struct inode *inode = d_inode(fh->fh_dentry);
|
2014-07-24 00:17:39 +04:00
|
|
|
|
2021-04-16 21:00:15 +03:00
|
|
|
/* XXX: why not (here & in file cache) use inode? */
|
|
|
|
return (unsigned int)hash_long(inode->i_ino, FILE_HASH_BITS);
|
2014-07-24 00:17:39 +04:00
|
|
|
}
|
|
|
|
|
2013-04-02 17:01:59 +04:00
|
|
|
static struct hlist_head file_hashtbl[FILE_HASH_SIZE];
|
2006-04-11 09:55:41 +04:00
|
|
|
|
2014-07-10 22:07:28 +04:00
|
|
|
static void
|
|
|
|
__nfs4_file_get_access(struct nfs4_file *fp, u32 access)
|
2013-08-24 01:55:18 +04:00
|
|
|
{
|
2014-07-10 22:07:33 +04:00
|
|
|
lockdep_assert_held(&fp->fi_lock);
|
|
|
|
|
2014-07-10 22:07:28 +04:00
|
|
|
if (access & NFS4_SHARE_ACCESS_WRITE)
|
|
|
|
atomic_inc(&fp->fi_access[O_WRONLY]);
|
|
|
|
if (access & NFS4_SHARE_ACCESS_READ)
|
|
|
|
atomic_inc(&fp->fi_access[O_RDONLY]);
|
2013-08-24 01:55:18 +04:00
|
|
|
}
|
|
|
|
|
2014-07-10 22:07:28 +04:00
|
|
|
static __be32
|
|
|
|
nfs4_file_get_access(struct nfs4_file *fp, u32 access)
|
2010-08-07 17:21:41 +04:00
|
|
|
{
|
2014-07-10 22:07:33 +04:00
|
|
|
lockdep_assert_held(&fp->fi_lock);
|
|
|
|
|
2014-07-10 22:07:28 +04:00
|
|
|
/* Does this access mode make sense? */
|
|
|
|
if (access & ~NFS4_SHARE_ACCESS_BOTH)
|
|
|
|
return nfserr_inval;
|
|
|
|
|
nfsd: make deny mode enforcement more efficient and close races in it
The current enforcement of deny modes is both inefficient and scattered
across several places, which makes it hard to guarantee atomicity. The
inefficiency is a problem now, and the lack of atomicity will mean races
once the client_mutex is removed.
First, we address the inefficiency. We have to track deny modes on a
per-stateid basis to ensure that open downgrades are sane, but when the
server goes to enforce them it has to walk the entire list of stateids
and check against each one.
Instead of doing that, maintain a per-nfs4_file deny mode. When a file
is opened, we simply set any deny bits in that mode that were specified
in the OPEN call. We can then use that unified deny mode to do a simple
check to see whether there are any conflicts without needing to walk the
entire stateid list.
The only time we'll need to walk the entire list of stateids is when a
stateid that has a deny mode on it is being released, or one is having
its deny mode downgraded. In that case, we must walk the entire list and
recalculate the fi_share_deny field. Since deny modes are pretty rare
today, this should be very rare under normal workloads.
To address the potential for races once the client_mutex is removed,
protect fi_share_deny with the fi_lock. In nfs4_get_vfs_file, check to
make sure that any deny mode we want to apply won't conflict with
existing access. If that's ok, then have nfs4_file_get_access check that
new access to the file won't conflict with existing deny modes.
If that also passes, then get file access references, set the correct
access and deny bits in the stateid, and update the fi_share_deny field.
If opening the file or truncating it fails, then unwind the whole mess
and return the appropriate error.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-10 22:07:34 +04:00
|
|
|
/* Does it conflict with a deny mode already set? */
|
|
|
|
if ((access & fp->fi_share_deny) != 0)
|
|
|
|
return nfserr_share_denied;
|
|
|
|
|
2014-07-10 22:07:28 +04:00
|
|
|
__nfs4_file_get_access(fp, access);
|
|
|
|
return nfs_ok;
|
2010-08-07 17:21:41 +04:00
|
|
|
}
|
|
|
|
|
nfsd: make deny mode enforcement more efficient and close races in it
The current enforcement of deny modes is both inefficient and scattered
across several places, which makes it hard to guarantee atomicity. The
inefficiency is a problem now, and the lack of atomicity will mean races
once the client_mutex is removed.
First, we address the inefficiency. We have to track deny modes on a
per-stateid basis to ensure that open downgrades are sane, but when the
server goes to enforce them it has to walk the entire list of stateids
and check against each one.
Instead of doing that, maintain a per-nfs4_file deny mode. When a file
is opened, we simply set any deny bits in that mode that were specified
in the OPEN call. We can then use that unified deny mode to do a simple
check to see whether there are any conflicts without needing to walk the
entire stateid list.
The only time we'll need to walk the entire list of stateids is when a
stateid that has a deny mode on it is being released, or one is having
its deny mode downgraded. In that case, we must walk the entire list and
recalculate the fi_share_deny field. Since deny modes are pretty rare
today, this should be very rare under normal workloads.
To address the potential for races once the client_mutex is removed,
protect fi_share_deny with the fi_lock. In nfs4_get_vfs_file, check to
make sure that any deny mode we want to apply won't conflict with
existing access. If that's ok, then have nfs4_file_get_access check that
new access to the file won't conflict with existing deny modes.
If that also passes, then get file access references, set the correct
access and deny bits in the stateid, and update the fi_share_deny field.
If opening the file or truncating it fails, then unwind the whole mess
and return the appropriate error.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-10 22:07:34 +04:00
|
|
|
static __be32 nfs4_file_check_deny(struct nfs4_file *fp, u32 deny)
|
|
|
|
{
|
|
|
|
/* Common case is that there is no deny mode. */
|
|
|
|
if (deny) {
|
|
|
|
/* Does this deny mode make sense? */
|
|
|
|
if (deny & ~NFS4_SHARE_DENY_BOTH)
|
|
|
|
return nfserr_inval;
|
|
|
|
|
|
|
|
if ((deny & NFS4_SHARE_DENY_READ) &&
|
|
|
|
atomic_read(&fp->fi_access[O_RDONLY]))
|
|
|
|
return nfserr_share_denied;
|
|
|
|
|
|
|
|
if ((deny & NFS4_SHARE_DENY_WRITE) &&
|
|
|
|
atomic_read(&fp->fi_access[O_WRONLY]))
|
|
|
|
return nfserr_share_denied;
|
|
|
|
}
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2010-08-07 17:21:41 +04:00
|
|
|
static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
|
2010-07-08 19:02:09 +04:00
|
|
|
{
|
2014-07-10 22:07:26 +04:00
|
|
|
might_lock(&fp->fi_lock);
|
|
|
|
|
|
|
|
if (atomic_dec_and_lock(&fp->fi_access[oflag], &fp->fi_lock)) {
|
2019-08-18 21:18:52 +03:00
|
|
|
struct nfsd_file *f1 = NULL;
|
|
|
|
struct nfsd_file *f2 = NULL;
|
2014-07-10 22:07:26 +04:00
|
|
|
|
2014-07-10 22:07:29 +04:00
|
|
|
swap(f1, fp->fi_fds[oflag]);
|
2013-03-29 04:37:14 +04:00
|
|
|
if (atomic_read(&fp->fi_access[1 - oflag]) == 0)
|
2014-07-10 22:07:29 +04:00
|
|
|
swap(f2, fp->fi_fds[O_RDWR]);
|
2014-07-10 22:07:26 +04:00
|
|
|
spin_unlock(&fp->fi_lock);
|
|
|
|
if (f1)
|
2019-08-18 21:18:52 +03:00
|
|
|
nfsd_file_put(f1);
|
2014-07-10 22:07:26 +04:00
|
|
|
if (f2)
|
2019-08-18 21:18:52 +03:00
|
|
|
nfsd_file_put(f2);
|
2010-07-08 19:02:09 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-10 22:07:28 +04:00
|
|
|
static void nfs4_file_put_access(struct nfs4_file *fp, u32 access)
|
2010-08-07 17:21:41 +04:00
|
|
|
{
|
2014-07-10 22:07:28 +04:00
|
|
|
WARN_ON_ONCE(access & ~NFS4_SHARE_ACCESS_BOTH);
|
|
|
|
|
|
|
|
if (access & NFS4_SHARE_ACCESS_WRITE)
|
2010-08-07 17:21:41 +04:00
|
|
|
__nfs4_file_put_access(fp, O_WRONLY);
|
2014-07-10 22:07:28 +04:00
|
|
|
if (access & NFS4_SHARE_ACCESS_READ)
|
|
|
|
__nfs4_file_put_access(fp, O_RDONLY);
|
2010-08-07 17:21:41 +04:00
|
|
|
}
|
|
|
|
|
2015-04-27 15:50:14 +03:00
|
|
|
/*
|
|
|
|
* Allocate a new open/delegation state counter. This is needed for
|
|
|
|
* pNFS for proper return on close semantics.
|
|
|
|
*
|
|
|
|
* Note that we only allocate it for pNFS-enabled exports, otherwise
|
|
|
|
* all pointers to struct nfs4_clnt_odstate are always NULL.
|
|
|
|
*/
|
|
|
|
static struct nfs4_clnt_odstate *
|
|
|
|
alloc_clnt_odstate(struct nfs4_client *clp)
|
|
|
|
{
|
|
|
|
struct nfs4_clnt_odstate *co;
|
|
|
|
|
|
|
|
co = kmem_cache_zalloc(odstate_slab, GFP_KERNEL);
|
|
|
|
if (co) {
|
|
|
|
co->co_client = clp;
|
2017-10-20 12:53:29 +03:00
|
|
|
refcount_set(&co->co_odcount, 1);
|
2015-04-27 15:50:14 +03:00
|
|
|
}
|
|
|
|
return co;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
hash_clnt_odstate_locked(struct nfs4_clnt_odstate *co)
|
|
|
|
{
|
|
|
|
struct nfs4_file *fp = co->co_file;
|
|
|
|
|
|
|
|
lockdep_assert_held(&fp->fi_lock);
|
|
|
|
list_add(&co->co_perfile, &fp->fi_clnt_odstate);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
get_clnt_odstate(struct nfs4_clnt_odstate *co)
|
|
|
|
{
|
|
|
|
if (co)
|
2017-10-20 12:53:29 +03:00
|
|
|
refcount_inc(&co->co_odcount);
|
2015-04-27 15:50:14 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
put_clnt_odstate(struct nfs4_clnt_odstate *co)
|
|
|
|
{
|
|
|
|
struct nfs4_file *fp;
|
|
|
|
|
|
|
|
if (!co)
|
|
|
|
return;
|
|
|
|
|
|
|
|
fp = co->co_file;
|
2017-10-20 12:53:29 +03:00
|
|
|
if (refcount_dec_and_lock(&co->co_odcount, &fp->fi_lock)) {
|
2015-04-27 15:50:14 +03:00
|
|
|
list_del(&co->co_perfile);
|
|
|
|
spin_unlock(&fp->fi_lock);
|
|
|
|
|
|
|
|
nfsd4_return_all_file_layouts(co->co_client, fp);
|
|
|
|
kmem_cache_free(odstate_slab, co);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct nfs4_clnt_odstate *
|
|
|
|
find_or_hash_clnt_odstate(struct nfs4_file *fp, struct nfs4_clnt_odstate *new)
|
|
|
|
{
|
|
|
|
struct nfs4_clnt_odstate *co;
|
|
|
|
struct nfs4_client *cl;
|
|
|
|
|
|
|
|
if (!new)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
cl = new->co_client;
|
|
|
|
|
|
|
|
spin_lock(&fp->fi_lock);
|
|
|
|
list_for_each_entry(co, &fp->fi_clnt_odstate, co_perfile) {
|
|
|
|
if (co->co_client == cl) {
|
|
|
|
get_clnt_odstate(co);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
co = new;
|
|
|
|
co->co_file = fp;
|
|
|
|
hash_clnt_odstate_locked(new);
|
|
|
|
out:
|
|
|
|
spin_unlock(&fp->fi_lock);
|
|
|
|
return co;
|
|
|
|
}
|
|
|
|
|
2017-01-18 14:04:42 +03:00
|
|
|
struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct kmem_cache *slab,
|
|
|
|
void (*sc_free)(struct nfs4_stid *))
|
2011-09-24 01:20:02 +04:00
|
|
|
{
|
2013-02-03 21:23:01 +04:00
|
|
|
struct nfs4_stid *stid;
|
2011-09-24 00:21:15 +04:00
|
|
|
int new_id;
|
2011-09-24 01:20:02 +04:00
|
|
|
|
2014-07-25 15:34:19 +04:00
|
|
|
stid = kmem_cache_zalloc(slab, GFP_KERNEL);
|
2013-02-03 21:23:01 +04:00
|
|
|
if (!stid)
|
|
|
|
return NULL;
|
|
|
|
|
2014-07-30 05:34:10 +04:00
|
|
|
idr_preload(GFP_KERNEL);
|
|
|
|
spin_lock(&cl->cl_lock);
|
2019-04-22 22:26:23 +03:00
|
|
|
/* Reserving 0 for start of file in nfsdfs "states" file: */
|
|
|
|
new_id = idr_alloc_cyclic(&cl->cl_stateids, stid, 1, 0, GFP_NOWAIT);
|
2014-07-30 05:34:10 +04:00
|
|
|
spin_unlock(&cl->cl_lock);
|
|
|
|
idr_preload_end();
|
2013-03-14 01:59:37 +04:00
|
|
|
if (new_id < 0)
|
2013-02-03 21:23:01 +04:00
|
|
|
goto out_free;
|
2017-01-18 14:04:42 +03:00
|
|
|
|
|
|
|
stid->sc_free = sc_free;
|
2011-09-24 01:20:02 +04:00
|
|
|
stid->sc_client = cl;
|
2013-02-03 21:23:01 +04:00
|
|
|
stid->sc_stateid.si_opaque.so_id = new_id;
|
|
|
|
stid->sc_stateid.si_opaque.so_clid = cl->cl_clientid;
|
2011-09-24 01:20:02 +04:00
|
|
|
/* Will be incremented before return to client: */
|
2017-10-20 12:53:28 +03:00
|
|
|
refcount_set(&stid->sc_count, 1);
|
2015-10-01 16:05:50 +03:00
|
|
|
spin_lock_init(&stid->sc_lock);
|
2019-10-04 23:34:26 +03:00
|
|
|
INIT_LIST_HEAD(&stid->sc_cp_list);
|
2011-10-17 19:14:48 +04:00
|
|
|
|
|
|
|
/*
|
2013-02-03 21:23:01 +04:00
|
|
|
* It shouldn't be a problem to reuse an opaque stateid value.
|
|
|
|
* I don't think it is for 4.1. But with 4.0 I worry that, for
|
|
|
|
* example, a stray write retransmission could be accepted by
|
|
|
|
* the server when it should have been rejected. Therefore,
|
|
|
|
* adopt a trick from the sctp code to attempt to maximize the
|
|
|
|
* amount of time until an id is reused, by ensuring they always
|
|
|
|
* "increase" (mod INT_MAX):
|
2011-10-17 19:14:48 +04:00
|
|
|
*/
|
2013-02-03 21:23:01 +04:00
|
|
|
return stid;
|
|
|
|
out_free:
|
2013-04-09 10:15:31 +04:00
|
|
|
kmem_cache_free(slab, stid);
|
2013-02-03 21:23:01 +04:00
|
|
|
return NULL;
|
2011-09-24 01:20:02 +04:00
|
|
|
}
|
|
|
|
|
2018-07-21 01:19:20 +03:00
|
|
|
/*
|
|
|
|
* Create a unique stateid_t to represent each COPY.
|
|
|
|
*/
|
2019-10-04 23:34:26 +03:00
|
|
|
static int nfs4_init_cp_state(struct nfsd_net *nn, copy_stateid_t *stid,
|
|
|
|
unsigned char sc_type)
|
2018-07-21 01:19:20 +03:00
|
|
|
{
|
|
|
|
int new_id;
|
|
|
|
|
2019-10-31 17:53:13 +03:00
|
|
|
stid->stid.si_opaque.so_clid.cl_boot = (u32)nn->boot_time;
|
2019-10-04 23:34:26 +03:00
|
|
|
stid->stid.si_opaque.so_clid.cl_id = nn->s2s_cp_cl_id;
|
|
|
|
stid->sc_type = sc_type;
|
|
|
|
|
2018-07-21 01:19:20 +03:00
|
|
|
idr_preload(GFP_KERNEL);
|
|
|
|
spin_lock(&nn->s2s_cp_lock);
|
2019-10-04 23:34:26 +03:00
|
|
|
new_id = idr_alloc_cyclic(&nn->s2s_cp_stateids, stid, 0, 0, GFP_NOWAIT);
|
|
|
|
stid->stid.si_opaque.so_id = new_id;
|
2020-12-01 00:24:49 +03:00
|
|
|
stid->stid.si_generation = 1;
|
2018-07-21 01:19:20 +03:00
|
|
|
spin_unlock(&nn->s2s_cp_lock);
|
|
|
|
idr_preload_end();
|
|
|
|
if (new_id < 0)
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2019-10-04 23:34:26 +03:00
|
|
|
int nfs4_init_copy_state(struct nfsd_net *nn, struct nfsd4_copy *copy)
|
|
|
|
{
|
|
|
|
return nfs4_init_cp_state(nn, ©->cp_stateid, NFS4_COPY_STID);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct nfs4_cpntf_state *nfs4_alloc_init_cpntf_state(struct nfsd_net *nn,
|
|
|
|
struct nfs4_stid *p_stid)
|
|
|
|
{
|
|
|
|
struct nfs4_cpntf_state *cps;
|
|
|
|
|
|
|
|
cps = kzalloc(sizeof(struct nfs4_cpntf_state), GFP_KERNEL);
|
|
|
|
if (!cps)
|
|
|
|
return NULL;
|
2019-11-04 18:31:52 +03:00
|
|
|
cps->cpntf_time = ktime_get_boottime_seconds();
|
2019-10-04 23:34:26 +03:00
|
|
|
refcount_set(&cps->cp_stateid.sc_count, 1);
|
|
|
|
if (!nfs4_init_cp_state(nn, &cps->cp_stateid, NFS4_COPYNOTIFY_STID))
|
|
|
|
goto out_free;
|
|
|
|
spin_lock(&nn->s2s_cp_lock);
|
|
|
|
list_add(&cps->cp_list, &p_stid->sc_cp_list);
|
|
|
|
spin_unlock(&nn->s2s_cp_lock);
|
|
|
|
return cps;
|
|
|
|
out_free:
|
|
|
|
kfree(cps);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void nfs4_free_copy_state(struct nfsd4_copy *copy)
|
2018-07-21 01:19:20 +03:00
|
|
|
{
|
|
|
|
struct nfsd_net *nn;
|
|
|
|
|
2019-10-04 23:34:26 +03:00
|
|
|
WARN_ON_ONCE(copy->cp_stateid.sc_type != NFS4_COPY_STID);
|
2018-07-21 01:19:20 +03:00
|
|
|
nn = net_generic(copy->cp_clp->net, nfsd_net_id);
|
|
|
|
spin_lock(&nn->s2s_cp_lock);
|
2019-10-04 23:34:26 +03:00
|
|
|
idr_remove(&nn->s2s_cp_stateids,
|
|
|
|
copy->cp_stateid.stid.si_opaque.so_id);
|
|
|
|
spin_unlock(&nn->s2s_cp_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nfs4_free_cpntf_statelist(struct net *net, struct nfs4_stid *stid)
|
|
|
|
{
|
|
|
|
struct nfs4_cpntf_state *cps;
|
|
|
|
struct nfsd_net *nn;
|
|
|
|
|
|
|
|
nn = net_generic(net, nfsd_net_id);
|
|
|
|
spin_lock(&nn->s2s_cp_lock);
|
|
|
|
while (!list_empty(&stid->sc_cp_list)) {
|
|
|
|
cps = list_first_entry(&stid->sc_cp_list,
|
|
|
|
struct nfs4_cpntf_state, cp_list);
|
|
|
|
_free_cpntf_state_locked(nn, cps);
|
|
|
|
}
|
2018-07-21 01:19:20 +03:00
|
|
|
spin_unlock(&nn->s2s_cp_lock);
|
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:11 +04:00
|
|
|
static struct nfs4_ol_stateid * nfs4_alloc_open_stateid(struct nfs4_client *clp)
|
2011-10-17 23:57:47 +04:00
|
|
|
{
|
2014-07-30 05:34:06 +04:00
|
|
|
struct nfs4_stid *stid;
|
|
|
|
|
2017-01-18 14:04:42 +03:00
|
|
|
stid = nfs4_alloc_stid(clp, stateid_slab, nfs4_free_ol_stateid);
|
2014-07-30 05:34:06 +04:00
|
|
|
if (!stid)
|
|
|
|
return NULL;
|
|
|
|
|
2017-01-18 14:04:42 +03:00
|
|
|
return openlockstateid(stid);
|
2014-07-30 05:34:06 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void nfs4_free_deleg(struct nfs4_stid *stid)
|
|
|
|
{
|
|
|
|
kmem_cache_free(deleg_slab, stid);
|
|
|
|
atomic_long_dec(&num_delegations);
|
2011-10-17 23:57:47 +04:00
|
|
|
}
|
|
|
|
|
NFSD: Don't hand out delegations for 30 seconds after recalling them.
If nfsd needs to recall a delegation for some reason it implies that there is
contention on the file, so further delegations should not be handed out.
The current code fails to do so, and the result is effectively a
live-lock under some workloads: a client attempting a conflicting
operation on a read-delegated file receives NFS4ERR_DELAY and retries
the operation, but by the time it retries the server may already have
given out another delegation.
We could simply avoid delegations for (say) 30 seconds after any recall, but
this is probably too heavy handed.
We could keep a list of inodes (or inode numbers or filehandles) for recalled
delegations, but that requires memory allocation and searching.
The approach taken here is to use a bloom filter to record the filehandles
which are currently blocked from delegation, and to accept the cost of a few
false positives.
We have 2 bloom filters, each of which is valid for 30 seconds. When a
delegation is recalled the filehandle is added to one filter and will remain
disabled for between 30 and 60 seconds.
We keep a count of the number of filehandles that have been added, so when
that count is zero we can bypass all other tests.
The bloom filters have 256 bits and 3 hash functions. This should allow a
couple of dozen blocked filehandles with minimal false positives. If many
more filehandles are all blocked at once, behaviour will degrade towards
rejecting all delegations for between 30 and 60 seconds, then resetting and
allowing new delegations.
Signed-off-by: NeilBrown <neilb@suse.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-06-04 11:39:26 +04:00
|
|
|
/*
|
|
|
|
* When we recall a delegation, we should be careful not to hand it
|
|
|
|
* out again straight away.
|
|
|
|
* To ensure this we keep a pair of bloom filters ('new' and 'old')
|
|
|
|
* in which the filehandles of recalled delegations are "stored".
|
|
|
|
* If a filehandle appear in either filter, a delegation is blocked.
|
|
|
|
* When a delegation is recalled, the filehandle is stored in the "new"
|
|
|
|
* filter.
|
|
|
|
* Every 30 seconds we swap the filters and clear the "new" one,
|
|
|
|
* unless both are empty of course.
|
|
|
|
*
|
|
|
|
* Each filter is 256 bits. We hash the filehandle to 32bit and use the
|
|
|
|
* low 3 bytes as hash-table indices.
|
|
|
|
*
|
2014-07-25 15:34:26 +04:00
|
|
|
* 'blocked_delegations_lock', which is always taken in block_delegations(),
|
NFSD: Don't hand out delegations for 30 seconds after recalling them.
If nfsd needs to recall a delegation for some reason it implies that there is
contention on the file, so further delegations should not be handed out.
The current code fails to do so, and the result is effectively a
live-lock under some workloads: a client attempting a conflicting
operation on a read-delegated file receives NFS4ERR_DELAY and retries
the operation, but by the time it retries the server may already have
given out another delegation.
We could simply avoid delegations for (say) 30 seconds after any recall, but
this is probably too heavy handed.
We could keep a list of inodes (or inode numbers or filehandles) for recalled
delegations, but that requires memory allocation and searching.
The approach taken here is to use a bloom filter to record the filehandles
which are currently blocked from delegation, and to accept the cost of a few
false positives.
We have 2 bloom filters, each of which is valid for 30 seconds. When a
delegation is recalled the filehandle is added to one filter and will remain
disabled for between 30 and 60 seconds.
We keep a count of the number of filehandles that have been added, so when
that count is zero we can bypass all other tests.
The bloom filters have 256 bits and 3 hash functions. This should allow a
couple of dozen blocked filehandles with minimal false positives. If many
more filehandles are all blocked at once, behaviour will degrade towards
rejecting all delegations for between 30 and 60 seconds, then resetting and
allowing new delegations.
Signed-off-by: NeilBrown <neilb@suse.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-06-04 11:39:26 +04:00
|
|
|
* is used to manage concurrent access. Testing does not need the lock
|
|
|
|
* except when swapping the two filters.
|
|
|
|
*/
|
2014-07-25 15:34:26 +04:00
|
|
|
static DEFINE_SPINLOCK(blocked_delegations_lock);
|
NFSD: Don't hand out delegations for 30 seconds after recalling them.
If nfsd needs to recall a delegation for some reason it implies that there is
contention on the file, so further delegations should not be handed out.
The current code fails to do so, and the result is effectively a
live-lock under some workloads: a client attempting a conflicting
operation on a read-delegated file receives NFS4ERR_DELAY and retries
the operation, but by the time it retries the server may already have
given out another delegation.
We could simply avoid delegations for (say) 30 seconds after any recall, but
this is probably too heavy handed.
We could keep a list of inodes (or inode numbers or filehandles) for recalled
delegations, but that requires memory allocation and searching.
The approach taken here is to use a bloom filter to record the filehandles
which are currently blocked from delegation, and to accept the cost of a few
false positives.
We have 2 bloom filters, each of which is valid for 30 seconds. When a
delegation is recalled the filehandle is added to one filter and will remain
disabled for between 30 and 60 seconds.
We keep a count of the number of filehandles that have been added, so when
that count is zero we can bypass all other tests.
The bloom filters have 256 bits and 3 hash functions. This should allow a
couple of dozen blocked filehandles with minimal false positives. If many
more filehandles are all blocked at once, behaviour will degrade towards
rejecting all delegations for between 30 and 60 seconds, then resetting and
allowing new delegations.
Signed-off-by: NeilBrown <neilb@suse.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-06-04 11:39:26 +04:00
|
|
|
static struct bloom_pair {
|
|
|
|
int entries, old_entries;
|
2017-10-20 12:25:34 +03:00
|
|
|
time64_t swap_time;
|
NFSD: Don't hand out delegations for 30 seconds after recalling them.
If nfsd needs to recall a delegation for some reason it implies that there is
contention on the file, so further delegations should not be handed out.
The current code fails to do so, and the result is effectively a
live-lock under some workloads: a client attempting a conflicting
operation on a read-delegated file receives NFS4ERR_DELAY and retries
the operation, but by the time it retries the server may already have
given out another delegation.
We could simply avoid delegations for (say) 30 seconds after any recall, but
this is probably too heavy handed.
We could keep a list of inodes (or inode numbers or filehandles) for recalled
delegations, but that requires memory allocation and searching.
The approach taken here is to use a bloom filter to record the filehandles
which are currently blocked from delegation, and to accept the cost of a few
false positives.
We have 2 bloom filters, each of which is valid for 30 seconds. When a
delegation is recalled the filehandle is added to one filter and will remain
disabled for between 30 and 60 seconds.
We keep a count of the number of filehandles that have been added, so when
that count is zero we can bypass all other tests.
The bloom filters have 256 bits and 3 hash functions. This should allow a
couple of dozen blocked filehandles with minimal false positives. If many
more filehandles are all blocked at once, behaviour will degrade towards
rejecting all delegations for between 30 and 60 seconds, then resetting and
allowing new delegations.
Signed-off-by: NeilBrown <neilb@suse.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-06-04 11:39:26 +04:00
|
|
|
int new; /* index into 'set' */
|
|
|
|
DECLARE_BITMAP(set[2], 256);
|
|
|
|
} blocked_delegations;
|
|
|
|
|
|
|
|
static int delegation_blocked(struct knfsd_fh *fh)
|
|
|
|
{
|
|
|
|
u32 hash;
|
|
|
|
struct bloom_pair *bd = &blocked_delegations;
|
|
|
|
|
|
|
|
if (bd->entries == 0)
|
|
|
|
return 0;
|
2017-10-20 12:25:34 +03:00
|
|
|
if (ktime_get_seconds() - bd->swap_time > 30) {
|
2014-07-25 15:34:26 +04:00
|
|
|
spin_lock(&blocked_delegations_lock);
|
2017-10-20 12:25:34 +03:00
|
|
|
if (ktime_get_seconds() - bd->swap_time > 30) {
|
NFSD: Don't hand out delegations for 30 seconds after recalling them.
If nfsd needs to recall a delegation for some reason it implies that there is
contention on the file, so further delegations should not be handed out.
The current code fails to do so, and the result is effectively a
live-lock under some workloads: a client attempting a conflicting
operation on a read-delegated file receives NFS4ERR_DELAY and retries
the operation, but by the time it retries the server may already have
given out another delegation.
We could simply avoid delegations for (say) 30 seconds after any recall, but
this is probably too heavy handed.
We could keep a list of inodes (or inode numbers or filehandles) for recalled
delegations, but that requires memory allocation and searching.
The approach taken here is to use a bloom filter to record the filehandles
which are currently blocked from delegation, and to accept the cost of a few
false positives.
We have 2 bloom filters, each of which is valid for 30 seconds. When a
delegation is recalled the filehandle is added to one filter and will remain
disabled for between 30 and 60 seconds.
We keep a count of the number of filehandles that have been added, so when
that count is zero we can bypass all other tests.
The bloom filters have 256 bits and 3 hash functions. This should allow a
couple of dozen blocked filehandles with minimal false positives. If many
more filehandles are all blocked at once, behaviour will degrade towards
rejecting all delegations for between 30 and 60 seconds, then resetting and
allowing new delegations.
Signed-off-by: NeilBrown <neilb@suse.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-06-04 11:39:26 +04:00
|
|
|
bd->entries -= bd->old_entries;
|
|
|
|
bd->old_entries = bd->entries;
|
|
|
|
memset(bd->set[bd->new], 0,
|
|
|
|
sizeof(bd->set[0]));
|
|
|
|
bd->new = 1-bd->new;
|
2017-10-20 12:25:34 +03:00
|
|
|
bd->swap_time = ktime_get_seconds();
|
NFSD: Don't hand out delegations for 30 seconds after recalling them.
If nfsd needs to recall a delegation for some reason it implies that there is
contention on the file, so further delegations should not be handed out.
The current code fails to do so, and the result is effectively a
live-lock under some workloads: a client attempting a conflicting
operation on a read-delegated file receives NFS4ERR_DELAY and retries
the operation, but by the time it retries the server may already have
given out another delegation.
We could simply avoid delegations for (say) 30 seconds after any recall, but
this is probably too heavy handed.
We could keep a list of inodes (or inode numbers or filehandles) for recalled
delegations, but that requires memory allocation and searching.
The approach taken here is to use a bloom filter to record the filehandles
which are currently blocked from delegation, and to accept the cost of a few
false positives.
We have 2 bloom filters, each of which is valid for 30 seconds. When a
delegation is recalled the filehandle is added to one filter and will remain
disabled for between 30 and 60 seconds.
We keep a count of the number of filehandles that have been added, so when
that count is zero we can bypass all other tests.
The bloom filters have 256 bits and 3 hash functions. This should allow a
couple of dozen blocked filehandles with minimal false positives. If many
more filehandles are all blocked at once, behaviour will degrade towards
rejecting all delegations for between 30 and 60 seconds, then resetting and
allowing new delegations.
Signed-off-by: NeilBrown <neilb@suse.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-06-04 11:39:26 +04:00
|
|
|
}
|
2014-07-25 15:34:26 +04:00
|
|
|
spin_unlock(&blocked_delegations_lock);
|
NFSD: Don't hand out delegations for 30 seconds after recalling them.
If nfsd needs to recall a delegation for some reason it implies that there is
contention on the file, so further delegations should not be handed out.
The current code fails to do so, and the result is effectively a
live-lock under some workloads: a client attempting a conflicting
operation on a read-delegated file receives NFS4ERR_DELAY and retries
the operation, but by the time it retries the server may already have
given out another delegation.
We could simply avoid delegations for (say) 30 seconds after any recall, but
this is probably too heavy handed.
We could keep a list of inodes (or inode numbers or filehandles) for recalled
delegations, but that requires memory allocation and searching.
The approach taken here is to use a bloom filter to record the filehandles
which are currently blocked from delegation, and to accept the cost of a few
false positives.
We have 2 bloom filters, each of which is valid for 30 seconds. When a
delegation is recalled the filehandle is added to one filter and will remain
disabled for between 30 and 60 seconds.
We keep a count of the number of filehandles that have been added, so when
that count is zero we can bypass all other tests.
The bloom filters have 256 bits and 3 hash functions. This should allow a
couple of dozen blocked filehandles with minimal false positives. If many
more filehandles are all blocked at once, behaviour will degrade towards
rejecting all delegations for between 30 and 60 seconds, then resetting and
allowing new delegations.
Signed-off-by: NeilBrown <neilb@suse.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-06-04 11:39:26 +04:00
|
|
|
}
|
2014-12-10 18:33:11 +03:00
|
|
|
hash = jhash(&fh->fh_base, fh->fh_size, 0);
|
NFSD: Don't hand out delegations for 30 seconds after recalling them.
If nfsd needs to recall a delegation for some reason it implies that there is
contention on the file, so further delegations should not be handed out.
The current code fails to do so, and the result is effectively a
live-lock under some workloads: a client attempting a conflicting
operation on a read-delegated file receives NFS4ERR_DELAY and retries
the operation, but by the time it retries the server may already have
given out another delegation.
We could simply avoid delegations for (say) 30 seconds after any recall, but
this is probably too heavy handed.
We could keep a list of inodes (or inode numbers or filehandles) for recalled
delegations, but that requires memory allocation and searching.
The approach taken here is to use a bloom filter to record the filehandles
which are currently blocked from delegation, and to accept the cost of a few
false positives.
We have 2 bloom filters, each of which is valid for 30 seconds. When a
delegation is recalled the filehandle is added to one filter and will remain
disabled for between 30 and 60 seconds.
We keep a count of the number of filehandles that have been added, so when
that count is zero we can bypass all other tests.
The bloom filters have 256 bits and 3 hash functions. This should allow a
couple of dozen blocked filehandles with minimal false positives. If many
more filehandles are all blocked at once, behaviour will degrade towards
rejecting all delegations for between 30 and 60 seconds, then resetting and
allowing new delegations.
Signed-off-by: NeilBrown <neilb@suse.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-06-04 11:39:26 +04:00
|
|
|
if (test_bit(hash&255, bd->set[0]) &&
|
|
|
|
test_bit((hash>>8)&255, bd->set[0]) &&
|
|
|
|
test_bit((hash>>16)&255, bd->set[0]))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (test_bit(hash&255, bd->set[1]) &&
|
|
|
|
test_bit((hash>>8)&255, bd->set[1]) &&
|
|
|
|
test_bit((hash>>16)&255, bd->set[1]))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void block_delegations(struct knfsd_fh *fh)
|
|
|
|
{
|
|
|
|
u32 hash;
|
|
|
|
struct bloom_pair *bd = &blocked_delegations;
|
|
|
|
|
2014-12-10 18:33:11 +03:00
|
|
|
hash = jhash(&fh->fh_base, fh->fh_size, 0);
|
NFSD: Don't hand out delegations for 30 seconds after recalling them.
If nfsd needs to recall a delegation for some reason it implies that there is
contention on the file, so further delegations should not be handed out.
The current code fails to do so, and the result is effectively a
live-lock under some workloads: a client attempting a conflicting
operation on a read-delegated file receives NFS4ERR_DELAY and retries
the operation, but by the time it retries the server may already have
given out another delegation.
We could simply avoid delegations for (say) 30 seconds after any recall, but
this is probably too heavy handed.
We could keep a list of inodes (or inode numbers or filehandles) for recalled
delegations, but that requires memory allocation and searching.
The approach taken here is to use a bloom filter to record the filehandles
which are currently blocked from delegation, and to accept the cost of a few
false positives.
We have 2 bloom filters, each of which is valid for 30 seconds. When a
delegation is recalled the filehandle is added to one filter and will remain
disabled for between 30 and 60 seconds.
We keep a count of the number of filehandles that have been added, so when
that count is zero we can bypass all other tests.
The bloom filters have 256 bits and 3 hash functions. This should allow a
couple of dozen blocked filehandles with minimal false positives. If many
more filehandles are all blocked at once, behaviour will degrade towards
rejecting all delegations for between 30 and 60 seconds, then resetting and
allowing new delegations.
Signed-off-by: NeilBrown <neilb@suse.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-06-04 11:39:26 +04:00
|
|
|
|
2014-07-25 15:34:26 +04:00
|
|
|
spin_lock(&blocked_delegations_lock);
|
NFSD: Don't hand out delegations for 30 seconds after recalling them.
If nfsd needs to recall a delegation for some reason it implies that there is
contention on the file, so further delegations should not be handed out.
The current code fails to do so, and the result is effectively a
live-lock under some workloads: a client attempting a conflicting
operation on a read-delegated file receives NFS4ERR_DELAY and retries
the operation, but by the time it retries the server may already have
given out another delegation.
We could simply avoid delegations for (say) 30 seconds after any recall, but
this is probably too heavy handed.
We could keep a list of inodes (or inode numbers or filehandles) for recalled
delegations, but that requires memory allocation and searching.
The approach taken here is to use a bloom filter to record the filehandles
which are currently blocked from delegation, and to accept the cost of a few
false positives.
We have 2 bloom filters, each of which is valid for 30 seconds. When a
delegation is recalled the filehandle is added to one filter and will remain
disabled for between 30 and 60 seconds.
We keep a count of the number of filehandles that have been added, so when
that count is zero we can bypass all other tests.
The bloom filters have 256 bits and 3 hash functions. This should allow a
couple of dozen blocked filehandles with minimal false positives. If many
more filehandles are all blocked at once, behaviour will degrade towards
rejecting all delegations for between 30 and 60 seconds, then resetting and
allowing new delegations.
Signed-off-by: NeilBrown <neilb@suse.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-06-04 11:39:26 +04:00
|
|
|
__set_bit(hash&255, bd->set[bd->new]);
|
|
|
|
__set_bit((hash>>8)&255, bd->set[bd->new]);
|
|
|
|
__set_bit((hash>>16)&255, bd->set[bd->new]);
|
|
|
|
if (bd->entries == 0)
|
2017-10-20 12:25:34 +03:00
|
|
|
bd->swap_time = ktime_get_seconds();
|
NFSD: Don't hand out delegations for 30 seconds after recalling them.
If nfsd needs to recall a delegation for some reason it implies that there is
contention on the file, so further delegations should not be handed out.
The current code fails to do so, and the result is effectively a
live-lock under some workloads: a client attempting a conflicting
operation on a read-delegated file receives NFS4ERR_DELAY and retries
the operation, but by the time it retries the server may already have
given out another delegation.
We could simply avoid delegations for (say) 30 seconds after any recall, but
this is probably too heavy handed.
We could keep a list of inodes (or inode numbers or filehandles) for recalled
delegations, but that requires memory allocation and searching.
The approach taken here is to use a bloom filter to record the filehandles
which are currently blocked from delegation, and to accept the cost of a few
false positives.
We have 2 bloom filters, each of which is valid for 30 seconds. When a
delegation is recalled the filehandle is added to one filter and will remain
disabled for between 30 and 60 seconds.
We keep a count of the number of filehandles that have been added, so when
that count is zero we can bypass all other tests.
The bloom filters have 256 bits and 3 hash functions. This should allow a
couple of dozen blocked filehandles with minimal false positives. If many
more filehandles are all blocked at once, behaviour will degrade towards
rejecting all delegations for between 30 and 60 seconds, then resetting and
allowing new delegations.
Signed-off-by: NeilBrown <neilb@suse.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-06-04 11:39:26 +04:00
|
|
|
bd->entries += 1;
|
2014-07-25 15:34:26 +04:00
|
|
|
spin_unlock(&blocked_delegations_lock);
|
NFSD: Don't hand out delegations for 30 seconds after recalling them.
If nfsd needs to recall a delegation for some reason it implies that there is
contention on the file, so further delegations should not be handed out.
The current code fails to do so, and the result is effectively a
live-lock under some workloads: a client attempting a conflicting
operation on a read-delegated file receives NFS4ERR_DELAY and retries
the operation, but by the time it retries the server may already have
given out another delegation.
We could simply avoid delegations for (say) 30 seconds after any recall, but
this is probably too heavy handed.
We could keep a list of inodes (or inode numbers or filehandles) for recalled
delegations, but that requires memory allocation and searching.
The approach taken here is to use a bloom filter to record the filehandles
which are currently blocked from delegation, and to accept the cost of a few
false positives.
We have 2 bloom filters, each of which is valid for 30 seconds. When a
delegation is recalled the filehandle is added to one filter and will remain
disabled for between 30 and 60 seconds.
We keep a count of the number of filehandles that have been added, so when
that count is zero we can bypass all other tests.
The bloom filters have 256 bits and 3 hash functions. This should allow a
couple of dozen blocked filehandles with minimal false positives. If many
more filehandles are all blocked at once, behaviour will degrade towards
rejecting all delegations for between 30 and 60 seconds, then resetting and
allowing new delegations.
Signed-off-by: NeilBrown <neilb@suse.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-06-04 11:39:26 +04:00
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
static struct nfs4_delegation *
|
2018-02-21 23:27:28 +03:00
|
|
|
alloc_init_deleg(struct nfs4_client *clp, struct nfs4_file *fp,
|
|
|
|
struct svc_fh *current_fh,
|
2015-04-27 15:50:14 +03:00
|
|
|
struct nfs4_clnt_odstate *odstate)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
struct nfs4_delegation *dp;
|
2014-07-25 15:34:22 +04:00
|
|
|
long n;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
dprintk("NFSD alloc_init_deleg\n");
|
2014-07-25 15:34:22 +04:00
|
|
|
n = atomic_long_inc_return(&num_delegations);
|
|
|
|
if (n < 0 || n > max_delegations)
|
|
|
|
goto out_dec;
|
NFSD: Don't hand out delegations for 30 seconds after recalling them.
If nfsd needs to recall a delegation for some reason it implies that there is
contention on the file, so further delegations should not be handed out.
The current code fails to do so, and the result is effectively a
live-lock under some workloads: a client attempting a conflicting
operation on a read-delegated file receives NFS4ERR_DELAY and retries
the operation, but by the time it retries the server may already have
given out another delegation.
We could simply avoid delegations for (say) 30 seconds after any recall, but
this is probably too heavy handed.
We could keep a list of inodes (or inode numbers or filehandles) for recalled
delegations, but that requires memory allocation and searching.
The approach taken here is to use a bloom filter to record the filehandles
which are currently blocked from delegation, and to accept the cost of a few
false positives.
We have 2 bloom filters, each of which is valid for 30 seconds. When a
delegation is recalled the filehandle is added to one filter and will remain
disabled for between 30 and 60 seconds.
We keep a count of the number of filehandles that have been added, so when
that count is zero we can bypass all other tests.
The bloom filters have 256 bits and 3 hash functions. This should allow a
couple of dozen blocked filehandles with minimal false positives. If many
more filehandles are all blocked at once, behaviour will degrade towards
rejecting all delegations for between 30 and 60 seconds, then resetting and
allowing new delegations.
Signed-off-by: NeilBrown <neilb@suse.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-06-04 11:39:26 +04:00
|
|
|
if (delegation_blocked(¤t_fh->fh_handle))
|
2014-07-25 15:34:22 +04:00
|
|
|
goto out_dec;
|
2017-01-18 14:04:42 +03:00
|
|
|
dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab, nfs4_free_deleg));
|
2005-06-24 09:03:04 +04:00
|
|
|
if (dp == NULL)
|
2014-07-25 15:34:22 +04:00
|
|
|
goto out_dec;
|
2014-07-30 05:34:06 +04:00
|
|
|
|
2011-09-24 01:20:02 +04:00
|
|
|
/*
|
|
|
|
* delegation seqid's are never incremented. The 4.1 special
|
2011-09-24 00:21:15 +04:00
|
|
|
* meaning of seqid 0 isn't meaningful, really, but let's avoid
|
|
|
|
* 0 anyway just for consistency and use 1:
|
2011-09-24 01:20:02 +04:00
|
|
|
*/
|
|
|
|
dp->dl_stid.sc_stateid.si_generation = 1;
|
2005-06-24 09:04:17 +04:00
|
|
|
INIT_LIST_HEAD(&dp->dl_perfile);
|
|
|
|
INIT_LIST_HEAD(&dp->dl_perclnt);
|
2005-04-17 02:20:36 +04:00
|
|
|
INIT_LIST_HEAD(&dp->dl_recall_lru);
|
2015-04-27 15:50:14 +03:00
|
|
|
dp->dl_clnt_odstate = odstate;
|
|
|
|
get_clnt_odstate(odstate);
|
2013-05-22 00:21:25 +04:00
|
|
|
dp->dl_type = NFS4_OPEN_DELEGATE_READ;
|
2014-09-24 14:19:18 +04:00
|
|
|
dp->dl_retries = 1;
|
|
|
|
nfsd4_init_cb(&dp->dl_recall, dp->dl_stid.sc_client,
|
2014-09-24 14:19:19 +04:00
|
|
|
&nfsd4_cb_recall_ops, NFSPROC4_CLNT_CB_RECALL);
|
2018-02-21 23:27:28 +03:00
|
|
|
get_nfs4_file(fp);
|
|
|
|
dp->dl_stid.sc_file = fp;
|
2005-04-17 02:20:36 +04:00
|
|
|
return dp;
|
2014-07-25 15:34:22 +04:00
|
|
|
out_dec:
|
|
|
|
atomic_long_dec(&num_delegations);
|
|
|
|
return NULL;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2014-07-30 05:34:06 +04:00
|
|
|
nfs4_put_stid(struct nfs4_stid *s)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2014-07-30 05:34:08 +04:00
|
|
|
struct nfs4_file *fp = s->sc_file;
|
2014-07-30 05:34:06 +04:00
|
|
|
struct nfs4_client *clp = s->sc_client;
|
|
|
|
|
2014-07-30 05:34:10 +04:00
|
|
|
might_lock(&clp->cl_lock);
|
|
|
|
|
2017-10-20 12:53:28 +03:00
|
|
|
if (!refcount_dec_and_lock(&s->sc_count, &clp->cl_lock)) {
|
2014-07-30 05:34:33 +04:00
|
|
|
wake_up_all(&close_wq);
|
2014-07-30 05:34:06 +04:00
|
|
|
return;
|
2014-07-30 05:34:33 +04:00
|
|
|
}
|
2014-07-30 05:34:06 +04:00
|
|
|
idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id);
|
2019-10-04 23:34:26 +03:00
|
|
|
nfs4_free_cpntf_statelist(clp->net, s);
|
2014-07-30 05:34:10 +04:00
|
|
|
spin_unlock(&clp->cl_lock);
|
2014-07-30 05:34:06 +04:00
|
|
|
s->sc_free(s);
|
2014-07-30 05:34:08 +04:00
|
|
|
if (fp)
|
|
|
|
put_nfs4_file(fp);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2015-10-01 16:05:50 +03:00
|
|
|
void
|
|
|
|
nfs4_inc_and_copy_stateid(stateid_t *dst, struct nfs4_stid *stid)
|
|
|
|
{
|
|
|
|
stateid_t *src = &stid->sc_stateid;
|
|
|
|
|
|
|
|
spin_lock(&stid->sc_lock);
|
|
|
|
if (unlikely(++src->si_generation == 0))
|
|
|
|
src->si_generation = 1;
|
|
|
|
memcpy(dst, src, sizeof(*dst));
|
|
|
|
spin_unlock(&stid->sc_lock);
|
|
|
|
}
|
|
|
|
|
2018-02-16 22:29:42 +03:00
|
|
|
static void put_deleg_file(struct nfs4_file *fp)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2019-08-18 21:18:53 +03:00
|
|
|
struct nfsd_file *nf = NULL;
|
2018-02-15 23:29:15 +03:00
|
|
|
|
2014-08-09 18:22:40 +04:00
|
|
|
spin_lock(&fp->fi_lock);
|
2018-02-16 22:29:42 +03:00
|
|
|
if (--fp->fi_delegees == 0)
|
2019-08-18 21:18:53 +03:00
|
|
|
swap(nf, fp->fi_deleg_file);
|
2014-08-09 18:22:40 +04:00
|
|
|
spin_unlock(&fp->fi_lock);
|
|
|
|
|
2019-08-18 21:18:53 +03:00
|
|
|
if (nf)
|
|
|
|
nfsd_file_put(nf);
|
2018-02-16 22:29:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void nfs4_unlock_deleg_lease(struct nfs4_delegation *dp)
|
|
|
|
{
|
|
|
|
struct nfs4_file *fp = dp->dl_stid.sc_file;
|
2019-08-18 21:18:53 +03:00
|
|
|
struct nfsd_file *nf = fp->fi_deleg_file;
|
2018-02-16 22:29:42 +03:00
|
|
|
|
|
|
|
WARN_ON_ONCE(!fp->fi_delegees);
|
|
|
|
|
2019-08-18 21:18:53 +03:00
|
|
|
vfs_setlease(nf->nf_file, F_UNLCK, NULL, (void **)&dp);
|
2018-02-16 22:29:42 +03:00
|
|
|
put_deleg_file(fp);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2018-02-21 23:11:03 +03:00
|
|
|
static void destroy_unhashed_deleg(struct nfs4_delegation *dp)
|
|
|
|
{
|
|
|
|
put_clnt_odstate(dp->dl_clnt_odstate);
|
2018-02-16 22:29:42 +03:00
|
|
|
nfs4_unlock_deleg_lease(dp);
|
2018-02-21 23:11:03 +03:00
|
|
|
nfs4_put_stid(&dp->dl_stid);
|
|
|
|
}
|
|
|
|
|
2014-08-14 10:44:57 +04:00
|
|
|
void nfs4_unhash_stid(struct nfs4_stid *s)
|
2011-09-24 00:21:15 +04:00
|
|
|
{
|
2013-02-03 21:23:01 +04:00
|
|
|
s->sc_type = 0;
|
2011-09-24 00:21:15 +04:00
|
|
|
}
|
|
|
|
|
2015-10-15 19:07:28 +03:00
|
|
|
/**
|
2018-02-19 19:38:33 +03:00
|
|
|
* nfs4_delegation_exists - Discover if this delegation already exists
|
2015-10-15 19:07:28 +03:00
|
|
|
* @clp: a pointer to the nfs4_client we're granting a delegation to
|
|
|
|
* @fp: a pointer to the nfs4_file we're granting a delegation on
|
|
|
|
*
|
|
|
|
* Return:
|
2018-02-19 19:38:33 +03:00
|
|
|
* On success: true iff an existing delegation is found
|
2015-10-15 19:07:28 +03:00
|
|
|
*/
|
|
|
|
|
2018-02-19 19:38:33 +03:00
|
|
|
static bool
|
|
|
|
nfs4_delegation_exists(struct nfs4_client *clp, struct nfs4_file *fp)
|
2015-10-15 19:07:28 +03:00
|
|
|
{
|
|
|
|
struct nfs4_delegation *searchdp = NULL;
|
|
|
|
struct nfs4_client *searchclp = NULL;
|
|
|
|
|
|
|
|
lockdep_assert_held(&state_lock);
|
|
|
|
lockdep_assert_held(&fp->fi_lock);
|
|
|
|
|
|
|
|
list_for_each_entry(searchdp, &fp->fi_delegations, dl_perfile) {
|
|
|
|
searchclp = searchdp->dl_stid.sc_client;
|
|
|
|
if (clp == searchclp) {
|
2018-03-22 08:37:20 +03:00
|
|
|
return true;
|
2015-10-15 19:07:28 +03:00
|
|
|
}
|
|
|
|
}
|
2018-03-22 08:37:20 +03:00
|
|
|
return false;
|
2015-10-15 19:07:28 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* hash_delegation_locked - Add a delegation to the appropriate lists
|
|
|
|
* @dp: a pointer to the nfs4_delegation we are adding.
|
|
|
|
* @fp: a pointer to the nfs4_file we're granting a delegation on
|
|
|
|
*
|
|
|
|
* Return:
|
|
|
|
* On success: NULL if the delegation was successfully hashed.
|
|
|
|
*
|
|
|
|
* On error: -EAGAIN if one was previously granted to this
|
|
|
|
* nfs4_client for this nfs4_file. Delegation is not hashed.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int
|
2014-05-30 17:09:27 +04:00
|
|
|
hash_delegation_locked(struct nfs4_delegation *dp, struct nfs4_file *fp)
|
|
|
|
{
|
2015-10-15 19:07:28 +03:00
|
|
|
struct nfs4_client *clp = dp->dl_stid.sc_client;
|
|
|
|
|
2014-05-30 17:09:30 +04:00
|
|
|
lockdep_assert_held(&state_lock);
|
2014-07-21 17:34:57 +04:00
|
|
|
lockdep_assert_held(&fp->fi_lock);
|
2014-05-30 17:09:27 +04:00
|
|
|
|
2018-02-19 19:38:33 +03:00
|
|
|
if (nfs4_delegation_exists(clp, fp))
|
|
|
|
return -EAGAIN;
|
2017-10-20 12:53:28 +03:00
|
|
|
refcount_inc(&dp->dl_stid.sc_count);
|
2014-05-30 17:09:31 +04:00
|
|
|
dp->dl_stid.sc_type = NFS4_DELEG_STID;
|
2014-05-30 17:09:27 +04:00
|
|
|
list_add(&dp->dl_perfile, &fp->fi_delegations);
|
2015-10-15 19:07:28 +03:00
|
|
|
list_add(&dp->dl_perclnt, &clp->cl_delegations);
|
|
|
|
return 0;
|
2014-05-30 17:09:27 +04:00
|
|
|
}
|
|
|
|
|
2015-08-24 19:41:48 +03:00
|
|
|
static bool
|
2014-07-25 15:34:20 +04:00
|
|
|
unhash_delegation_locked(struct nfs4_delegation *dp)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2014-07-30 05:34:08 +04:00
|
|
|
struct nfs4_file *fp = dp->dl_stid.sc_file;
|
2014-07-16 18:31:57 +04:00
|
|
|
|
2014-07-25 15:34:20 +04:00
|
|
|
lockdep_assert_held(&state_lock);
|
|
|
|
|
2015-08-24 19:41:48 +03:00
|
|
|
if (list_empty(&dp->dl_perfile))
|
|
|
|
return false;
|
|
|
|
|
2014-07-16 18:31:59 +04:00
|
|
|
dp->dl_stid.sc_type = NFS4_CLOSED_DELEG_STID;
|
nfsd: bump dl_time when unhashing delegation
There's a potential race between a lease break and DELEGRETURN call.
Suppose a lease break comes in and queues the workqueue job for a
delegation, but it doesn't run just yet. Then, a DELEGRETURN comes in
finds the delegation and calls destroy_delegation on it to unhash it and
put its primary reference.
Next, the workqueue job runs and queues the delegation back onto the
del_recall_lru list, issues the CB_RECALL and puts the final reference.
With that, the final reference to the delegation is put, but it's still
on the LRU list.
When we go to unhash a delegation, it's because we intend to get rid of
it soon afterward, so we don't want lease breaks to mess with it once
that occurs. Fix this by bumping the dl_time whenever we unhash a
delegation, to ensure that lease breaks don't monkey with it.
I believe this is a regression due to commit 02e1215f9f7 (nfsd: Avoid
taking state_lock while holding inode lock in nfsd_break_one_deleg).
Prior to that, the state_lock was held in the lm_break callback itself,
and that would have prevented this race.
Cc: Trond Myklebust <trond.myklebust@primarydata.com>
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-22 21:52:06 +04:00
|
|
|
/* Ensure that deleg break won't try to requeue it */
|
|
|
|
++dp->dl_time;
|
2014-07-21 17:34:57 +04:00
|
|
|
spin_lock(&fp->fi_lock);
|
2014-05-30 17:09:27 +04:00
|
|
|
list_del_init(&dp->dl_perclnt);
|
2005-04-17 02:20:36 +04:00
|
|
|
list_del_init(&dp->dl_recall_lru);
|
2014-07-16 18:31:57 +04:00
|
|
|
list_del_init(&dp->dl_perfile);
|
|
|
|
spin_unlock(&fp->fi_lock);
|
2015-08-24 19:41:48 +03:00
|
|
|
return true;
|
2013-04-10 01:02:51 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void destroy_delegation(struct nfs4_delegation *dp)
|
|
|
|
{
|
2015-08-24 19:41:48 +03:00
|
|
|
bool unhashed;
|
|
|
|
|
2014-07-25 15:34:20 +04:00
|
|
|
spin_lock(&state_lock);
|
2015-08-24 19:41:48 +03:00
|
|
|
unhashed = unhash_delegation_locked(dp);
|
2014-07-25 15:34:20 +04:00
|
|
|
spin_unlock(&state_lock);
|
2018-02-21 23:11:03 +03:00
|
|
|
if (unhashed)
|
|
|
|
destroy_unhashed_deleg(dp);
|
2013-04-10 01:02:51 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void revoke_delegation(struct nfs4_delegation *dp)
|
|
|
|
{
|
|
|
|
struct nfs4_client *clp = dp->dl_stid.sc_client;
|
|
|
|
|
2014-07-25 15:34:21 +04:00
|
|
|
WARN_ON(!list_empty(&dp->dl_recall_lru));
|
|
|
|
|
2018-02-21 23:11:03 +03:00
|
|
|
if (clp->cl_minorversion) {
|
2013-04-10 01:02:51 +04:00
|
|
|
dp->dl_stid.sc_type = NFS4_REVOKED_DELEG_STID;
|
2018-02-21 23:11:03 +03:00
|
|
|
refcount_inc(&dp->dl_stid.sc_count);
|
2014-07-25 15:34:21 +04:00
|
|
|
spin_lock(&clp->cl_lock);
|
|
|
|
list_add(&dp->dl_recall_lru, &clp->cl_revoked);
|
|
|
|
spin_unlock(&clp->cl_lock);
|
2013-04-10 01:02:51 +04:00
|
|
|
}
|
2018-02-21 23:11:03 +03:00
|
|
|
destroy_unhashed_deleg(dp);
|
2013-04-10 01:02:51 +04:00
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* SETCLIENTID state
|
|
|
|
*/
|
|
|
|
|
2011-07-31 07:46:29 +04:00
|
|
|
static unsigned int clientid_hashval(u32 id)
|
|
|
|
{
|
|
|
|
return id & CLIENT_HASH_MASK;
|
|
|
|
}
|
|
|
|
|
2019-03-27 01:06:26 +03:00
|
|
|
static unsigned int clientstr_hashval(struct xdr_netobj name)
|
2011-07-31 07:46:29 +04:00
|
|
|
{
|
2019-03-27 01:06:26 +03:00
|
|
|
return opaque_hashval(name.data, 8) & CLIENT_HASH_MASK;
|
2011-07-31 07:46:29 +04:00
|
|
|
}
|
|
|
|
|
nfsd: make deny mode enforcement more efficient and close races in it
The current enforcement of deny modes is both inefficient and scattered
across several places, which makes it hard to guarantee atomicity. The
inefficiency is a problem now, and the lack of atomicity will mean races
once the client_mutex is removed.
First, we address the inefficiency. We have to track deny modes on a
per-stateid basis to ensure that open downgrades are sane, but when the
server goes to enforce them it has to walk the entire list of stateids
and check against each one.
Instead of doing that, maintain a per-nfs4_file deny mode. When a file
is opened, we simply set any deny bits in that mode that were specified
in the OPEN call. We can then use that unified deny mode to do a simple
check to see whether there are any conflicts without needing to walk the
entire stateid list.
The only time we'll need to walk the entire list of stateids is when a
stateid that has a deny mode on it is being released, or one is having
its deny mode downgraded. In that case, we must walk the entire list and
recalculate the fi_share_deny field. Since deny modes are pretty rare
today, this should be very rare under normal workloads.
To address the potential for races once the client_mutex is removed,
protect fi_share_deny with the fi_lock. In nfs4_get_vfs_file, check to
make sure that any deny mode we want to apply won't conflict with
existing access. If that's ok, then have nfs4_file_get_access check that
new access to the file won't conflict with existing deny modes.
If that also passes, then get file access references, set the correct
access and deny bits in the stateid, and update the fi_share_deny field.
If opening the file or truncating it fails, then unwind the whole mess
and return the appropriate error.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-10 22:07:34 +04:00
|
|
|
/*
|
|
|
|
* A stateid that had a deny mode associated with it is being released
|
|
|
|
* or downgraded. Recalculate the deny mode on the file.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
recalculate_deny_mode(struct nfs4_file *fp)
|
|
|
|
{
|
|
|
|
struct nfs4_ol_stateid *stp;
|
|
|
|
|
|
|
|
spin_lock(&fp->fi_lock);
|
|
|
|
fp->fi_share_deny = 0;
|
|
|
|
list_for_each_entry(stp, &fp->fi_stateids, st_perfile)
|
|
|
|
fp->fi_share_deny |= bmap_to_share_mode(stp->st_deny_bmap);
|
|
|
|
spin_unlock(&fp->fi_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
reset_union_bmap_deny(u32 deny, struct nfs4_ol_stateid *stp)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
bool change = false;
|
|
|
|
|
|
|
|
for (i = 1; i < 4; i++) {
|
|
|
|
if ((i & deny) != i) {
|
|
|
|
change = true;
|
|
|
|
clear_deny(i, stp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Recalculate per-file deny mode if there was a change */
|
|
|
|
if (change)
|
2014-07-30 05:34:08 +04:00
|
|
|
recalculate_deny_mode(stp->st_stid.sc_file);
|
nfsd: make deny mode enforcement more efficient and close races in it
The current enforcement of deny modes is both inefficient and scattered
across several places, which makes it hard to guarantee atomicity. The
inefficiency is a problem now, and the lack of atomicity will mean races
once the client_mutex is removed.
First, we address the inefficiency. We have to track deny modes on a
per-stateid basis to ensure that open downgrades are sane, but when the
server goes to enforce them it has to walk the entire list of stateids
and check against each one.
Instead of doing that, maintain a per-nfs4_file deny mode. When a file
is opened, we simply set any deny bits in that mode that were specified
in the OPEN call. We can then use that unified deny mode to do a simple
check to see whether there are any conflicts without needing to walk the
entire stateid list.
The only time we'll need to walk the entire list of stateids is when a
stateid that has a deny mode on it is being released, or one is having
its deny mode downgraded. In that case, we must walk the entire list and
recalculate the fi_share_deny field. Since deny modes are pretty rare
today, this should be very rare under normal workloads.
To address the potential for races once the client_mutex is removed,
protect fi_share_deny with the fi_lock. In nfs4_get_vfs_file, check to
make sure that any deny mode we want to apply won't conflict with
existing access. If that's ok, then have nfs4_file_get_access check that
new access to the file won't conflict with existing deny modes.
If that also passes, then get file access references, set the correct
access and deny bits in the stateid, and update the fi_share_deny field.
If opening the file or truncating it fails, then unwind the whole mess
and return the appropriate error.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-10 22:07:34 +04:00
|
|
|
}
|
|
|
|
|
2012-05-11 17:45:13 +04:00
|
|
|
/* release all access and file references for a given stateid */
|
|
|
|
static void
|
|
|
|
release_all_access(struct nfs4_ol_stateid *stp)
|
|
|
|
{
|
|
|
|
int i;
|
2014-07-30 05:34:08 +04:00
|
|
|
struct nfs4_file *fp = stp->st_stid.sc_file;
|
nfsd: make deny mode enforcement more efficient and close races in it
The current enforcement of deny modes is both inefficient and scattered
across several places, which makes it hard to guarantee atomicity. The
inefficiency is a problem now, and the lack of atomicity will mean races
once the client_mutex is removed.
First, we address the inefficiency. We have to track deny modes on a
per-stateid basis to ensure that open downgrades are sane, but when the
server goes to enforce them it has to walk the entire list of stateids
and check against each one.
Instead of doing that, maintain a per-nfs4_file deny mode. When a file
is opened, we simply set any deny bits in that mode that were specified
in the OPEN call. We can then use that unified deny mode to do a simple
check to see whether there are any conflicts without needing to walk the
entire stateid list.
The only time we'll need to walk the entire list of stateids is when a
stateid that has a deny mode on it is being released, or one is having
its deny mode downgraded. In that case, we must walk the entire list and
recalculate the fi_share_deny field. Since deny modes are pretty rare
today, this should be very rare under normal workloads.
To address the potential for races once the client_mutex is removed,
protect fi_share_deny with the fi_lock. In nfs4_get_vfs_file, check to
make sure that any deny mode we want to apply won't conflict with
existing access. If that's ok, then have nfs4_file_get_access check that
new access to the file won't conflict with existing deny modes.
If that also passes, then get file access references, set the correct
access and deny bits in the stateid, and update the fi_share_deny field.
If opening the file or truncating it fails, then unwind the whole mess
and return the appropriate error.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-10 22:07:34 +04:00
|
|
|
|
|
|
|
if (fp && stp->st_deny_bmap != 0)
|
|
|
|
recalculate_deny_mode(fp);
|
2012-05-11 17:45:13 +04:00
|
|
|
|
|
|
|
for (i = 1; i < 4; i++) {
|
|
|
|
if (test_access(i, stp))
|
2014-07-30 05:34:08 +04:00
|
|
|
nfs4_file_put_access(stp->st_stid.sc_file, i);
|
2012-05-11 17:45:13 +04:00
|
|
|
clear_access(i, stp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-16 07:05:07 +03:00
|
|
|
static inline void nfs4_free_stateowner(struct nfs4_stateowner *sop)
|
|
|
|
{
|
|
|
|
kfree(sop->so_owner.data);
|
|
|
|
sop->so_ops->so_free(sop);
|
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:26 +04:00
|
|
|
static void nfs4_put_stateowner(struct nfs4_stateowner *sop)
|
|
|
|
{
|
2014-07-30 05:34:38 +04:00
|
|
|
struct nfs4_client *clp = sop->so_client;
|
|
|
|
|
|
|
|
might_lock(&clp->cl_lock);
|
|
|
|
|
|
|
|
if (!atomic_dec_and_lock(&sop->so_count, &clp->cl_lock))
|
2014-07-30 05:34:26 +04:00
|
|
|
return;
|
2014-07-30 05:34:29 +04:00
|
|
|
sop->so_ops->so_unhash(sop);
|
2014-07-30 05:34:38 +04:00
|
|
|
spin_unlock(&clp->cl_lock);
|
2015-07-16 07:05:07 +03:00
|
|
|
nfs4_free_stateowner(sop);
|
2014-07-30 05:34:26 +04:00
|
|
|
}
|
|
|
|
|
2020-03-02 02:21:38 +03:00
|
|
|
static bool
|
|
|
|
nfs4_ol_stateid_unhashed(const struct nfs4_ol_stateid *stp)
|
|
|
|
{
|
|
|
|
return list_empty(&stp->st_perfile);
|
|
|
|
}
|
|
|
|
|
2015-08-24 19:41:47 +03:00
|
|
|
static bool unhash_ol_stateid(struct nfs4_ol_stateid *stp)
|
2011-03-03 07:48:33 +03:00
|
|
|
{
|
2014-07-30 05:34:08 +04:00
|
|
|
struct nfs4_file *fp = stp->st_stid.sc_file;
|
2014-07-10 22:07:25 +04:00
|
|
|
|
2014-07-30 05:34:12 +04:00
|
|
|
lockdep_assert_held(&stp->st_stateowner->so_client->cl_lock);
|
|
|
|
|
2015-08-24 19:41:47 +03:00
|
|
|
if (list_empty(&stp->st_perfile))
|
|
|
|
return false;
|
|
|
|
|
2014-07-10 22:07:25 +04:00
|
|
|
spin_lock(&fp->fi_lock);
|
2015-08-24 19:41:47 +03:00
|
|
|
list_del_init(&stp->st_perfile);
|
2014-07-10 22:07:25 +04:00
|
|
|
spin_unlock(&fp->fi_lock);
|
2011-03-03 07:48:33 +03:00
|
|
|
list_del(&stp->st_perstateowner);
|
2015-08-24 19:41:47 +03:00
|
|
|
return true;
|
2011-03-03 07:48:33 +03:00
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:06 +04:00
|
|
|
static void nfs4_free_ol_stateid(struct nfs4_stid *stid)
|
2011-03-03 07:48:33 +03:00
|
|
|
{
|
2014-07-30 05:34:06 +04:00
|
|
|
struct nfs4_ol_stateid *stp = openlockstateid(stid);
|
2011-09-06 22:50:49 +04:00
|
|
|
|
2015-04-27 15:50:14 +03:00
|
|
|
put_clnt_odstate(stp->st_clnt_odstate);
|
2014-07-30 05:34:06 +04:00
|
|
|
release_all_access(stp);
|
2014-07-30 05:34:32 +04:00
|
|
|
if (stp->st_stateowner)
|
|
|
|
nfs4_put_stateowner(stp->st_stateowner);
|
2014-07-30 05:34:06 +04:00
|
|
|
kmem_cache_free(stateid_slab, stid);
|
2011-03-03 07:48:33 +03:00
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:11 +04:00
|
|
|
static void nfs4_free_lock_stateid(struct nfs4_stid *stid)
|
2011-03-03 07:48:33 +03:00
|
|
|
{
|
2014-07-30 05:34:11 +04:00
|
|
|
struct nfs4_ol_stateid *stp = openlockstateid(stid);
|
|
|
|
struct nfs4_lockowner *lo = lockowner(stp->st_stateowner);
|
2019-08-18 21:18:53 +03:00
|
|
|
struct nfsd_file *nf;
|
2011-03-03 07:48:33 +03:00
|
|
|
|
2019-08-18 21:18:53 +03:00
|
|
|
nf = find_any_file(stp->st_stid.sc_file);
|
|
|
|
if (nf) {
|
|
|
|
get_file(nf->nf_file);
|
|
|
|
filp_close(nf->nf_file, (fl_owner_t)lo);
|
|
|
|
nfsd_file_put(nf);
|
|
|
|
}
|
2014-07-30 05:34:11 +04:00
|
|
|
nfs4_free_ol_stateid(stid);
|
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:41 +04:00
|
|
|
/*
|
|
|
|
* Put the persistent reference to an already unhashed generic stateid, while
|
|
|
|
* holding the cl_lock. If it's the last reference, then put it onto the
|
|
|
|
* reaplist for later destruction.
|
|
|
|
*/
|
|
|
|
static void put_ol_stateid_locked(struct nfs4_ol_stateid *stp,
|
|
|
|
struct list_head *reaplist)
|
|
|
|
{
|
|
|
|
struct nfs4_stid *s = &stp->st_stid;
|
|
|
|
struct nfs4_client *clp = s->sc_client;
|
|
|
|
|
|
|
|
lockdep_assert_held(&clp->cl_lock);
|
|
|
|
|
|
|
|
WARN_ON_ONCE(!list_empty(&stp->st_locks));
|
|
|
|
|
2017-10-20 12:53:28 +03:00
|
|
|
if (!refcount_dec_and_test(&s->sc_count)) {
|
2014-07-30 05:34:41 +04:00
|
|
|
wake_up_all(&close_wq);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id);
|
|
|
|
list_add(&stp->st_locks, reaplist);
|
|
|
|
}
|
|
|
|
|
2015-08-24 19:41:47 +03:00
|
|
|
static bool unhash_lock_stateid(struct nfs4_ol_stateid *stp)
|
2014-07-30 05:34:11 +04:00
|
|
|
{
|
2016-10-30 01:19:03 +03:00
|
|
|
lockdep_assert_held(&stp->st_stid.sc_client->cl_lock);
|
2014-07-30 05:34:39 +04:00
|
|
|
|
2020-03-02 02:21:38 +03:00
|
|
|
if (!unhash_ol_stateid(stp))
|
|
|
|
return false;
|
2014-07-30 05:34:39 +04:00
|
|
|
list_del_init(&stp->st_locks);
|
2014-08-14 10:44:57 +04:00
|
|
|
nfs4_unhash_stid(&stp->st_stid);
|
2020-03-02 02:21:38 +03:00
|
|
|
return true;
|
2014-07-30 05:34:39 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void release_lock_stateid(struct nfs4_ol_stateid *stp)
|
|
|
|
{
|
2016-10-30 01:19:03 +03:00
|
|
|
struct nfs4_client *clp = stp->st_stid.sc_client;
|
2015-08-24 19:41:47 +03:00
|
|
|
bool unhashed;
|
2014-07-30 05:34:39 +04:00
|
|
|
|
2016-10-30 01:19:03 +03:00
|
|
|
spin_lock(&clp->cl_lock);
|
2015-08-24 19:41:47 +03:00
|
|
|
unhashed = unhash_lock_stateid(stp);
|
2016-10-30 01:19:03 +03:00
|
|
|
spin_unlock(&clp->cl_lock);
|
2015-08-24 19:41:47 +03:00
|
|
|
if (unhashed)
|
|
|
|
nfs4_put_stid(&stp->st_stid);
|
2011-03-03 07:48:33 +03:00
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:35 +04:00
|
|
|
static void unhash_lockowner_locked(struct nfs4_lockowner *lo)
|
2014-07-30 05:34:29 +04:00
|
|
|
{
|
2014-07-30 05:34:36 +04:00
|
|
|
struct nfs4_client *clp = lo->lo_owner.so_client;
|
2014-07-30 05:34:35 +04:00
|
|
|
|
2014-07-30 05:34:36 +04:00
|
|
|
lockdep_assert_held(&clp->cl_lock);
|
2014-07-30 05:34:35 +04:00
|
|
|
|
2014-07-30 05:34:29 +04:00
|
|
|
list_del_init(&lo->lo_owner.so_strhash);
|
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:41 +04:00
|
|
|
/*
|
|
|
|
* Free a list of generic stateids that were collected earlier after being
|
|
|
|
* fully unhashed.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
free_ol_stateid_reaplist(struct list_head *reaplist)
|
|
|
|
{
|
|
|
|
struct nfs4_ol_stateid *stp;
|
2014-08-05 17:20:27 +04:00
|
|
|
struct nfs4_file *fp;
|
2014-07-30 05:34:41 +04:00
|
|
|
|
|
|
|
might_sleep();
|
|
|
|
|
|
|
|
while (!list_empty(reaplist)) {
|
|
|
|
stp = list_first_entry(reaplist, struct nfs4_ol_stateid,
|
|
|
|
st_locks);
|
|
|
|
list_del(&stp->st_locks);
|
2014-08-05 17:20:27 +04:00
|
|
|
fp = stp->st_stid.sc_file;
|
2014-07-30 05:34:41 +04:00
|
|
|
stp->st_stid.sc_free(&stp->st_stid);
|
2014-08-05 17:20:27 +04:00
|
|
|
if (fp)
|
|
|
|
put_nfs4_file(fp);
|
2014-07-30 05:34:41 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:42 +04:00
|
|
|
static void release_open_stateid_locks(struct nfs4_ol_stateid *open_stp,
|
|
|
|
struct list_head *reaplist)
|
2014-06-30 19:48:38 +04:00
|
|
|
{
|
|
|
|
struct nfs4_ol_stateid *stp;
|
|
|
|
|
2015-08-24 19:41:47 +03:00
|
|
|
lockdep_assert_held(&open_stp->st_stid.sc_client->cl_lock);
|
|
|
|
|
2014-06-30 19:48:38 +04:00
|
|
|
while (!list_empty(&open_stp->st_locks)) {
|
|
|
|
stp = list_entry(open_stp->st_locks.next,
|
|
|
|
struct nfs4_ol_stateid, st_locks);
|
2015-08-24 19:41:47 +03:00
|
|
|
WARN_ON(!unhash_lock_stateid(stp));
|
2014-07-30 05:34:42 +04:00
|
|
|
put_ol_stateid_locked(stp, reaplist);
|
2011-03-03 07:48:33 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-24 19:41:47 +03:00
|
|
|
static bool unhash_open_stateid(struct nfs4_ol_stateid *stp,
|
2014-07-30 05:34:42 +04:00
|
|
|
struct list_head *reaplist)
|
2009-01-11 22:27:17 +03:00
|
|
|
{
|
2014-07-30 05:34:41 +04:00
|
|
|
lockdep_assert_held(&stp->st_stid.sc_client->cl_lock);
|
|
|
|
|
2020-03-02 02:21:38 +03:00
|
|
|
if (!unhash_ol_stateid(stp))
|
|
|
|
return false;
|
2014-07-30 05:34:42 +04:00
|
|
|
release_open_stateid_locks(stp, reaplist);
|
2020-03-02 02:21:38 +03:00
|
|
|
return true;
|
2011-09-17 01:42:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void release_open_stateid(struct nfs4_ol_stateid *stp)
|
|
|
|
{
|
2014-07-30 05:34:41 +04:00
|
|
|
LIST_HEAD(reaplist);
|
|
|
|
|
|
|
|
spin_lock(&stp->st_stid.sc_client->cl_lock);
|
2015-08-24 19:41:47 +03:00
|
|
|
if (unhash_open_stateid(stp, &reaplist))
|
|
|
|
put_ol_stateid_locked(stp, &reaplist);
|
2014-07-30 05:34:41 +04:00
|
|
|
spin_unlock(&stp->st_stid.sc_client->cl_lock);
|
|
|
|
free_ol_stateid_reaplist(&reaplist);
|
2009-01-11 22:27:17 +03:00
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:34 +04:00
|
|
|
static void unhash_openowner_locked(struct nfs4_openowner *oo)
|
2009-01-11 22:37:31 +03:00
|
|
|
{
|
2014-07-30 05:34:36 +04:00
|
|
|
struct nfs4_client *clp = oo->oo_owner.so_client;
|
2014-07-30 05:34:34 +04:00
|
|
|
|
2014-07-30 05:34:36 +04:00
|
|
|
lockdep_assert_held(&clp->cl_lock);
|
2014-07-30 05:34:34 +04:00
|
|
|
|
2014-07-30 05:34:29 +04:00
|
|
|
list_del_init(&oo->oo_owner.so_strhash);
|
|
|
|
list_del_init(&oo->oo_perclient);
|
2009-01-11 22:37:31 +03:00
|
|
|
}
|
|
|
|
|
2011-09-17 04:12:38 +04:00
|
|
|
static void release_last_closed_stateid(struct nfs4_openowner *oo)
|
|
|
|
{
|
2014-07-30 16:27:11 +04:00
|
|
|
struct nfsd_net *nn = net_generic(oo->oo_owner.so_client->net,
|
|
|
|
nfsd_net_id);
|
|
|
|
struct nfs4_ol_stateid *s;
|
2011-09-17 04:12:38 +04:00
|
|
|
|
2014-07-30 16:27:11 +04:00
|
|
|
spin_lock(&nn->client_lock);
|
|
|
|
s = oo->oo_last_closed_stid;
|
2011-09-17 04:12:38 +04:00
|
|
|
if (s) {
|
2014-07-30 05:34:32 +04:00
|
|
|
list_del_init(&oo->oo_close_lru);
|
2011-09-17 04:12:38 +04:00
|
|
|
oo->oo_last_closed_stid = NULL;
|
|
|
|
}
|
2014-07-30 16:27:11 +04:00
|
|
|
spin_unlock(&nn->client_lock);
|
|
|
|
if (s)
|
|
|
|
nfs4_put_stid(&s->st_stid);
|
2011-09-17 04:12:38 +04:00
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:41 +04:00
|
|
|
static void release_openowner(struct nfs4_openowner *oo)
|
2014-07-30 05:34:29 +04:00
|
|
|
{
|
|
|
|
struct nfs4_ol_stateid *stp;
|
2014-07-30 05:34:36 +04:00
|
|
|
struct nfs4_client *clp = oo->oo_owner.so_client;
|
2014-07-30 05:34:41 +04:00
|
|
|
struct list_head reaplist;
|
2014-07-30 05:34:34 +04:00
|
|
|
|
2014-07-30 05:34:41 +04:00
|
|
|
INIT_LIST_HEAD(&reaplist);
|
2014-07-30 05:34:29 +04:00
|
|
|
|
2014-07-30 05:34:41 +04:00
|
|
|
spin_lock(&clp->cl_lock);
|
|
|
|
unhash_openowner_locked(oo);
|
2014-07-30 05:34:29 +04:00
|
|
|
while (!list_empty(&oo->oo_owner.so_stateids)) {
|
|
|
|
stp = list_first_entry(&oo->oo_owner.so_stateids,
|
|
|
|
struct nfs4_ol_stateid, st_perstateowner);
|
2015-08-24 19:41:47 +03:00
|
|
|
if (unhash_open_stateid(stp, &reaplist))
|
|
|
|
put_ol_stateid_locked(stp, &reaplist);
|
2014-07-30 05:34:29 +04:00
|
|
|
}
|
2014-07-30 05:34:36 +04:00
|
|
|
spin_unlock(&clp->cl_lock);
|
2014-07-30 05:34:41 +04:00
|
|
|
free_ol_stateid_reaplist(&reaplist);
|
2011-09-17 04:12:38 +04:00
|
|
|
release_last_closed_stateid(oo);
|
2014-07-30 05:34:26 +04:00
|
|
|
nfs4_put_stateowner(&oo->oo_owner);
|
2009-01-11 22:37:31 +03:00
|
|
|
}
|
|
|
|
|
2009-04-03 09:27:52 +04:00
|
|
|
static inline int
|
|
|
|
hash_sessionid(struct nfs4_sessionid *sessionid)
|
|
|
|
{
|
|
|
|
struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
|
|
|
|
|
|
|
|
return sid->sequence % SESSION_HASH_SIZE;
|
|
|
|
}
|
|
|
|
|
2015-04-06 16:46:00 +03:00
|
|
|
#ifdef CONFIG_SUNRPC_DEBUG
|
2009-04-03 09:27:52 +04:00
|
|
|
static inline void
|
|
|
|
dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
|
|
|
|
{
|
|
|
|
u32 *ptr = (u32 *)(&sessionid->data[0]);
|
|
|
|
dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
|
|
|
|
}
|
2012-03-20 23:11:17 +04:00
|
|
|
#else
|
|
|
|
static inline void
|
|
|
|
dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-04-02 00:37:12 +04:00
|
|
|
/*
|
|
|
|
* Bump the seqid on cstate->replay_owner, and clear replay_owner if it
|
|
|
|
* won't be used for replay.
|
|
|
|
*/
|
|
|
|
void nfsd4_bump_seqid(struct nfsd4_compound_state *cstate, __be32 nfserr)
|
|
|
|
{
|
|
|
|
struct nfs4_stateowner *so = cstate->replay_owner;
|
|
|
|
|
|
|
|
if (nfserr == nfserr_replay_me)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!seqid_mutating_err(ntohl(nfserr))) {
|
2014-07-30 05:34:27 +04:00
|
|
|
nfsd4_cstate_clear_replay(cstate);
|
2013-04-02 00:37:12 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!so)
|
|
|
|
return;
|
|
|
|
if (so->so_is_open_owner)
|
|
|
|
release_last_closed_stateid(openowner(so));
|
|
|
|
so->so_seqid++;
|
|
|
|
return;
|
|
|
|
}
|
2009-04-03 09:27:52 +04:00
|
|
|
|
2009-04-03 09:28:28 +04:00
|
|
|
static void
|
|
|
|
gen_sessionid(struct nfsd4_session *ses)
|
|
|
|
{
|
|
|
|
struct nfs4_client *clp = ses->se_client;
|
|
|
|
struct nfsd4_sessionid *sid;
|
|
|
|
|
|
|
|
sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
|
|
|
|
sid->clientid = clp->cl_clientid;
|
|
|
|
sid->sequence = current_sessionid++;
|
|
|
|
sid->reserved = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2009-08-28 16:45:01 +04:00
|
|
|
* The protocol defines ca_maxresponssize_cached to include the size of
|
|
|
|
* the rpc header, but all we need to cache is the data starting after
|
|
|
|
* the end of the initial SEQUENCE operation--the rest we regenerate
|
|
|
|
* each time. Therefore we can advertise a ca_maxresponssize_cached
|
|
|
|
* value that is the number of bytes in our cache plus a few additional
|
|
|
|
* bytes. In order to stay on the safe side, and not promise more than
|
|
|
|
* we can cache, those additional bytes must be the minimum possible: 24
|
|
|
|
* bytes of rpc header (xid through accept state, with AUTH_NULL
|
|
|
|
* verifier), 12 for the compound header (with zero-length tag), and 44
|
|
|
|
* for the SEQUENCE op response:
|
|
|
|
*/
|
|
|
|
#define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44)
|
|
|
|
|
2009-08-28 16:45:04 +04:00
|
|
|
static void
|
|
|
|
free_session_slots(struct nfsd4_session *ses)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2017-10-18 03:38:49 +03:00
|
|
|
for (i = 0; i < ses->se_fchannel.maxreqs; i++) {
|
|
|
|
free_svc_cred(&ses->se_slots[i]->sl_cred);
|
2009-08-28 16:45:04 +04:00
|
|
|
kfree(ses->se_slots[i]);
|
2017-10-18 03:38:49 +03:00
|
|
|
}
|
2009-08-28 16:45:04 +04:00
|
|
|
}
|
|
|
|
|
2009-08-28 16:45:01 +04:00
|
|
|
/*
|
2009-10-25 03:52:16 +03:00
|
|
|
* We don't actually need to cache the rpc and session headers, so we
|
|
|
|
* can allocate a little less for each slot:
|
|
|
|
*/
|
2013-04-09 00:44:14 +04:00
|
|
|
static inline u32 slot_bytes(struct nfsd4_channel_attrs *ca)
|
2009-10-25 03:52:16 +03:00
|
|
|
{
|
2013-04-09 00:44:14 +04:00
|
|
|
u32 size;
|
2009-10-25 03:52:16 +03:00
|
|
|
|
2013-04-09 00:44:14 +04:00
|
|
|
if (ca->maxresp_cached < NFSD_MIN_HDR_SEQ_SZ)
|
|
|
|
size = 0;
|
|
|
|
else
|
|
|
|
size = ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
|
|
|
|
return size + sizeof(struct nfsd4_slot);
|
2010-09-28 01:12:05 +04:00
|
|
|
}
|
2009-04-03 09:28:28 +04:00
|
|
|
|
2010-09-28 01:12:05 +04:00
|
|
|
/*
|
|
|
|
* XXX: If we run out of reserved DRC memory we could (up to a point)
|
2009-08-28 16:45:01 +04:00
|
|
|
* re-negotiate active sessions and reduce their slot usage to make
|
2011-11-29 08:31:00 +04:00
|
|
|
* room for new connections. For now we just fail the create session.
|
2009-04-03 09:28:28 +04:00
|
|
|
*/
|
2019-09-20 09:36:45 +03:00
|
|
|
static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn)
|
2009-04-03 09:28:28 +04:00
|
|
|
{
|
2013-04-09 00:44:14 +04:00
|
|
|
u32 slotsize = slot_bytes(ca);
|
|
|
|
u32 num = ca->maxreqs;
|
2019-02-21 18:47:00 +03:00
|
|
|
unsigned long avail, total_avail;
|
2019-09-20 09:36:45 +03:00
|
|
|
unsigned int scale_factor;
|
2009-04-03 09:28:28 +04:00
|
|
|
|
2010-09-28 01:12:05 +04:00
|
|
|
spin_lock(&nfsd_drc_lock);
|
2019-09-20 09:33:16 +03:00
|
|
|
if (nfsd_drc_max_mem > nfsd_drc_mem_used)
|
|
|
|
total_avail = nfsd_drc_max_mem - nfsd_drc_mem_used;
|
|
|
|
else
|
|
|
|
/* We have handed out more space than we chose in
|
|
|
|
* set_max_drc() to allow. That isn't really a
|
|
|
|
* problem as long as that doesn't make us think we
|
|
|
|
* have lots more due to integer overflow.
|
|
|
|
*/
|
|
|
|
total_avail = 0;
|
2019-02-21 18:47:00 +03:00
|
|
|
avail = min((unsigned long)NFSD_MAX_MEM_PER_SESSION, total_avail);
|
2017-09-20 02:25:41 +03:00
|
|
|
/*
|
2019-09-20 09:36:45 +03:00
|
|
|
* Never use more than a fraction of the remaining memory,
|
2019-09-20 09:33:16 +03:00
|
|
|
* unless it's the only way to give this client a slot.
|
2019-09-20 09:36:45 +03:00
|
|
|
* The chosen fraction is either 1/8 or 1/number of threads,
|
|
|
|
* whichever is smaller. This ensures there are adequate
|
|
|
|
* slots to support multiple clients per thread.
|
2019-09-20 09:33:16 +03:00
|
|
|
* Give the client one slot even if that would require
|
|
|
|
* over-allocation--it is better than failure.
|
2017-09-20 02:25:41 +03:00
|
|
|
*/
|
2019-09-20 09:36:45 +03:00
|
|
|
scale_factor = max_t(unsigned int, 8, nn->nfsd_serv->sv_nrthreads);
|
|
|
|
|
|
|
|
avail = clamp_t(unsigned long, avail, slotsize,
|
|
|
|
total_avail/scale_factor);
|
2010-09-28 01:12:05 +04:00
|
|
|
num = min_t(int, num, avail / slotsize);
|
2019-09-20 09:33:16 +03:00
|
|
|
num = max_t(int, num, 1);
|
2010-09-28 01:12:05 +04:00
|
|
|
nfsd_drc_mem_used += num * slotsize;
|
|
|
|
spin_unlock(&nfsd_drc_lock);
|
2009-04-03 09:28:28 +04:00
|
|
|
|
2010-09-28 01:12:05 +04:00
|
|
|
return num;
|
|
|
|
}
|
2009-04-03 09:28:28 +04:00
|
|
|
|
2013-04-09 00:44:14 +04:00
|
|
|
static void nfsd4_put_drc_mem(struct nfsd4_channel_attrs *ca)
|
2010-09-28 01:12:05 +04:00
|
|
|
{
|
2013-04-09 00:44:14 +04:00
|
|
|
int slotsize = slot_bytes(ca);
|
|
|
|
|
2009-06-24 23:37:45 +04:00
|
|
|
spin_lock(&nfsd_drc_lock);
|
2013-04-09 00:44:14 +04:00
|
|
|
nfsd_drc_mem_used -= slotsize * ca->maxreqs;
|
2009-06-24 23:37:45 +04:00
|
|
|
spin_unlock(&nfsd_drc_lock);
|
2010-09-28 01:12:05 +04:00
|
|
|
}
|
2009-04-03 09:28:28 +04:00
|
|
|
|
2013-12-31 20:35:47 +04:00
|
|
|
static struct nfsd4_session *alloc_session(struct nfsd4_channel_attrs *fattrs,
|
|
|
|
struct nfsd4_channel_attrs *battrs)
|
2010-09-28 01:12:05 +04:00
|
|
|
{
|
2013-12-31 20:35:47 +04:00
|
|
|
int numslots = fattrs->maxreqs;
|
|
|
|
int slotsize = slot_bytes(fattrs);
|
2010-09-28 01:12:05 +04:00
|
|
|
struct nfsd4_session *new;
|
|
|
|
int mem, i;
|
2009-08-28 16:45:01 +04:00
|
|
|
|
2010-09-28 01:12:05 +04:00
|
|
|
BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
|
|
|
|
+ sizeof(struct nfsd4_session) > PAGE_SIZE);
|
|
|
|
mem = numslots * sizeof(struct nfsd4_slot *);
|
2009-04-03 09:28:28 +04:00
|
|
|
|
2010-09-28 01:12:05 +04:00
|
|
|
new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
|
|
|
|
if (!new)
|
|
|
|
return NULL;
|
2009-08-28 16:45:04 +04:00
|
|
|
/* allocate each struct nfsd4_slot and data cache in one piece */
|
2010-09-28 01:12:05 +04:00
|
|
|
for (i = 0; i < numslots; i++) {
|
2013-04-09 00:44:14 +04:00
|
|
|
new->se_slots[i] = kzalloc(slotsize, GFP_KERNEL);
|
2010-09-28 01:12:05 +04:00
|
|
|
if (!new->se_slots[i])
|
2009-08-28 16:45:04 +04:00
|
|
|
goto out_free;
|
|
|
|
}
|
2013-12-31 20:35:47 +04:00
|
|
|
|
|
|
|
memcpy(&new->se_fchannel, fattrs, sizeof(struct nfsd4_channel_attrs));
|
|
|
|
memcpy(&new->se_bchannel, battrs, sizeof(struct nfsd4_channel_attrs));
|
|
|
|
|
2010-09-28 01:12:05 +04:00
|
|
|
return new;
|
|
|
|
out_free:
|
|
|
|
while (i--)
|
|
|
|
kfree(new->se_slots[i]);
|
|
|
|
kfree(new);
|
|
|
|
return NULL;
|
2009-04-03 09:28:28 +04:00
|
|
|
}
|
|
|
|
|
2010-06-07 02:37:16 +04:00
|
|
|
static void free_conn(struct nfsd4_conn *c)
|
|
|
|
{
|
|
|
|
svc_xprt_put(c->cn_xprt);
|
|
|
|
kfree(c);
|
|
|
|
}
|
2009-04-03 09:28:28 +04:00
|
|
|
|
2010-06-07 02:37:16 +04:00
|
|
|
static void nfsd4_conn_lost(struct svc_xpt_user *u)
|
|
|
|
{
|
|
|
|
struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
|
|
|
|
struct nfs4_client *clp = c->cn_session->se_client;
|
2009-04-03 09:28:28 +04:00
|
|
|
|
2021-05-14 22:56:43 +03:00
|
|
|
trace_nfsd_cb_lost(clp);
|
|
|
|
|
2010-06-07 02:37:16 +04:00
|
|
|
spin_lock(&clp->cl_lock);
|
|
|
|
if (!list_empty(&c->cn_persession)) {
|
|
|
|
list_del(&c->cn_persession);
|
|
|
|
free_conn(c);
|
|
|
|
}
|
2010-11-18 16:34:12 +03:00
|
|
|
nfsd4_probe_callback(clp);
|
2013-03-08 18:30:43 +04:00
|
|
|
spin_unlock(&clp->cl_lock);
|
2010-06-07 02:37:16 +04:00
|
|
|
}
|
2009-04-03 09:28:28 +04:00
|
|
|
|
2010-06-16 01:34:11 +04:00
|
|
|
static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
|
2010-06-07 02:12:14 +04:00
|
|
|
{
|
|
|
|
struct nfsd4_conn *conn;
|
2009-04-03 09:28:28 +04:00
|
|
|
|
2010-06-07 02:12:14 +04:00
|
|
|
conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
|
|
|
|
if (!conn)
|
2010-09-29 23:29:32 +04:00
|
|
|
return NULL;
|
2010-06-07 02:12:14 +04:00
|
|
|
svc_xprt_get(rqstp->rq_xprt);
|
|
|
|
conn->cn_xprt = rqstp->rq_xprt;
|
2010-06-16 01:34:11 +04:00
|
|
|
conn->cn_flags = flags;
|
2010-09-29 23:29:32 +04:00
|
|
|
INIT_LIST_HEAD(&conn->cn_xpt_user.list);
|
|
|
|
return conn;
|
|
|
|
}
|
2009-08-28 16:45:01 +04:00
|
|
|
|
2010-09-30 00:11:06 +04:00
|
|
|
static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
|
|
|
|
{
|
|
|
|
conn->cn_session = ses;
|
|
|
|
list_add(&conn->cn_persession, &ses->se_conns);
|
2009-04-03 09:28:28 +04:00
|
|
|
}
|
|
|
|
|
2010-09-29 23:29:32 +04:00
|
|
|
static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
|
2009-08-28 16:45:04 +04:00
|
|
|
{
|
2010-09-29 23:29:32 +04:00
|
|
|
struct nfs4_client *clp = ses->se_client;
|
2009-08-28 16:45:04 +04:00
|
|
|
|
2010-06-07 02:12:14 +04:00
|
|
|
spin_lock(&clp->cl_lock);
|
2010-09-30 00:11:06 +04:00
|
|
|
__nfsd4_hash_conn(conn, ses);
|
2010-06-07 02:12:14 +04:00
|
|
|
spin_unlock(&clp->cl_lock);
|
2009-08-28 16:45:04 +04:00
|
|
|
}
|
|
|
|
|
2010-10-26 18:07:17 +04:00
|
|
|
static int nfsd4_register_conn(struct nfsd4_conn *conn)
|
2009-10-25 03:52:16 +03:00
|
|
|
{
|
2010-06-07 02:37:16 +04:00
|
|
|
conn->cn_xpt_user.callback = nfsd4_conn_lost;
|
2010-10-26 18:07:17 +04:00
|
|
|
return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
|
2009-10-25 03:52:16 +03:00
|
|
|
}
|
|
|
|
|
2012-09-12 01:10:25 +04:00
|
|
|
static void nfsd4_init_conn(struct svc_rqst *rqstp, struct nfsd4_conn *conn, struct nfsd4_session *ses)
|
2009-04-03 09:28:28 +04:00
|
|
|
{
|
2010-10-26 18:07:17 +04:00
|
|
|
int ret;
|
2009-04-03 09:28:28 +04:00
|
|
|
|
2010-09-29 23:29:32 +04:00
|
|
|
nfsd4_hash_conn(conn, ses);
|
2010-10-26 18:07:17 +04:00
|
|
|
ret = nfsd4_register_conn(conn);
|
|
|
|
if (ret)
|
|
|
|
/* oops; xprt is already down: */
|
|
|
|
nfsd4_conn_lost(&conn->cn_xpt_user);
|
2014-07-18 23:06:47 +04:00
|
|
|
/* We may have gained or lost a callback channel: */
|
|
|
|
nfsd4_probe_callback_sync(ses->se_client);
|
2010-06-07 02:12:14 +04:00
|
|
|
}
|
2009-04-03 09:28:28 +04:00
|
|
|
|
2012-09-12 01:10:25 +04:00
|
|
|
static struct nfsd4_conn *alloc_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_create_session *cses)
|
2010-10-05 07:12:59 +04:00
|
|
|
{
|
|
|
|
u32 dir = NFS4_CDFC4_FORE;
|
|
|
|
|
2012-09-12 01:10:25 +04:00
|
|
|
if (cses->flags & SESSION4_BACK_CHAN)
|
2010-10-05 07:12:59 +04:00
|
|
|
dir |= NFS4_CDFC4_BACK;
|
2012-09-12 01:10:25 +04:00
|
|
|
return alloc_conn(rqstp, dir);
|
2010-10-05 07:12:59 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* must be called under client_lock */
|
2010-06-07 02:37:16 +04:00
|
|
|
static void nfsd4_del_conns(struct nfsd4_session *s)
|
2010-06-07 02:12:14 +04:00
|
|
|
{
|
2010-06-07 02:37:16 +04:00
|
|
|
struct nfs4_client *clp = s->se_client;
|
|
|
|
struct nfsd4_conn *c;
|
2009-04-03 09:28:28 +04:00
|
|
|
|
2010-06-07 02:37:16 +04:00
|
|
|
spin_lock(&clp->cl_lock);
|
|
|
|
while (!list_empty(&s->se_conns)) {
|
|
|
|
c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
|
|
|
|
list_del_init(&c->cn_persession);
|
|
|
|
spin_unlock(&clp->cl_lock);
|
2009-08-28 16:45:04 +04:00
|
|
|
|
2010-06-07 02:37:16 +04:00
|
|
|
unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
|
|
|
|
free_conn(c);
|
2009-04-03 09:28:28 +04:00
|
|
|
|
2010-06-07 02:37:16 +04:00
|
|
|
spin_lock(&clp->cl_lock);
|
|
|
|
}
|
|
|
|
spin_unlock(&clp->cl_lock);
|
2010-06-07 02:12:14 +04:00
|
|
|
}
|
2009-04-03 09:28:28 +04:00
|
|
|
|
2012-09-12 05:42:40 +04:00
|
|
|
static void __free_session(struct nfsd4_session *ses)
|
|
|
|
{
|
|
|
|
free_session_slots(ses);
|
|
|
|
kfree(ses);
|
|
|
|
}
|
|
|
|
|
2013-03-19 20:05:39 +04:00
|
|
|
static void free_session(struct nfsd4_session *ses)
|
2010-06-07 02:12:14 +04:00
|
|
|
{
|
2010-06-07 02:37:16 +04:00
|
|
|
nfsd4_del_conns(ses);
|
2013-04-09 00:44:14 +04:00
|
|
|
nfsd4_put_drc_mem(&ses->se_fchannel);
|
2012-09-12 05:42:40 +04:00
|
|
|
__free_session(ses);
|
2010-06-07 02:12:14 +04:00
|
|
|
}
|
|
|
|
|
2012-11-10 16:20:25 +04:00
|
|
|
static void init_session(struct svc_rqst *rqstp, struct nfsd4_session *new, struct nfs4_client *clp, struct nfsd4_create_session *cses)
|
2012-09-12 17:51:34 +04:00
|
|
|
{
|
|
|
|
int idx;
|
2012-11-14 19:21:51 +04:00
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
2012-09-12 17:51:34 +04:00
|
|
|
|
2009-04-03 09:28:28 +04:00
|
|
|
new->se_client = clp;
|
|
|
|
gen_sessionid(new);
|
|
|
|
|
2010-06-07 02:12:14 +04:00
|
|
|
INIT_LIST_HEAD(&new->se_conns);
|
|
|
|
|
2010-06-15 03:01:57 +04:00
|
|
|
new->se_cb_seq_nr = 1;
|
2009-04-03 09:28:28 +04:00
|
|
|
new->se_flags = cses->flags;
|
2010-10-20 01:31:50 +04:00
|
|
|
new->se_cb_prog = cses->callback_prog;
|
2012-11-02 00:31:02 +04:00
|
|
|
new->se_cb_sec = cses->cb_sec;
|
2013-03-19 20:05:39 +04:00
|
|
|
atomic_set(&new->se_ref, 0);
|
2010-09-28 01:12:05 +04:00
|
|
|
idx = hash_sessionid(&new->se_sessionid);
|
2012-11-14 19:21:51 +04:00
|
|
|
list_add(&new->se_hash, &nn->sessionid_hashtbl[idx]);
|
2010-06-15 22:22:37 +04:00
|
|
|
spin_lock(&clp->cl_lock);
|
2009-04-03 09:28:28 +04:00
|
|
|
list_add(&new->se_perclnt, &clp->cl_sessions);
|
2010-06-15 22:22:37 +04:00
|
|
|
spin_unlock(&clp->cl_lock);
|
2013-12-31 20:35:47 +04:00
|
|
|
|
2014-08-22 23:10:59 +04:00
|
|
|
{
|
2010-06-15 06:26:31 +04:00
|
|
|
struct sockaddr *sa = svc_addr(rqstp);
|
2010-06-16 01:25:45 +04:00
|
|
|
/*
|
|
|
|
* This is a little silly; with sessions there's no real
|
|
|
|
* use for the callback address. Use the peer address
|
|
|
|
* as a reasonable default for now, but consider fixing
|
|
|
|
* the rpc client not to require an address in the
|
|
|
|
* future:
|
|
|
|
*/
|
2010-06-15 06:26:31 +04:00
|
|
|
rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
|
|
|
|
clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
|
|
|
|
}
|
2009-04-03 09:28:28 +04:00
|
|
|
}
|
|
|
|
|
2010-05-12 01:12:26 +04:00
|
|
|
/* caller must hold client_lock */
|
2009-04-03 09:27:52 +04:00
|
|
|
static struct nfsd4_session *
|
2014-06-30 19:48:42 +04:00
|
|
|
__find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net)
|
2009-04-03 09:27:52 +04:00
|
|
|
{
|
|
|
|
struct nfsd4_session *elem;
|
|
|
|
int idx;
|
2012-11-14 19:21:51 +04:00
|
|
|
struct nfsd_net *nn = net_generic(net, nfsd_net_id);
|
2009-04-03 09:27:52 +04:00
|
|
|
|
2014-07-30 16:27:10 +04:00
|
|
|
lockdep_assert_held(&nn->client_lock);
|
|
|
|
|
2009-04-03 09:27:52 +04:00
|
|
|
dump_sessionid(__func__, sessionid);
|
|
|
|
idx = hash_sessionid(sessionid);
|
|
|
|
/* Search in the appropriate list */
|
2012-11-14 19:21:51 +04:00
|
|
|
list_for_each_entry(elem, &nn->sessionid_hashtbl[idx], se_hash) {
|
2009-04-03 09:27:52 +04:00
|
|
|
if (!memcmp(elem->se_sessionid.data, sessionid->data,
|
|
|
|
NFS4_MAX_SESSIONID_LEN)) {
|
|
|
|
return elem;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
dprintk("%s: session not found\n", __func__);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-06-30 19:48:42 +04:00
|
|
|
static struct nfsd4_session *
|
|
|
|
find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net,
|
|
|
|
__be32 *ret)
|
|
|
|
{
|
|
|
|
struct nfsd4_session *session;
|
|
|
|
__be32 status = nfserr_badsession;
|
|
|
|
|
|
|
|
session = __find_in_sessionid_hashtbl(sessionid, net);
|
|
|
|
if (!session)
|
|
|
|
goto out;
|
|
|
|
status = nfsd4_get_session_locked(session);
|
|
|
|
if (status)
|
|
|
|
session = NULL;
|
|
|
|
out:
|
|
|
|
*ret = status;
|
|
|
|
return session;
|
|
|
|
}
|
|
|
|
|
2010-05-12 01:12:26 +04:00
|
|
|
/* caller must hold client_lock */
|
2009-04-03 09:27:43 +04:00
|
|
|
static void
|
2009-04-03 09:27:52 +04:00
|
|
|
unhash_session(struct nfsd4_session *ses)
|
2009-04-03 09:27:43 +04:00
|
|
|
{
|
2014-07-30 16:27:10 +04:00
|
|
|
struct nfs4_client *clp = ses->se_client;
|
|
|
|
struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
|
|
|
|
|
|
|
|
lockdep_assert_held(&nn->client_lock);
|
|
|
|
|
2009-04-03 09:27:43 +04:00
|
|
|
list_del(&ses->se_hash);
|
2010-06-15 22:22:37 +04:00
|
|
|
spin_lock(&ses->se_client->cl_lock);
|
2009-04-03 09:27:43 +04:00
|
|
|
list_del(&ses->se_perclnt);
|
2010-06-15 22:22:37 +04:00
|
|
|
spin_unlock(&ses->se_client->cl_lock);
|
2009-04-03 09:27:52 +04:00
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
|
|
|
|
static int
|
2012-07-25 16:57:45 +04:00
|
|
|
STALE_CLIENTID(clientid_t *clid, struct nfsd_net *nn)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2015-01-20 19:51:26 +03:00
|
|
|
/*
|
|
|
|
* We're assuming the clid was not given out from a boot
|
|
|
|
* precisely 2^32 (about 136 years) before this one. That seems
|
|
|
|
* a safe assumption:
|
|
|
|
*/
|
|
|
|
if (clid->cl_boot == (u32)nn->boot_time)
|
2005-04-17 02:20:36 +04:00
|
|
|
return 0;
|
2020-04-05 18:42:29 +03:00
|
|
|
trace_nfsd_clid_stale(clid);
|
2005-04-17 02:20:36 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX Should we use a slab cache ?
|
|
|
|
* This type of memory management is somewhat inefficient, but we use it
|
|
|
|
* anyway since SETCLIENTID is not a common operation.
|
|
|
|
*/
|
2007-11-22 06:07:08 +03:00
|
|
|
static struct nfs4_client *alloc_client(struct xdr_netobj name)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
struct nfs4_client *clp;
|
2014-07-30 05:34:36 +04:00
|
|
|
int i;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2018-03-16 16:47:22 +03:00
|
|
|
clp = kmem_cache_zalloc(client_slab, GFP_KERNEL);
|
2007-11-22 06:07:08 +03:00
|
|
|
if (clp == NULL)
|
|
|
|
return NULL;
|
2019-06-19 21:30:33 +03:00
|
|
|
xdr_netobj_dup(&clp->cl_name, &name, GFP_KERNEL);
|
2014-07-30 05:34:36 +04:00
|
|
|
if (clp->cl_name.data == NULL)
|
|
|
|
goto err_no_name;
|
treewide: kmalloc() -> kmalloc_array()
The kmalloc() function has a 2-factor argument form, kmalloc_array(). This
patch replaces cases of:
kmalloc(a * b, gfp)
with:
kmalloc_array(a * b, gfp)
as well as handling cases of:
kmalloc(a * b * c, gfp)
with:
kmalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kmalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kmalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The tools/ directory was manually excluded, since it has its own
implementation of kmalloc().
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kmalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kmalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kmalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kmalloc
+ kmalloc_array
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kmalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kmalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kmalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kmalloc(sizeof(THING) * C2, ...)
|
kmalloc(sizeof(TYPE) * C2, ...)
|
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(C1 * C2, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * E2
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 23:55:00 +03:00
|
|
|
clp->cl_ownerstr_hashtbl = kmalloc_array(OWNER_HASH_SIZE,
|
|
|
|
sizeof(struct list_head),
|
|
|
|
GFP_KERNEL);
|
2014-07-30 05:34:36 +04:00
|
|
|
if (!clp->cl_ownerstr_hashtbl)
|
|
|
|
goto err_no_hashtbl;
|
|
|
|
for (i = 0; i < OWNER_HASH_SIZE; i++)
|
|
|
|
INIT_LIST_HEAD(&clp->cl_ownerstr_hashtbl[i]);
|
2014-04-18 22:43:56 +04:00
|
|
|
INIT_LIST_HEAD(&clp->cl_sessions);
|
|
|
|
idr_init(&clp->cl_stateids);
|
2019-03-20 18:54:11 +03:00
|
|
|
atomic_set(&clp->cl_rpc_users, 0);
|
2014-04-18 22:43:56 +04:00
|
|
|
clp->cl_cb_state = NFSD4_CB_UNKNOWN;
|
|
|
|
INIT_LIST_HEAD(&clp->cl_idhash);
|
|
|
|
INIT_LIST_HEAD(&clp->cl_openowners);
|
|
|
|
INIT_LIST_HEAD(&clp->cl_delegations);
|
|
|
|
INIT_LIST_HEAD(&clp->cl_lru);
|
|
|
|
INIT_LIST_HEAD(&clp->cl_revoked);
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 15:11:59 +04:00
|
|
|
#ifdef CONFIG_NFSD_PNFS
|
|
|
|
INIT_LIST_HEAD(&clp->cl_lo_states);
|
|
|
|
#endif
|
2018-07-21 01:19:20 +03:00
|
|
|
INIT_LIST_HEAD(&clp->async_copies);
|
|
|
|
spin_lock_init(&clp->async_lock);
|
2014-04-18 22:43:56 +04:00
|
|
|
spin_lock_init(&clp->cl_lock);
|
|
|
|
rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
|
2005-04-17 02:20:36 +04:00
|
|
|
return clp;
|
2014-07-30 05:34:36 +04:00
|
|
|
err_no_hashtbl:
|
|
|
|
kfree(clp->cl_name.data);
|
|
|
|
err_no_name:
|
2018-03-16 16:47:22 +03:00
|
|
|
kmem_cache_free(client_slab, clp);
|
2014-07-30 05:34:36 +04:00
|
|
|
return NULL;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2019-03-21 03:03:02 +03:00
|
|
|
static void __free_client(struct kref *k)
|
|
|
|
{
|
2019-03-22 18:11:06 +03:00
|
|
|
struct nfsdfs_client *c = container_of(k, struct nfsdfs_client, cl_ref);
|
|
|
|
struct nfs4_client *clp = container_of(c, struct nfs4_client, cl_nfsdfs);
|
2019-03-21 03:03:02 +03:00
|
|
|
|
|
|
|
free_svc_cred(&clp->cl_cred);
|
|
|
|
kfree(clp->cl_ownerstr_hashtbl);
|
|
|
|
kfree(clp->cl_name.data);
|
2019-06-05 19:42:05 +03:00
|
|
|
kfree(clp->cl_nii_domain.data);
|
|
|
|
kfree(clp->cl_nii_name.data);
|
2019-03-21 03:03:02 +03:00
|
|
|
idr_destroy(&clp->cl_stateids);
|
|
|
|
kmem_cache_free(client_slab, clp);
|
|
|
|
}
|
|
|
|
|
2019-07-08 10:29:33 +03:00
|
|
|
static void drop_client(struct nfs4_client *clp)
|
2019-03-21 03:03:02 +03:00
|
|
|
{
|
2019-03-22 18:11:06 +03:00
|
|
|
kref_put(&clp->cl_nfsdfs.cl_ref, __free_client);
|
2019-03-21 03:03:02 +03:00
|
|
|
}
|
|
|
|
|
2014-04-18 22:43:58 +04:00
|
|
|
static void
|
2005-04-17 02:20:36 +04:00
|
|
|
free_client(struct nfs4_client *clp)
|
|
|
|
{
|
2010-10-13 03:55:25 +04:00
|
|
|
while (!list_empty(&clp->cl_sessions)) {
|
|
|
|
struct nfsd4_session *ses;
|
|
|
|
ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
|
|
|
|
se_perclnt);
|
|
|
|
list_del(&ses->se_perclnt);
|
2013-03-19 20:05:39 +04:00
|
|
|
WARN_ON_ONCE(atomic_read(&ses->se_ref));
|
|
|
|
free_session(ses);
|
2010-10-13 03:55:25 +04:00
|
|
|
}
|
2014-04-18 22:43:57 +04:00
|
|
|
rpc_destroy_wait_queue(&clp->cl_cb_waitq);
|
2019-06-19 19:43:11 +03:00
|
|
|
if (clp->cl_nfsd_dentry) {
|
2019-03-22 18:11:06 +03:00
|
|
|
nfsd_client_rmdir(clp->cl_nfsd_dentry);
|
2019-06-19 19:43:11 +03:00
|
|
|
clp->cl_nfsd_dentry = NULL;
|
|
|
|
wake_up_all(&expiry_wq);
|
|
|
|
}
|
2019-03-21 03:03:02 +03:00
|
|
|
drop_client(clp);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2010-05-12 01:13:16 +04:00
|
|
|
/* must be called under the client_lock */
|
2014-07-30 16:27:02 +04:00
|
|
|
static void
|
2010-05-12 01:13:16 +04:00
|
|
|
unhash_client_locked(struct nfs4_client *clp)
|
|
|
|
{
|
2014-07-30 16:27:02 +04:00
|
|
|
struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
|
2010-10-13 03:55:25 +04:00
|
|
|
struct nfsd4_session *ses;
|
|
|
|
|
2014-07-30 16:27:10 +04:00
|
|
|
lockdep_assert_held(&nn->client_lock);
|
|
|
|
|
2014-07-30 16:27:02 +04:00
|
|
|
/* Mark the client as expired! */
|
|
|
|
clp->cl_time = 0;
|
|
|
|
/* Make it invisible */
|
|
|
|
if (!list_empty(&clp->cl_idhash)) {
|
|
|
|
list_del_init(&clp->cl_idhash);
|
|
|
|
if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags))
|
|
|
|
rb_erase(&clp->cl_namenode, &nn->conf_name_tree);
|
|
|
|
else
|
|
|
|
rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
|
|
|
|
}
|
|
|
|
list_del_init(&clp->cl_lru);
|
2010-06-15 22:22:37 +04:00
|
|
|
spin_lock(&clp->cl_lock);
|
2010-10-13 03:55:25 +04:00
|
|
|
list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
|
|
|
|
list_del_init(&ses->se_hash);
|
2010-06-15 22:22:37 +04:00
|
|
|
spin_unlock(&clp->cl_lock);
|
2010-05-12 01:13:16 +04:00
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
static void
|
2014-07-30 16:27:02 +04:00
|
|
|
unhash_client(struct nfs4_client *clp)
|
|
|
|
{
|
|
|
|
struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
|
|
|
|
|
|
|
|
spin_lock(&nn->client_lock);
|
|
|
|
unhash_client_locked(clp);
|
|
|
|
spin_unlock(&nn->client_lock);
|
|
|
|
}
|
|
|
|
|
2014-07-30 16:27:12 +04:00
|
|
|
static __be32 mark_client_expired_locked(struct nfs4_client *clp)
|
|
|
|
{
|
2019-03-20 18:54:11 +03:00
|
|
|
if (atomic_read(&clp->cl_rpc_users))
|
2014-07-30 16:27:12 +04:00
|
|
|
return nfserr_jukebox;
|
|
|
|
unhash_client_locked(clp);
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2014-07-30 16:27:02 +04:00
|
|
|
static void
|
|
|
|
__destroy_client(struct nfs4_client *clp)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2018-03-16 18:32:02 +03:00
|
|
|
int i;
|
2011-07-31 07:33:59 +04:00
|
|
|
struct nfs4_openowner *oo;
|
2005-04-17 02:20:36 +04:00
|
|
|
struct nfs4_delegation *dp;
|
|
|
|
struct list_head reaplist;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&reaplist);
|
2014-05-30 17:09:30 +04:00
|
|
|
spin_lock(&state_lock);
|
2005-06-24 09:04:17 +04:00
|
|
|
while (!list_empty(&clp->cl_delegations)) {
|
|
|
|
dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
|
2015-08-24 19:41:48 +03:00
|
|
|
WARN_ON(!unhash_delegation_locked(dp));
|
2014-07-25 15:34:20 +04:00
|
|
|
list_add(&dp->dl_recall_lru, &reaplist);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2014-05-30 17:09:30 +04:00
|
|
|
spin_unlock(&state_lock);
|
2005-04-17 02:20:36 +04:00
|
|
|
while (!list_empty(&reaplist)) {
|
|
|
|
dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
|
2014-07-25 15:34:20 +04:00
|
|
|
list_del_init(&dp->dl_recall_lru);
|
2018-02-21 23:11:03 +03:00
|
|
|
destroy_unhashed_deleg(dp);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2014-07-25 15:34:21 +04:00
|
|
|
while (!list_empty(&clp->cl_revoked)) {
|
2015-02-26 01:46:27 +03:00
|
|
|
dp = list_entry(clp->cl_revoked.next, struct nfs4_delegation, dl_recall_lru);
|
2014-07-25 15:34:21 +04:00
|
|
|
list_del_init(&dp->dl_recall_lru);
|
2014-07-30 05:34:06 +04:00
|
|
|
nfs4_put_stid(&dp->dl_stid);
|
2013-10-29 13:39:12 +04:00
|
|
|
}
|
2005-06-24 09:04:17 +04:00
|
|
|
while (!list_empty(&clp->cl_openowners)) {
|
2011-07-31 07:33:59 +04:00
|
|
|
oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient);
|
2014-08-22 18:18:43 +04:00
|
|
|
nfs4_get_stateowner(&oo->oo_owner);
|
2011-07-31 07:33:59 +04:00
|
|
|
release_openowner(oo);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2018-03-16 18:32:02 +03:00
|
|
|
for (i = 0; i < OWNER_HASH_SIZE; i++) {
|
|
|
|
struct nfs4_stateowner *so, *tmp;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(so, tmp, &clp->cl_ownerstr_hashtbl[i],
|
|
|
|
so_strhash) {
|
|
|
|
/* Should be no openowners at this point */
|
|
|
|
WARN_ON_ONCE(so->so_is_open_owner);
|
|
|
|
remove_blocked_locks(lockowner(so));
|
|
|
|
}
|
|
|
|
}
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 15:11:59 +04:00
|
|
|
nfsd4_return_all_client_layouts(clp);
|
2018-07-21 01:19:20 +03:00
|
|
|
nfsd4_shutdown_copy(clp);
|
2010-06-05 04:04:45 +04:00
|
|
|
nfsd4_shutdown_callback(clp);
|
2010-05-12 01:13:16 +04:00
|
|
|
if (clp->cl_cb_conn.cb_xprt)
|
|
|
|
svc_xprt_put(clp->cl_cb_conn.cb_xprt);
|
2013-04-02 06:23:49 +04:00
|
|
|
free_client(clp);
|
2019-06-19 19:43:11 +03:00
|
|
|
wake_up_all(&expiry_wq);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2014-07-30 16:27:02 +04:00
|
|
|
static void
|
|
|
|
destroy_client(struct nfs4_client *clp)
|
|
|
|
{
|
|
|
|
unhash_client(clp);
|
|
|
|
__destroy_client(clp);
|
|
|
|
}
|
|
|
|
|
2019-03-27 01:06:28 +03:00
|
|
|
static void inc_reclaim_complete(struct nfs4_client *clp)
|
|
|
|
{
|
|
|
|
struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
|
|
|
|
|
|
|
|
if (!nn->track_reclaim_completes)
|
|
|
|
return;
|
|
|
|
if (!nfsd4_find_reclaim_client(clp->cl_name, nn))
|
|
|
|
return;
|
|
|
|
if (atomic_inc_return(&nn->nr_reclaim_complete) ==
|
|
|
|
nn->reclaim_str_hashtbl_size) {
|
|
|
|
printk(KERN_INFO "NFSD: all clients done reclaiming, ending NFSv4 grace period (net %x)\n",
|
|
|
|
clp->net->ns.inum);
|
|
|
|
nfsd4_end_grace(nn);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-26 19:36:16 +04:00
|
|
|
static void expire_client(struct nfs4_client *clp)
|
|
|
|
{
|
2014-07-30 16:27:02 +04:00
|
|
|
unhash_client(clp);
|
2012-09-26 19:36:16 +04:00
|
|
|
nfsd4_client_record_remove(clp);
|
2014-07-30 16:27:02 +04:00
|
|
|
__destroy_client(clp);
|
2012-09-26 19:36:16 +04:00
|
|
|
}
|
|
|
|
|
2007-11-22 06:07:08 +03:00
|
|
|
static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
|
|
|
|
{
|
|
|
|
memcpy(target->cl_verifier.data, source->data,
|
|
|
|
sizeof(target->cl_verifier.data));
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2007-11-22 06:07:08 +03:00
|
|
|
static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
|
|
|
|
{
|
2005-04-17 02:20:36 +04:00
|
|
|
target->cl_clientid.cl_boot = source->cl_clientid.cl_boot;
|
|
|
|
target->cl_clientid.cl_id = source->cl_clientid.cl_id;
|
|
|
|
}
|
|
|
|
|
2015-11-20 23:58:37 +03:00
|
|
|
static int copy_cred(struct svc_cred *target, struct svc_cred *source)
|
|
|
|
{
|
2017-03-23 11:57:36 +03:00
|
|
|
target->cr_principal = kstrdup(source->cr_principal, GFP_KERNEL);
|
|
|
|
target->cr_raw_principal = kstrdup(source->cr_raw_principal,
|
|
|
|
GFP_KERNEL);
|
2018-08-16 19:05:59 +03:00
|
|
|
target->cr_targ_princ = kstrdup(source->cr_targ_princ, GFP_KERNEL);
|
|
|
|
if ((source->cr_principal && !target->cr_principal) ||
|
|
|
|
(source->cr_raw_principal && !target->cr_raw_principal) ||
|
|
|
|
(source->cr_targ_princ && !target->cr_targ_princ))
|
2017-03-23 11:57:36 +03:00
|
|
|
return -ENOMEM;
|
2015-11-20 23:58:37 +03:00
|
|
|
|
2012-05-15 06:06:49 +04:00
|
|
|
target->cr_flavor = source->cr_flavor;
|
2005-04-17 02:20:36 +04:00
|
|
|
target->cr_uid = source->cr_uid;
|
|
|
|
target->cr_gid = source->cr_gid;
|
|
|
|
target->cr_group_info = source->cr_group_info;
|
|
|
|
get_group_info(target->cr_group_info);
|
2013-05-15 00:07:13 +04:00
|
|
|
target->cr_gss_mech = source->cr_gss_mech;
|
|
|
|
if (source->cr_gss_mech)
|
|
|
|
gss_mech_get(source->cr_gss_mech);
|
2012-05-15 03:55:22 +04:00
|
|
|
return 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2014-12-05 18:40:07 +03:00
|
|
|
static int
|
2012-11-13 00:00:56 +04:00
|
|
|
compare_blob(const struct xdr_netobj *o1, const struct xdr_netobj *o2)
|
|
|
|
{
|
2014-12-05 18:40:07 +03:00
|
|
|
if (o1->len < o2->len)
|
|
|
|
return -1;
|
|
|
|
if (o1->len > o2->len)
|
|
|
|
return 1;
|
|
|
|
return memcmp(o1->data, o2->data, o1->len);
|
2012-11-13 00:00:56 +04:00
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
static int
|
2007-07-27 01:04:54 +04:00
|
|
|
same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
|
|
|
|
{
|
|
|
|
return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2007-07-27 01:04:54 +04:00
|
|
|
same_clid(clientid_t *cl1, clientid_t *cl2)
|
|
|
|
{
|
|
|
|
return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2012-05-15 05:20:54 +04:00
|
|
|
static bool groups_equal(struct group_info *g1, struct group_info *g2)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (g1->ngroups != g2->ngroups)
|
|
|
|
return false;
|
|
|
|
for (i=0; i<g1->ngroups; i++)
|
cred: simpler, 1D supplementary groups
Current supplementary groups code can massively overallocate memory and
is implemented in a way so that access to individual gid is done via 2D
array.
If number of gids is <= 32, memory allocation is more or less tolerable
(140/148 bytes). But if it is not, code allocates full page (!)
regardless and, what's even more fun, doesn't reuse small 32-entry
array.
2D array means dependent shifts, loads and LEAs without possibility to
optimize them (gid is never known at compile time).
All of the above is unnecessary. Switch to the usual
trailing-zero-len-array scheme. Memory is allocated with
kmalloc/vmalloc() and only as much as needed. Accesses become simpler
(LEA 8(gi,idx,4) or even without displacement).
Maximum number of gids is 65536 which translates to 256KB+8 bytes. I
think kernel can handle such allocation.
On my usual desktop system with whole 9 (nine) aux groups, struct
group_info shrinks from 148 bytes to 44 bytes, yay!
Nice side effects:
- "gi->gid[i]" is shorter than "GROUP_AT(gi, i)", less typing,
- fix little mess in net/ipv4/ping.c
should have been using GROUP_AT macro but this point becomes moot,
- aux group allocation is persistent and should be accounted as such.
Link: http://lkml.kernel.org/r/20160817201927.GA2096@p183.telecom.by
Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
Cc: Vasily Kulikov <segoon@openwall.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-10-08 03:03:12 +03:00
|
|
|
if (!gid_eq(g1->gid[i], g2->gid[i]))
|
2012-05-15 05:20:54 +04:00
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-08-21 20:48:30 +04:00
|
|
|
/*
|
|
|
|
* RFC 3530 language requires clid_inuse be returned when the
|
|
|
|
* "principal" associated with a requests differs from that previously
|
|
|
|
* used. We use uid, gid's, and gss principal string as our best
|
|
|
|
* approximation. We also don't want to allow non-gss use of a client
|
|
|
|
* established using gss: in theory cr_principal should catch that
|
|
|
|
* change, but in practice cr_principal can be null even in the gss case
|
|
|
|
* since gssd doesn't always pass down a principal string.
|
|
|
|
*/
|
|
|
|
static bool is_gss_cred(struct svc_cred *cr)
|
|
|
|
{
|
|
|
|
/* Is cr_flavor one of the gss "pseudoflavors"?: */
|
|
|
|
return (cr->cr_flavor > RPC_AUTH_MAXFLAVOR);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-07-24 19:48:20 +04:00
|
|
|
static bool
|
2007-07-27 01:04:54 +04:00
|
|
|
same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
|
|
|
|
{
|
2012-08-21 20:48:30 +04:00
|
|
|
if ((is_gss_cred(cr1) != is_gss_cred(cr2))
|
2013-02-02 18:53:11 +04:00
|
|
|
|| (!uid_eq(cr1->cr_uid, cr2->cr_uid))
|
|
|
|
|| (!gid_eq(cr1->cr_gid, cr2->cr_gid))
|
2012-05-15 05:20:54 +04:00
|
|
|
|| !groups_equal(cr1->cr_group_info, cr2->cr_group_info))
|
|
|
|
return false;
|
2018-08-16 19:05:59 +03:00
|
|
|
/* XXX: check that cr_targ_princ fields match ? */
|
2012-05-15 05:20:54 +04:00
|
|
|
if (cr1->cr_principal == cr2->cr_principal)
|
|
|
|
return true;
|
|
|
|
if (!cr1->cr_principal || !cr2->cr_principal)
|
|
|
|
return false;
|
2012-07-24 19:48:20 +04:00
|
|
|
return 0 == strcmp(cr1->cr_principal, cr2->cr_principal);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2013-04-13 22:27:29 +04:00
|
|
|
static bool svc_rqst_integrity_protected(struct svc_rqst *rqstp)
|
|
|
|
{
|
|
|
|
struct svc_cred *cr = &rqstp->rq_cred;
|
|
|
|
u32 service;
|
|
|
|
|
2013-08-07 19:41:49 +04:00
|
|
|
if (!cr->cr_gss_mech)
|
|
|
|
return false;
|
2013-04-13 22:27:29 +04:00
|
|
|
service = gss_pseudoflavor_to_service(cr->cr_gss_mech, cr->cr_flavor);
|
|
|
|
return service == RPC_GSS_SVC_INTEGRITY ||
|
|
|
|
service == RPC_GSS_SVC_PRIVACY;
|
|
|
|
}
|
|
|
|
|
2016-06-15 19:52:08 +03:00
|
|
|
bool nfsd4_mach_creds_match(struct nfs4_client *cl, struct svc_rqst *rqstp)
|
2013-04-13 22:27:29 +04:00
|
|
|
{
|
|
|
|
struct svc_cred *cr = &rqstp->rq_cred;
|
|
|
|
|
|
|
|
if (!cl->cl_mach_cred)
|
|
|
|
return true;
|
|
|
|
if (cl->cl_cred.cr_gss_mech != cr->cr_gss_mech)
|
|
|
|
return false;
|
|
|
|
if (!svc_rqst_integrity_protected(rqstp))
|
|
|
|
return false;
|
2015-11-20 18:48:02 +03:00
|
|
|
if (cl->cl_cred.cr_raw_principal)
|
|
|
|
return 0 == strcmp(cl->cl_cred.cr_raw_principal,
|
|
|
|
cr->cr_raw_principal);
|
2013-04-13 22:27:29 +04:00
|
|
|
if (!cr->cr_principal)
|
|
|
|
return false;
|
|
|
|
return 0 == strcmp(cl->cl_cred.cr_principal, cr->cr_principal);
|
|
|
|
}
|
|
|
|
|
2014-07-30 16:27:15 +04:00
|
|
|
static void gen_confirm(struct nfs4_client *clp, struct nfsd_net *nn)
|
2007-11-20 04:31:04 +03:00
|
|
|
{
|
2012-03-03 02:13:50 +04:00
|
|
|
__be32 verf[2];
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2014-06-17 15:44:11 +04:00
|
|
|
/*
|
|
|
|
* This is opaque to client, so no need to byte-swap. Use
|
|
|
|
* __force to keep sparse happy
|
|
|
|
*/
|
2019-11-04 18:45:30 +03:00
|
|
|
verf[0] = (__force __be32)(u32)ktime_get_real_seconds();
|
2015-07-18 02:33:31 +03:00
|
|
|
verf[1] = (__force __be32)nn->clverifier_counter++;
|
2012-03-03 02:13:50 +04:00
|
|
|
memcpy(clp->cl_confirm.data, verf, sizeof(clp->cl_confirm.data));
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2014-07-30 16:27:15 +04:00
|
|
|
static void gen_clid(struct nfs4_client *clp, struct nfsd_net *nn)
|
|
|
|
{
|
2019-10-31 17:53:13 +03:00
|
|
|
clp->cl_clientid.cl_boot = (u32)nn->boot_time;
|
2014-07-30 16:27:15 +04:00
|
|
|
clp->cl_clientid.cl_id = nn->clientid_counter++;
|
|
|
|
gen_confirm(clp, nn);
|
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:10 +04:00
|
|
|
static struct nfs4_stid *
|
|
|
|
find_stateid_locked(struct nfs4_client *cl, stateid_t *t)
|
2011-09-06 22:56:09 +04:00
|
|
|
{
|
2013-02-03 21:23:01 +04:00
|
|
|
struct nfs4_stid *ret;
|
|
|
|
|
|
|
|
ret = idr_find(&cl->cl_stateids, t->si_opaque.so_id);
|
|
|
|
if (!ret || !ret->sc_type)
|
|
|
|
return NULL;
|
|
|
|
return ret;
|
2011-09-07 00:48:57 +04:00
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:10 +04:00
|
|
|
static struct nfs4_stid *
|
|
|
|
find_stateid_by_type(struct nfs4_client *cl, stateid_t *t, char typemask)
|
2011-09-09 17:06:12 +04:00
|
|
|
{
|
|
|
|
struct nfs4_stid *s;
|
2011-09-07 00:48:57 +04:00
|
|
|
|
2014-07-30 05:34:10 +04:00
|
|
|
spin_lock(&cl->cl_lock);
|
|
|
|
s = find_stateid_locked(cl, t);
|
2014-07-30 05:34:25 +04:00
|
|
|
if (s != NULL) {
|
|
|
|
if (typemask & s->sc_type)
|
2017-10-20 12:53:28 +03:00
|
|
|
refcount_inc(&s->sc_count);
|
2014-07-30 05:34:25 +04:00
|
|
|
else
|
|
|
|
s = NULL;
|
|
|
|
}
|
2014-07-30 05:34:10 +04:00
|
|
|
spin_unlock(&cl->cl_lock);
|
|
|
|
return s;
|
2011-09-06 22:56:09 +04:00
|
|
|
}
|
|
|
|
|
2019-06-19 19:54:45 +03:00
|
|
|
static struct nfs4_client *get_nfsdfs_clp(struct inode *inode)
|
|
|
|
{
|
|
|
|
struct nfsdfs_client *nc;
|
|
|
|
nc = get_nfsdfs_client(inode);
|
|
|
|
if (!nc)
|
|
|
|
return NULL;
|
|
|
|
return container_of(nc, struct nfs4_client, cl_nfsdfs);
|
|
|
|
}
|
|
|
|
|
2019-06-19 19:39:46 +03:00
|
|
|
static void seq_quote_mem(struct seq_file *m, char *data, int len)
|
|
|
|
{
|
|
|
|
seq_printf(m, "\"");
|
2021-07-01 04:55:43 +03:00
|
|
|
seq_escape_mem(m, data, len, ESCAPE_HEX | ESCAPE_NAP | ESCAPE_APPEND, "\"\\");
|
2019-06-19 19:39:46 +03:00
|
|
|
seq_printf(m, "\"");
|
|
|
|
}
|
|
|
|
|
2021-06-02 20:51:39 +03:00
|
|
|
static const char *cb_state2str(int state)
|
|
|
|
{
|
|
|
|
switch (state) {
|
|
|
|
case NFSD4_CB_UP:
|
|
|
|
return "UP";
|
|
|
|
case NFSD4_CB_UNKNOWN:
|
|
|
|
return "UNKNOWN";
|
|
|
|
case NFSD4_CB_DOWN:
|
|
|
|
return "DOWN";
|
|
|
|
case NFSD4_CB_FAULT:
|
|
|
|
return "FAULT";
|
|
|
|
}
|
|
|
|
return "UNDEFINED";
|
|
|
|
}
|
|
|
|
|
2019-04-09 22:56:57 +03:00
|
|
|
static int client_info_show(struct seq_file *m, void *v)
|
|
|
|
{
|
|
|
|
struct inode *inode = m->private;
|
|
|
|
struct nfs4_client *clp;
|
|
|
|
u64 clid;
|
|
|
|
|
2019-06-19 19:54:45 +03:00
|
|
|
clp = get_nfsdfs_clp(inode);
|
|
|
|
if (!clp)
|
2019-04-09 22:56:57 +03:00
|
|
|
return -ENXIO;
|
|
|
|
memcpy(&clid, &clp->cl_clientid, sizeof(clid));
|
|
|
|
seq_printf(m, "clientid: 0x%llx\n", clid);
|
2019-06-19 19:39:46 +03:00
|
|
|
seq_printf(m, "address: \"%pISpc\"\n", (struct sockaddr *)&clp->cl_addr);
|
2021-03-20 01:38:04 +03:00
|
|
|
if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags))
|
|
|
|
seq_puts(m, "status: confirmed\n");
|
|
|
|
else
|
|
|
|
seq_puts(m, "status: unconfirmed\n");
|
2019-06-19 19:39:46 +03:00
|
|
|
seq_printf(m, "name: ");
|
|
|
|
seq_quote_mem(m, clp->cl_name.data, clp->cl_name.len);
|
|
|
|
seq_printf(m, "\nminor version: %d\n", clp->cl_minorversion);
|
2019-06-05 19:42:05 +03:00
|
|
|
if (clp->cl_nii_domain.data) {
|
|
|
|
seq_printf(m, "Implementation domain: ");
|
|
|
|
seq_quote_mem(m, clp->cl_nii_domain.data,
|
|
|
|
clp->cl_nii_domain.len);
|
|
|
|
seq_printf(m, "\nImplementation name: ");
|
|
|
|
seq_quote_mem(m, clp->cl_nii_name.data, clp->cl_nii_name.len);
|
2019-10-31 16:52:43 +03:00
|
|
|
seq_printf(m, "\nImplementation time: [%lld, %ld]\n",
|
2019-06-05 19:42:05 +03:00
|
|
|
clp->cl_nii_time.tv_sec, clp->cl_nii_time.tv_nsec);
|
|
|
|
}
|
2021-06-02 20:51:39 +03:00
|
|
|
seq_printf(m, "callback state: %s\n", cb_state2str(clp->cl_cb_state));
|
|
|
|
seq_printf(m, "callback address: %pISpc\n", &clp->cl_cb_conn.cb_addr);
|
2019-04-09 22:56:57 +03:00
|
|
|
drop_client(clp);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int client_info_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return single_open(file, client_info_show, inode);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations client_info_fops = {
|
|
|
|
.open = client_info_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
|
|
|
|
2019-04-22 22:26:23 +03:00
|
|
|
static void *states_start(struct seq_file *s, loff_t *pos)
|
|
|
|
__acquires(&clp->cl_lock)
|
|
|
|
{
|
|
|
|
struct nfs4_client *clp = s->private;
|
|
|
|
unsigned long id = *pos;
|
|
|
|
void *ret;
|
|
|
|
|
|
|
|
spin_lock(&clp->cl_lock);
|
|
|
|
ret = idr_get_next_ul(&clp->cl_stateids, &id);
|
|
|
|
*pos = id;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *states_next(struct seq_file *s, void *v, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct nfs4_client *clp = s->private;
|
|
|
|
unsigned long id = *pos;
|
|
|
|
void *ret;
|
|
|
|
|
|
|
|
id = *pos;
|
|
|
|
id++;
|
|
|
|
ret = idr_get_next_ul(&clp->cl_stateids, &id);
|
|
|
|
*pos = id;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void states_stop(struct seq_file *s, void *v)
|
|
|
|
__releases(&clp->cl_lock)
|
|
|
|
{
|
|
|
|
struct nfs4_client *clp = s->private;
|
|
|
|
|
|
|
|
spin_unlock(&clp->cl_lock);
|
|
|
|
}
|
|
|
|
|
2020-04-20 15:50:31 +03:00
|
|
|
static void nfs4_show_fname(struct seq_file *s, struct nfsd_file *f)
|
|
|
|
{
|
|
|
|
seq_printf(s, "filename: \"%pD2\"", f->nf_file);
|
|
|
|
}
|
|
|
|
|
2019-08-18 21:18:52 +03:00
|
|
|
static void nfs4_show_superblock(struct seq_file *s, struct nfsd_file *f)
|
2019-04-22 22:26:23 +03:00
|
|
|
{
|
2019-08-18 21:18:52 +03:00
|
|
|
struct inode *inode = f->nf_inode;
|
2019-04-22 22:26:23 +03:00
|
|
|
|
|
|
|
seq_printf(s, "superblock: \"%02x:%02x:%ld\"",
|
|
|
|
MAJOR(inode->i_sb->s_dev),
|
|
|
|
MINOR(inode->i_sb->s_dev),
|
|
|
|
inode->i_ino);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nfs4_show_owner(struct seq_file *s, struct nfs4_stateowner *oo)
|
|
|
|
{
|
|
|
|
seq_printf(s, "owner: ");
|
|
|
|
seq_quote_mem(s, oo->so_owner.data, oo->so_owner.len);
|
|
|
|
}
|
|
|
|
|
2020-04-14 04:37:19 +03:00
|
|
|
static void nfs4_show_stateid(struct seq_file *s, stateid_t *stid)
|
|
|
|
{
|
2020-04-14 05:03:06 +03:00
|
|
|
seq_printf(s, "0x%.8x", stid->si_generation);
|
|
|
|
seq_printf(s, "%12phN", &stid->si_opaque);
|
2020-04-14 04:37:19 +03:00
|
|
|
}
|
|
|
|
|
2019-04-22 22:26:23 +03:00
|
|
|
static int nfs4_show_open(struct seq_file *s, struct nfs4_stid *st)
|
|
|
|
{
|
|
|
|
struct nfs4_ol_stateid *ols;
|
|
|
|
struct nfs4_file *nf;
|
2019-08-18 21:18:52 +03:00
|
|
|
struct nfsd_file *file;
|
2019-04-22 22:26:23 +03:00
|
|
|
struct nfs4_stateowner *oo;
|
|
|
|
unsigned int access, deny;
|
|
|
|
|
|
|
|
if (st->sc_type != NFS4_OPEN_STID && st->sc_type != NFS4_LOCK_STID)
|
|
|
|
return 0; /* XXX: or SEQ_SKIP? */
|
|
|
|
ols = openlockstateid(st);
|
|
|
|
oo = ols->st_stateowner;
|
|
|
|
nf = st->sc_file;
|
|
|
|
file = find_any_file(nf);
|
2020-07-15 20:31:36 +03:00
|
|
|
if (!file)
|
|
|
|
return 0;
|
2019-04-22 22:26:23 +03:00
|
|
|
|
2020-04-14 04:37:19 +03:00
|
|
|
seq_printf(s, "- ");
|
|
|
|
nfs4_show_stateid(s, &st->sc_stateid);
|
|
|
|
seq_printf(s, ": { type: open, ");
|
2019-04-22 22:26:23 +03:00
|
|
|
|
|
|
|
access = bmap_to_share_mode(ols->st_access_bmap);
|
|
|
|
deny = bmap_to_share_mode(ols->st_deny_bmap);
|
|
|
|
|
2019-10-03 19:33:08 +03:00
|
|
|
seq_printf(s, "access: %s%s, ",
|
2019-04-22 22:26:23 +03:00
|
|
|
access & NFS4_SHARE_ACCESS_READ ? "r" : "-",
|
|
|
|
access & NFS4_SHARE_ACCESS_WRITE ? "w" : "-");
|
2019-10-03 19:33:08 +03:00
|
|
|
seq_printf(s, "deny: %s%s, ",
|
2019-04-22 22:26:23 +03:00
|
|
|
deny & NFS4_SHARE_ACCESS_READ ? "r" : "-",
|
|
|
|
deny & NFS4_SHARE_ACCESS_WRITE ? "w" : "-");
|
|
|
|
|
|
|
|
nfs4_show_superblock(s, file);
|
|
|
|
seq_printf(s, ", ");
|
2020-04-20 15:50:31 +03:00
|
|
|
nfs4_show_fname(s, file);
|
|
|
|
seq_printf(s, ", ");
|
2019-04-22 22:26:23 +03:00
|
|
|
nfs4_show_owner(s, oo);
|
|
|
|
seq_printf(s, " }\n");
|
2019-08-18 21:18:52 +03:00
|
|
|
nfsd_file_put(file);
|
2019-05-10 22:27:50 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nfs4_show_lock(struct seq_file *s, struct nfs4_stid *st)
|
|
|
|
{
|
|
|
|
struct nfs4_ol_stateid *ols;
|
|
|
|
struct nfs4_file *nf;
|
2019-08-18 21:18:52 +03:00
|
|
|
struct nfsd_file *file;
|
2019-05-10 22:27:50 +03:00
|
|
|
struct nfs4_stateowner *oo;
|
|
|
|
|
|
|
|
ols = openlockstateid(st);
|
|
|
|
oo = ols->st_stateowner;
|
|
|
|
nf = st->sc_file;
|
|
|
|
file = find_any_file(nf);
|
2020-07-15 20:31:36 +03:00
|
|
|
if (!file)
|
|
|
|
return 0;
|
2019-05-10 22:27:50 +03:00
|
|
|
|
2020-04-14 04:37:19 +03:00
|
|
|
seq_printf(s, "- ");
|
|
|
|
nfs4_show_stateid(s, &st->sc_stateid);
|
|
|
|
seq_printf(s, ": { type: lock, ");
|
2019-05-10 22:27:50 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Note: a lock stateid isn't really the same thing as a lock,
|
|
|
|
* it's the locking state held by one owner on a file, and there
|
|
|
|
* may be multiple (or no) lock ranges associated with it.
|
|
|
|
* (Same for the matter is true of open stateids.)
|
|
|
|
*/
|
2019-04-22 22:26:23 +03:00
|
|
|
|
2019-05-10 22:27:50 +03:00
|
|
|
nfs4_show_superblock(s, file);
|
|
|
|
/* XXX: open stateid? */
|
|
|
|
seq_printf(s, ", ");
|
2020-04-20 15:50:31 +03:00
|
|
|
nfs4_show_fname(s, file);
|
|
|
|
seq_printf(s, ", ");
|
2019-05-10 22:27:50 +03:00
|
|
|
nfs4_show_owner(s, oo);
|
|
|
|
seq_printf(s, " }\n");
|
2019-08-18 21:18:52 +03:00
|
|
|
nfsd_file_put(file);
|
2019-04-22 22:26:23 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-05-10 22:27:50 +03:00
|
|
|
static int nfs4_show_deleg(struct seq_file *s, struct nfs4_stid *st)
|
|
|
|
{
|
|
|
|
struct nfs4_delegation *ds;
|
|
|
|
struct nfs4_file *nf;
|
2019-08-18 21:18:53 +03:00
|
|
|
struct nfsd_file *file;
|
2019-05-10 22:27:50 +03:00
|
|
|
|
|
|
|
ds = delegstateid(st);
|
|
|
|
nf = st->sc_file;
|
2020-07-15 20:31:36 +03:00
|
|
|
file = find_deleg_file(nf);
|
|
|
|
if (!file)
|
|
|
|
return 0;
|
2019-05-10 22:27:50 +03:00
|
|
|
|
2020-04-14 04:37:19 +03:00
|
|
|
seq_printf(s, "- ");
|
|
|
|
nfs4_show_stateid(s, &st->sc_stateid);
|
|
|
|
seq_printf(s, ": { type: deleg, ");
|
2019-05-10 22:27:50 +03:00
|
|
|
|
|
|
|
/* Kinda dead code as long as we only support read delegs: */
|
|
|
|
seq_printf(s, "access: %s, ",
|
|
|
|
ds->dl_type == NFS4_OPEN_DELEGATE_READ ? "r" : "w");
|
|
|
|
|
|
|
|
/* XXX: lease time, whether it's being recalled. */
|
|
|
|
|
|
|
|
nfs4_show_superblock(s, file);
|
2020-04-20 15:50:31 +03:00
|
|
|
seq_printf(s, ", ");
|
|
|
|
nfs4_show_fname(s, file);
|
2019-05-10 22:27:50 +03:00
|
|
|
seq_printf(s, " }\n");
|
2020-07-15 20:31:36 +03:00
|
|
|
nfsd_file_put(file);
|
2019-05-10 22:27:50 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-05-14 22:52:57 +03:00
|
|
|
static int nfs4_show_layout(struct seq_file *s, struct nfs4_stid *st)
|
|
|
|
{
|
|
|
|
struct nfs4_layout_stateid *ls;
|
2019-08-18 21:18:53 +03:00
|
|
|
struct nfsd_file *file;
|
2019-05-14 22:52:57 +03:00
|
|
|
|
|
|
|
ls = container_of(st, struct nfs4_layout_stateid, ls_stid);
|
|
|
|
file = ls->ls_file;
|
|
|
|
|
2020-04-14 04:37:19 +03:00
|
|
|
seq_printf(s, "- ");
|
|
|
|
nfs4_show_stateid(s, &st->sc_stateid);
|
|
|
|
seq_printf(s, ": { type: layout, ");
|
2019-05-14 22:52:57 +03:00
|
|
|
|
|
|
|
/* XXX: What else would be useful? */
|
|
|
|
|
|
|
|
nfs4_show_superblock(s, file);
|
2020-04-20 15:50:31 +03:00
|
|
|
seq_printf(s, ", ");
|
|
|
|
nfs4_show_fname(s, file);
|
2019-05-14 22:52:57 +03:00
|
|
|
seq_printf(s, " }\n");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-04-22 22:26:23 +03:00
|
|
|
static int states_show(struct seq_file *s, void *v)
|
|
|
|
{
|
|
|
|
struct nfs4_stid *st = v;
|
|
|
|
|
|
|
|
switch (st->sc_type) {
|
|
|
|
case NFS4_OPEN_STID:
|
|
|
|
return nfs4_show_open(s, st);
|
2019-05-10 22:27:50 +03:00
|
|
|
case NFS4_LOCK_STID:
|
|
|
|
return nfs4_show_lock(s, st);
|
|
|
|
case NFS4_DELEG_STID:
|
|
|
|
return nfs4_show_deleg(s, st);
|
2019-05-14 22:52:57 +03:00
|
|
|
case NFS4_LAYOUT_STID:
|
|
|
|
return nfs4_show_layout(s, st);
|
2019-04-22 22:26:23 +03:00
|
|
|
default:
|
|
|
|
return 0; /* XXX: or SEQ_SKIP? */
|
|
|
|
}
|
2019-05-10 22:27:50 +03:00
|
|
|
/* XXX: copy stateids? */
|
2019-04-22 22:26:23 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct seq_operations states_seq_ops = {
|
|
|
|
.start = states_start,
|
|
|
|
.next = states_next,
|
|
|
|
.stop = states_stop,
|
|
|
|
.show = states_show
|
|
|
|
};
|
|
|
|
|
|
|
|
static int client_states_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
struct seq_file *s;
|
|
|
|
struct nfs4_client *clp;
|
|
|
|
int ret;
|
|
|
|
|
2019-06-19 19:54:45 +03:00
|
|
|
clp = get_nfsdfs_clp(inode);
|
|
|
|
if (!clp)
|
2019-04-22 22:26:23 +03:00
|
|
|
return -ENXIO;
|
|
|
|
|
|
|
|
ret = seq_open(file, &states_seq_ops);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
s = file->private_data;
|
|
|
|
s->private = clp;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int client_opens_release(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
struct seq_file *m = file->private_data;
|
|
|
|
struct nfs4_client *clp = m->private;
|
|
|
|
|
|
|
|
/* XXX: alternatively, we could get/drop in seq start/stop */
|
|
|
|
drop_client(clp);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations client_states_fops = {
|
|
|
|
.open = client_states_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = client_opens_release,
|
|
|
|
};
|
|
|
|
|
2019-06-19 19:43:11 +03:00
|
|
|
/*
|
|
|
|
* Normally we refuse to destroy clients that are in use, but here the
|
|
|
|
* administrator is telling us to just do it. We also want to wait
|
|
|
|
* so the caller has a guarantee that the client's locks are gone by
|
|
|
|
* the time the write returns:
|
|
|
|
*/
|
2019-07-08 10:29:33 +03:00
|
|
|
static void force_expire_client(struct nfs4_client *clp)
|
2019-06-19 19:43:11 +03:00
|
|
|
{
|
|
|
|
struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
|
|
|
|
bool already_expired;
|
|
|
|
|
2021-05-14 22:56:06 +03:00
|
|
|
trace_nfsd_clid_admin_expired(&clp->cl_clientid);
|
|
|
|
|
2021-08-12 23:41:43 +03:00
|
|
|
spin_lock(&nn->client_lock);
|
2019-06-19 19:43:11 +03:00
|
|
|
clp->cl_time = 0;
|
2021-08-12 23:41:43 +03:00
|
|
|
spin_unlock(&nn->client_lock);
|
2019-06-19 19:43:11 +03:00
|
|
|
|
|
|
|
wait_event(expiry_wq, atomic_read(&clp->cl_rpc_users) == 0);
|
|
|
|
spin_lock(&nn->client_lock);
|
|
|
|
already_expired = list_empty(&clp->cl_lru);
|
|
|
|
if (!already_expired)
|
|
|
|
unhash_client_locked(clp);
|
|
|
|
spin_unlock(&nn->client_lock);
|
|
|
|
|
|
|
|
if (!already_expired)
|
|
|
|
expire_client(clp);
|
|
|
|
else
|
|
|
|
wait_event(expiry_wq, clp->cl_nfsd_dentry == NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t client_ctl_write(struct file *file, const char __user *buf,
|
|
|
|
size_t size, loff_t *pos)
|
|
|
|
{
|
|
|
|
char *data;
|
|
|
|
struct nfs4_client *clp;
|
|
|
|
|
|
|
|
data = simple_transaction_get(file, buf, size);
|
|
|
|
if (IS_ERR(data))
|
|
|
|
return PTR_ERR(data);
|
|
|
|
if (size != 7 || 0 != memcmp(data, "expire\n", 7))
|
|
|
|
return -EINVAL;
|
|
|
|
clp = get_nfsdfs_clp(file_inode(file));
|
|
|
|
if (!clp)
|
|
|
|
return -ENXIO;
|
|
|
|
force_expire_client(clp);
|
|
|
|
drop_client(clp);
|
|
|
|
return 7;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations client_ctl_fops = {
|
|
|
|
.write = client_ctl_write,
|
|
|
|
.release = simple_transaction_release,
|
|
|
|
};
|
|
|
|
|
2019-04-09 22:56:57 +03:00
|
|
|
static const struct tree_descr client_files[] = {
|
|
|
|
[0] = {"info", &client_info_fops, S_IRUSR},
|
2019-04-22 22:26:23 +03:00
|
|
|
[1] = {"states", &client_states_fops, S_IRUSR},
|
2020-03-13 15:39:57 +03:00
|
|
|
[2] = {"ctl", &client_ctl_fops, S_IWUSR},
|
2019-04-22 22:26:23 +03:00
|
|
|
[3] = {""},
|
2019-04-09 22:56:57 +03:00
|
|
|
};
|
|
|
|
|
2012-11-13 00:00:57 +04:00
|
|
|
static struct nfs4_client *create_client(struct xdr_netobj name,
|
2009-09-10 13:27:34 +04:00
|
|
|
struct svc_rqst *rqstp, nfs4_verifier *verf)
|
|
|
|
{
|
|
|
|
struct nfs4_client *clp;
|
|
|
|
struct sockaddr *sa = svc_addr(rqstp);
|
2012-05-15 03:55:22 +04:00
|
|
|
int ret;
|
2012-11-14 19:21:10 +04:00
|
|
|
struct net *net = SVC_NET(rqstp);
|
2019-03-22 18:11:06 +03:00
|
|
|
struct nfsd_net *nn = net_generic(net, nfsd_net_id);
|
2021-03-20 01:38:04 +03:00
|
|
|
struct dentry *dentries[ARRAY_SIZE(client_files)];
|
2009-09-10 13:27:34 +04:00
|
|
|
|
|
|
|
clp = alloc_client(name);
|
|
|
|
if (clp == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2012-05-15 03:55:22 +04:00
|
|
|
ret = copy_cred(&clp->cl_cred, &rqstp->rq_cred);
|
|
|
|
if (ret) {
|
|
|
|
free_client(clp);
|
|
|
|
return NULL;
|
2009-09-10 13:27:34 +04:00
|
|
|
}
|
2019-03-22 18:11:06 +03:00
|
|
|
gen_clid(clp, nn);
|
|
|
|
kref_init(&clp->cl_nfsdfs.cl_ref);
|
2014-09-24 14:19:19 +04:00
|
|
|
nfsd4_init_cb(&clp->cl_cb_null, clp, NULL, NFSPROC4_CLNT_CB_NULL);
|
2019-11-04 18:31:52 +03:00
|
|
|
clp->cl_time = ktime_get_boottime_seconds();
|
2009-09-10 13:27:34 +04:00
|
|
|
clear_bit(0, &clp->cl_cb_slot_busy);
|
|
|
|
copy_verf(clp, verf);
|
2019-05-15 04:38:11 +03:00
|
|
|
memcpy(&clp->cl_addr, sa, sizeof(struct sockaddr_storage));
|
2010-06-15 06:26:31 +04:00
|
|
|
clp->cl_cb_session = NULL;
|
2012-11-14 19:21:10 +04:00
|
|
|
clp->net = net;
|
2021-03-20 01:38:04 +03:00
|
|
|
clp->cl_nfsd_dentry = nfsd_client_mkdir(
|
|
|
|
nn, &clp->cl_nfsdfs,
|
|
|
|
clp->cl_clientid.cl_id - nn->clientid_base,
|
|
|
|
client_files, dentries);
|
|
|
|
clp->cl_nfsd_info_dentry = dentries[0];
|
2019-03-22 18:11:06 +03:00
|
|
|
if (!clp->cl_nfsd_dentry) {
|
|
|
|
free_client(clp);
|
|
|
|
return NULL;
|
|
|
|
}
|
2009-09-10 13:27:34 +04:00
|
|
|
return clp;
|
|
|
|
}
|
|
|
|
|
2005-06-24 09:04:03 +04:00
|
|
|
static void
|
2012-11-13 00:00:56 +04:00
|
|
|
add_clp_to_name_tree(struct nfs4_client *new_clp, struct rb_root *root)
|
|
|
|
{
|
|
|
|
struct rb_node **new = &(root->rb_node), *parent = NULL;
|
|
|
|
struct nfs4_client *clp;
|
|
|
|
|
|
|
|
while (*new) {
|
|
|
|
clp = rb_entry(*new, struct nfs4_client, cl_namenode);
|
|
|
|
parent = *new;
|
|
|
|
|
|
|
|
if (compare_blob(&clp->cl_name, &new_clp->cl_name) > 0)
|
|
|
|
new = &((*new)->rb_left);
|
|
|
|
else
|
|
|
|
new = &((*new)->rb_right);
|
|
|
|
}
|
|
|
|
|
|
|
|
rb_link_node(&new_clp->cl_namenode, parent, new);
|
|
|
|
rb_insert_color(&new_clp->cl_namenode, root);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct nfs4_client *
|
|
|
|
find_clp_in_name_tree(struct xdr_netobj *name, struct rb_root *root)
|
|
|
|
{
|
2014-12-05 18:40:07 +03:00
|
|
|
int cmp;
|
2012-11-13 00:00:56 +04:00
|
|
|
struct rb_node *node = root->rb_node;
|
|
|
|
struct nfs4_client *clp;
|
|
|
|
|
|
|
|
while (node) {
|
|
|
|
clp = rb_entry(node, struct nfs4_client, cl_namenode);
|
|
|
|
cmp = compare_blob(&clp->cl_name, name);
|
|
|
|
if (cmp > 0)
|
|
|
|
node = node->rb_left;
|
|
|
|
else if (cmp < 0)
|
|
|
|
node = node->rb_right;
|
|
|
|
else
|
|
|
|
return clp;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
add_to_unconfirmed(struct nfs4_client *clp)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
unsigned int idhashval;
|
2012-11-14 19:21:31 +04:00
|
|
|
struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2014-07-30 16:27:10 +04:00
|
|
|
lockdep_assert_held(&nn->client_lock);
|
|
|
|
|
2012-11-13 00:00:56 +04:00
|
|
|
clear_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
|
2012-11-14 19:21:36 +04:00
|
|
|
add_clp_to_name_tree(clp, &nn->unconf_name_tree);
|
2005-04-17 02:20:36 +04:00
|
|
|
idhashval = clientid_hashval(clp->cl_clientid.cl_id);
|
2012-11-14 19:21:31 +04:00
|
|
|
list_add(&clp->cl_idhash, &nn->unconf_id_hashtbl[idhashval]);
|
2014-07-30 16:27:06 +04:00
|
|
|
renew_client_locked(clp);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2005-06-24 09:04:03 +04:00
|
|
|
static void
|
2005-04-17 02:20:36 +04:00
|
|
|
move_to_confirmed(struct nfs4_client *clp)
|
|
|
|
{
|
|
|
|
unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
|
2012-11-14 19:21:21 +04:00
|
|
|
struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2014-07-30 16:27:10 +04:00
|
|
|
lockdep_assert_held(&nn->client_lock);
|
|
|
|
|
2012-11-14 19:21:21 +04:00
|
|
|
list_move(&clp->cl_idhash, &nn->conf_id_hashtbl[idhashval]);
|
2012-11-14 19:21:36 +04:00
|
|
|
rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
|
2012-11-14 19:21:26 +04:00
|
|
|
add_clp_to_name_tree(clp, &nn->conf_name_tree);
|
2021-05-25 21:53:44 +03:00
|
|
|
set_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
|
|
|
|
trace_nfsd_clid_confirmed(&clp->cl_clientid);
|
2014-07-30 16:27:06 +04:00
|
|
|
renew_client_locked(clp);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct nfs4_client *
|
2013-03-15 02:24:52 +04:00
|
|
|
find_client_in_id_table(struct list_head *tbl, clientid_t *clid, bool sessions)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
struct nfs4_client *clp;
|
|
|
|
unsigned int idhashval = clientid_hashval(clid->cl_id);
|
|
|
|
|
2013-03-15 02:24:52 +04:00
|
|
|
list_for_each_entry(clp, &tbl[idhashval], cl_idhash) {
|
2011-10-13 00:24:27 +04:00
|
|
|
if (same_clid(&clp->cl_clientid, clid)) {
|
2012-09-14 00:19:31 +04:00
|
|
|
if ((bool)clp->cl_minorversion != sessions)
|
|
|
|
return NULL;
|
2014-07-30 16:27:06 +04:00
|
|
|
renew_client_locked(clp);
|
2005-04-17 02:20:36 +04:00
|
|
|
return clp;
|
2011-10-13 00:24:27 +04:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-03-15 02:24:52 +04:00
|
|
|
static struct nfs4_client *
|
|
|
|
find_confirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
|
|
|
|
{
|
|
|
|
struct list_head *tbl = nn->conf_id_hashtbl;
|
|
|
|
|
2014-07-30 16:27:10 +04:00
|
|
|
lockdep_assert_held(&nn->client_lock);
|
2013-03-15 02:24:52 +04:00
|
|
|
return find_client_in_id_table(tbl, clid, sessions);
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
static struct nfs4_client *
|
2012-11-14 19:21:31 +04:00
|
|
|
find_unconfirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2013-03-15 02:24:52 +04:00
|
|
|
struct list_head *tbl = nn->unconf_id_hashtbl;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2014-07-30 16:27:10 +04:00
|
|
|
lockdep_assert_held(&nn->client_lock);
|
2013-03-15 02:24:52 +04:00
|
|
|
return find_client_in_id_table(tbl, clid, sessions);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2010-11-25 01:17:34 +03:00
|
|
|
static bool clp_used_exchangeid(struct nfs4_client *clp)
|
2009-04-03 09:28:05 +04:00
|
|
|
{
|
2010-11-25 01:17:34 +03:00
|
|
|
return clp->cl_exchange_flags != 0;
|
2010-11-25 01:30:54 +03:00
|
|
|
}
|
2009-04-03 09:28:05 +04:00
|
|
|
|
2005-06-24 09:03:56 +04:00
|
|
|
static struct nfs4_client *
|
2012-11-14 19:21:26 +04:00
|
|
|
find_confirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
|
2005-06-24 09:03:56 +04:00
|
|
|
{
|
2014-07-30 16:27:10 +04:00
|
|
|
lockdep_assert_held(&nn->client_lock);
|
2012-11-14 19:21:26 +04:00
|
|
|
return find_clp_in_name_tree(name, &nn->conf_name_tree);
|
2005-06-24 09:03:56 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct nfs4_client *
|
2012-11-14 19:21:36 +04:00
|
|
|
find_unconfirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
|
2005-06-24 09:03:56 +04:00
|
|
|
{
|
2014-07-30 16:27:10 +04:00
|
|
|
lockdep_assert_held(&nn->client_lock);
|
2012-11-14 19:21:36 +04:00
|
|
|
return find_clp_in_name_tree(name, &nn->unconf_name_tree);
|
2005-06-24 09:03:56 +04:00
|
|
|
}
|
|
|
|
|
2005-06-24 09:04:03 +04:00
|
|
|
static void
|
2010-12-15 08:09:01 +03:00
|
|
|
gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2010-06-01 03:09:40 +04:00
|
|
|
struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
|
2010-12-15 08:09:01 +03:00
|
|
|
struct sockaddr *sa = svc_addr(rqstp);
|
|
|
|
u32 scopeid = rpc_get_scope_id(sa);
|
2009-08-14 20:57:58 +04:00
|
|
|
unsigned short expected_family;
|
|
|
|
|
|
|
|
/* Currently, we only support tcp and tcp6 for the callback channel */
|
|
|
|
if (se->se_callback_netid_len == 3 &&
|
|
|
|
!memcmp(se->se_callback_netid_val, "tcp", 3))
|
|
|
|
expected_family = AF_INET;
|
|
|
|
else if (se->se_callback_netid_len == 4 &&
|
|
|
|
!memcmp(se->se_callback_netid_val, "tcp6", 4))
|
|
|
|
expected_family = AF_INET6;
|
|
|
|
else
|
2005-04-17 02:20:36 +04:00
|
|
|
goto out_err;
|
|
|
|
|
2012-11-14 19:21:10 +04:00
|
|
|
conn->cb_addrlen = rpc_uaddr2sockaddr(clp->net, se->se_callback_addr_val,
|
2009-08-14 20:57:57 +04:00
|
|
|
se->se_callback_addr_len,
|
2010-06-01 03:09:40 +04:00
|
|
|
(struct sockaddr *)&conn->cb_addr,
|
|
|
|
sizeof(conn->cb_addr));
|
2009-08-14 20:57:57 +04:00
|
|
|
|
2010-06-01 03:09:40 +04:00
|
|
|
if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
|
2005-04-17 02:20:36 +04:00
|
|
|
goto out_err;
|
2009-08-14 20:57:57 +04:00
|
|
|
|
2010-06-01 03:09:40 +04:00
|
|
|
if (conn->cb_addr.ss_family == AF_INET6)
|
|
|
|
((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
|
2009-08-14 20:57:59 +04:00
|
|
|
|
2010-06-01 03:09:40 +04:00
|
|
|
conn->cb_prog = se->se_callback_prog;
|
|
|
|
conn->cb_ident = se->se_callback_ident;
|
2011-08-30 13:18:41 +04:00
|
|
|
memcpy(&conn->cb_saddr, &rqstp->rq_daddr, rqstp->rq_daddrlen);
|
2020-04-05 21:15:29 +03:00
|
|
|
trace_nfsd_cb_args(clp, conn);
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
out_err:
|
2010-06-01 03:09:40 +04:00
|
|
|
conn->cb_addr.ss_family = AF_UNSPEC;
|
|
|
|
conn->cb_addrlen = 0;
|
2020-04-05 21:15:29 +03:00
|
|
|
trace_nfsd_cb_nodelegs(clp);
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-04-03 09:28:15 +04:00
|
|
|
/*
|
2014-03-22 01:26:44 +04:00
|
|
|
* Cache a reply. nfsd4_check_resp_size() has bounded the cache size.
|
2009-04-03 09:28:15 +04:00
|
|
|
*/
|
2014-06-30 19:48:35 +04:00
|
|
|
static void
|
2009-04-03 09:28:15 +04:00
|
|
|
nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
|
|
|
|
{
|
2020-10-27 22:53:42 +03:00
|
|
|
struct xdr_buf *buf = resp->xdr->buf;
|
2009-08-28 16:45:04 +04:00
|
|
|
struct nfsd4_slot *slot = resp->cstate.slot;
|
|
|
|
unsigned int base;
|
2009-04-03 09:28:15 +04:00
|
|
|
|
2009-08-28 16:45:04 +04:00
|
|
|
dprintk("--> %s slot %p\n", __func__, slot);
|
2009-04-03 09:28:15 +04:00
|
|
|
|
nfsd4: fix cached replies to solo SEQUENCE compounds
Currently our handling of 4.1+ requests without "cachethis" set is
confusing and not quite correct.
Suppose a client sends a compound consisting of only a single SEQUENCE
op, and it matches the seqid in a session slot (so it's a retry), but
the previous request with that seqid did not have "cachethis" set.
The obvious thing to do might be to return NFS4ERR_RETRY_UNCACHED_REP,
but the protocol only allows that to be returned on the op following the
SEQUENCE, and there is no such op in this case.
The protocol permits us to cache replies even if the client didn't ask
us to. And it's easy to do so in the case of solo SEQUENCE compounds.
So, when we get a solo SEQUENCE, we can either return the previously
cached reply or NFSERR_SEQ_FALSE_RETRY if we notice it differs in some
way from the original call.
Currently, we're returning a corrupt reply in the case a solo SEQUENCE
matches a previous compound with more ops. This actually matters
because the Linux client recently started doing this as a way to recover
from lost replies to idempotent operations in the case the process doing
the original reply was killed: in that case it's difficult to keep the
original arguments around to do a real retry, and the client no longer
cares what the result is anyway, but it would like to make sure that the
slot's sequence id has been incremented, and the solo SEQUENCE assures
that: if the server never got the original reply, it will increment the
sequence id. If it did get the original reply, it won't increment, and
nothing else that about the reply really matters much. But we can at
least attempt to return valid xdr!
Tested-by: Olga Kornievskaia <aglo@umich.edu>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2017-10-18 23:17:18 +03:00
|
|
|
slot->sl_flags |= NFSD4_SLOT_INITIALIZED;
|
2009-08-28 16:45:04 +04:00
|
|
|
slot->sl_opcnt = resp->opcnt;
|
|
|
|
slot->sl_status = resp->cstate.status;
|
2017-10-18 03:38:49 +03:00
|
|
|
free_svc_cred(&slot->sl_cred);
|
|
|
|
copy_cred(&slot->sl_cred, &resp->rqstp->rq_cred);
|
2009-04-03 09:28:15 +04:00
|
|
|
|
nfsd4: fix cached replies to solo SEQUENCE compounds
Currently our handling of 4.1+ requests without "cachethis" set is
confusing and not quite correct.
Suppose a client sends a compound consisting of only a single SEQUENCE
op, and it matches the seqid in a session slot (so it's a retry), but
the previous request with that seqid did not have "cachethis" set.
The obvious thing to do might be to return NFS4ERR_RETRY_UNCACHED_REP,
but the protocol only allows that to be returned on the op following the
SEQUENCE, and there is no such op in this case.
The protocol permits us to cache replies even if the client didn't ask
us to. And it's easy to do so in the case of solo SEQUENCE compounds.
So, when we get a solo SEQUENCE, we can either return the previously
cached reply or NFSERR_SEQ_FALSE_RETRY if we notice it differs in some
way from the original call.
Currently, we're returning a corrupt reply in the case a solo SEQUENCE
matches a previous compound with more ops. This actually matters
because the Linux client recently started doing this as a way to recover
from lost replies to idempotent operations in the case the process doing
the original reply was killed: in that case it's difficult to keep the
original arguments around to do a real retry, and the client no longer
cares what the result is anyway, but it would like to make sure that the
slot's sequence id has been incremented, and the solo SEQUENCE assures
that: if the server never got the original reply, it will increment the
sequence id. If it did get the original reply, it won't increment, and
nothing else that about the reply really matters much. But we can at
least attempt to return valid xdr!
Tested-by: Olga Kornievskaia <aglo@umich.edu>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2017-10-18 23:17:18 +03:00
|
|
|
if (!nfsd4_cache_this(resp)) {
|
|
|
|
slot->sl_flags &= ~NFSD4_SLOT_CACHED;
|
2009-04-03 09:28:35 +04:00
|
|
|
return;
|
2009-04-03 09:28:15 +04:00
|
|
|
}
|
nfsd4: fix cached replies to solo SEQUENCE compounds
Currently our handling of 4.1+ requests without "cachethis" set is
confusing and not quite correct.
Suppose a client sends a compound consisting of only a single SEQUENCE
op, and it matches the seqid in a session slot (so it's a retry), but
the previous request with that seqid did not have "cachethis" set.
The obvious thing to do might be to return NFS4ERR_RETRY_UNCACHED_REP,
but the protocol only allows that to be returned on the op following the
SEQUENCE, and there is no such op in this case.
The protocol permits us to cache replies even if the client didn't ask
us to. And it's easy to do so in the case of solo SEQUENCE compounds.
So, when we get a solo SEQUENCE, we can either return the previously
cached reply or NFSERR_SEQ_FALSE_RETRY if we notice it differs in some
way from the original call.
Currently, we're returning a corrupt reply in the case a solo SEQUENCE
matches a previous compound with more ops. This actually matters
because the Linux client recently started doing this as a way to recover
from lost replies to idempotent operations in the case the process doing
the original reply was killed: in that case it's difficult to keep the
original arguments around to do a real retry, and the client no longer
cares what the result is anyway, but it would like to make sure that the
slot's sequence id has been incremented, and the solo SEQUENCE assures
that: if the server never got the original reply, it will increment the
sequence id. If it did get the original reply, it won't increment, and
nothing else that about the reply really matters much. But we can at
least attempt to return valid xdr!
Tested-by: Olga Kornievskaia <aglo@umich.edu>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2017-10-18 23:17:18 +03:00
|
|
|
slot->sl_flags |= NFSD4_SLOT_CACHED;
|
|
|
|
|
2014-03-22 01:57:57 +04:00
|
|
|
base = resp->cstate.data_offset;
|
|
|
|
slot->sl_datalen = buf->len - base;
|
|
|
|
if (read_bytes_from_xdr_buf(buf, base, slot->sl_data, slot->sl_datalen))
|
2015-11-21 13:28:50 +03:00
|
|
|
WARN(1, "%s: sessions DRC could not cache compound\n",
|
|
|
|
__func__);
|
2009-08-28 16:45:04 +04:00
|
|
|
return;
|
2009-04-03 09:28:15 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2009-07-24 03:02:18 +04:00
|
|
|
* Encode the replay sequence operation from the slot values.
|
|
|
|
* If cachethis is FALSE encode the uncached rep error on the next
|
|
|
|
* operation which sets resp->p and increments resp->opcnt for
|
|
|
|
* nfs4svc_encode_compoundres.
|
2009-04-03 09:28:15 +04:00
|
|
|
*
|
|
|
|
*/
|
2009-07-24 03:02:18 +04:00
|
|
|
static __be32
|
|
|
|
nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
|
|
|
|
struct nfsd4_compoundres *resp)
|
2009-04-03 09:28:15 +04:00
|
|
|
{
|
2009-07-24 03:02:18 +04:00
|
|
|
struct nfsd4_op *op;
|
|
|
|
struct nfsd4_slot *slot = resp->cstate.slot;
|
2009-04-03 09:28:35 +04:00
|
|
|
|
2009-07-24 03:02:18 +04:00
|
|
|
/* Encode the replayed sequence operation */
|
|
|
|
op = &args->ops[resp->opcnt - 1];
|
|
|
|
nfsd4_encode_operation(resp, op);
|
2009-04-03 09:28:35 +04:00
|
|
|
|
nfsd4: fix cached replies to solo SEQUENCE compounds
Currently our handling of 4.1+ requests without "cachethis" set is
confusing and not quite correct.
Suppose a client sends a compound consisting of only a single SEQUENCE
op, and it matches the seqid in a session slot (so it's a retry), but
the previous request with that seqid did not have "cachethis" set.
The obvious thing to do might be to return NFS4ERR_RETRY_UNCACHED_REP,
but the protocol only allows that to be returned on the op following the
SEQUENCE, and there is no such op in this case.
The protocol permits us to cache replies even if the client didn't ask
us to. And it's easy to do so in the case of solo SEQUENCE compounds.
So, when we get a solo SEQUENCE, we can either return the previously
cached reply or NFSERR_SEQ_FALSE_RETRY if we notice it differs in some
way from the original call.
Currently, we're returning a corrupt reply in the case a solo SEQUENCE
matches a previous compound with more ops. This actually matters
because the Linux client recently started doing this as a way to recover
from lost replies to idempotent operations in the case the process doing
the original reply was killed: in that case it's difficult to keep the
original arguments around to do a real retry, and the client no longer
cares what the result is anyway, but it would like to make sure that the
slot's sequence id has been incremented, and the solo SEQUENCE assures
that: if the server never got the original reply, it will increment the
sequence id. If it did get the original reply, it won't increment, and
nothing else that about the reply really matters much. But we can at
least attempt to return valid xdr!
Tested-by: Olga Kornievskaia <aglo@umich.edu>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2017-10-18 23:17:18 +03:00
|
|
|
if (slot->sl_flags & NFSD4_SLOT_CACHED)
|
|
|
|
return op->status;
|
|
|
|
if (args->opcnt == 1) {
|
|
|
|
/*
|
|
|
|
* The original operation wasn't a solo sequence--we
|
|
|
|
* always cache those--so this retry must not match the
|
|
|
|
* original:
|
|
|
|
*/
|
|
|
|
op->status = nfserr_seq_false_retry;
|
|
|
|
} else {
|
2009-07-24 03:02:18 +04:00
|
|
|
op = &args->ops[resp->opcnt++];
|
|
|
|
op->status = nfserr_retry_uncached_rep;
|
|
|
|
nfsd4_encode_operation(resp, op);
|
2009-04-03 09:28:15 +04:00
|
|
|
}
|
2009-07-24 03:02:18 +04:00
|
|
|
return op->status;
|
2009-04-03 09:28:15 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2009-08-28 16:45:04 +04:00
|
|
|
* The sequence operation is not cached because we can use the slot and
|
|
|
|
* session values.
|
2009-04-03 09:28:15 +04:00
|
|
|
*/
|
2014-03-21 20:04:21 +04:00
|
|
|
static __be32
|
2009-04-03 09:28:35 +04:00
|
|
|
nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
|
|
|
|
struct nfsd4_sequence *seq)
|
2009-04-03 09:28:15 +04:00
|
|
|
{
|
2009-08-28 16:45:04 +04:00
|
|
|
struct nfsd4_slot *slot = resp->cstate.slot;
|
2020-10-27 22:53:42 +03:00
|
|
|
struct xdr_stream *xdr = resp->xdr;
|
2014-03-22 01:57:57 +04:00
|
|
|
__be32 *p;
|
2009-04-03 09:28:15 +04:00
|
|
|
__be32 status;
|
|
|
|
|
2009-08-28 16:45:04 +04:00
|
|
|
dprintk("--> %s slot %p\n", __func__, slot);
|
2009-04-03 09:28:15 +04:00
|
|
|
|
2009-07-24 03:02:18 +04:00
|
|
|
status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
|
2014-03-21 19:43:34 +04:00
|
|
|
if (status)
|
2009-07-24 03:02:18 +04:00
|
|
|
return status;
|
2009-04-03 09:28:15 +04:00
|
|
|
|
2014-03-22 01:57:57 +04:00
|
|
|
p = xdr_reserve_space(xdr, slot->sl_datalen);
|
|
|
|
if (!p) {
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
return nfserr_serverfault;
|
|
|
|
}
|
|
|
|
xdr_encode_opaque_fixed(p, slot->sl_data, slot->sl_datalen);
|
|
|
|
xdr_commit_encode(xdr);
|
2009-04-03 09:28:15 +04:00
|
|
|
|
2009-08-28 16:45:04 +04:00
|
|
|
resp->opcnt = slot->sl_opcnt;
|
2014-03-22 01:57:57 +04:00
|
|
|
return slot->sl_status;
|
2009-04-03 09:28:15 +04:00
|
|
|
}
|
|
|
|
|
2009-04-03 09:28:01 +04:00
|
|
|
/*
|
|
|
|
* Set the exchange_id flags returned by the server.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
|
|
|
|
{
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 15:11:59 +04:00
|
|
|
#ifdef CONFIG_NFSD_PNFS
|
|
|
|
new->cl_exchange_flags |= EXCHGID4_FLAG_USE_PNFS_MDS;
|
|
|
|
#else
|
2009-04-03 09:28:01 +04:00
|
|
|
new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 15:11:59 +04:00
|
|
|
#endif
|
2009-04-03 09:28:01 +04:00
|
|
|
|
|
|
|
/* Referrals are supported, Migration is not. */
|
|
|
|
new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
|
|
|
|
|
|
|
|
/* set the wire flags to return to client. */
|
|
|
|
clid->flags = new->cl_exchange_flags;
|
|
|
|
}
|
|
|
|
|
2015-10-15 23:11:01 +03:00
|
|
|
static bool client_has_openowners(struct nfs4_client *clp)
|
|
|
|
{
|
|
|
|
struct nfs4_openowner *oo;
|
|
|
|
|
|
|
|
list_for_each_entry(oo, &clp->cl_openowners, oo_perclient) {
|
|
|
|
if (!list_empty(&oo->oo_owner.so_stateids))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-05-14 23:57:23 +04:00
|
|
|
static bool client_has_state(struct nfs4_client *clp)
|
|
|
|
{
|
2015-10-15 23:11:01 +03:00
|
|
|
return client_has_openowners(clp)
|
2015-07-21 08:09:17 +03:00
|
|
|
#ifdef CONFIG_NFSD_PNFS
|
|
|
|
|| !list_empty(&clp->cl_lo_states)
|
|
|
|
#endif
|
2012-05-30 00:37:44 +04:00
|
|
|
|| !list_empty(&clp->cl_delegations)
|
2018-07-21 01:19:20 +03:00
|
|
|
|| !list_empty(&clp->cl_sessions)
|
|
|
|
|| !list_empty(&clp->async_copies);
|
2012-05-14 23:57:23 +04:00
|
|
|
}
|
|
|
|
|
2019-06-05 19:42:05 +03:00
|
|
|
static __be32 copy_impl_id(struct nfs4_client *clp,
|
|
|
|
struct nfsd4_exchange_id *exid)
|
|
|
|
{
|
|
|
|
if (!exid->nii_domain.data)
|
|
|
|
return 0;
|
|
|
|
xdr_netobj_dup(&clp->cl_nii_domain, &exid->nii_domain, GFP_KERNEL);
|
|
|
|
if (!clp->cl_nii_domain.data)
|
|
|
|
return nfserr_jukebox;
|
|
|
|
xdr_netobj_dup(&clp->cl_nii_name, &exid->nii_name, GFP_KERNEL);
|
|
|
|
if (!clp->cl_nii_name.data)
|
|
|
|
return nfserr_jukebox;
|
2019-10-31 16:52:43 +03:00
|
|
|
clp->cl_nii_time = exid->nii_time;
|
2019-06-05 19:42:05 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-04-03 09:27:58 +04:00
|
|
|
__be32
|
2017-05-08 21:58:35 +03:00
|
|
|
nfsd4_exchange_id(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
2009-04-03 09:27:58 +04:00
|
|
|
{
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_exchange_id *exid = &u->exchange_id;
|
2014-07-30 16:27:06 +04:00
|
|
|
struct nfs4_client *conf, *new;
|
|
|
|
struct nfs4_client *unconf = NULL;
|
2012-04-26 01:58:50 +04:00
|
|
|
__be32 status;
|
2009-08-14 20:57:56 +04:00
|
|
|
char addr_str[INET6_ADDRSTRLEN];
|
2009-04-03 09:28:01 +04:00
|
|
|
nfs4_verifier verf = exid->verifier;
|
2009-08-14 20:57:56 +04:00
|
|
|
struct sockaddr *sa = svc_addr(rqstp);
|
2012-05-14 17:08:10 +04:00
|
|
|
bool update = exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A;
|
2012-11-14 19:21:10 +04:00
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
2009-04-03 09:28:01 +04:00
|
|
|
|
2009-08-14 20:57:56 +04:00
|
|
|
rpc_ntop(sa, addr_str, sizeof(addr_str));
|
2009-04-03 09:28:01 +04:00
|
|
|
dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
|
2020-11-02 23:19:12 +03:00
|
|
|
"ip_addr=%s flags %x, spa_how %u\n",
|
2009-04-03 09:28:01 +04:00
|
|
|
__func__, rqstp, exid, exid->clname.len, exid->clname.data,
|
2009-08-14 20:57:56 +04:00
|
|
|
addr_str, exid->flags, exid->spa_how);
|
2009-04-03 09:28:01 +04:00
|
|
|
|
2011-10-10 23:07:40 +04:00
|
|
|
if (exid->flags & ~EXCHGID4_FLAG_MASK_A)
|
2009-04-03 09:28:01 +04:00
|
|
|
return nfserr_inval;
|
|
|
|
|
2015-11-24 01:39:12 +03:00
|
|
|
new = create_client(exid->clname, rqstp, &verf);
|
|
|
|
if (new == NULL)
|
|
|
|
return nfserr_jukebox;
|
2019-06-05 19:42:05 +03:00
|
|
|
status = copy_impl_id(new, exid);
|
|
|
|
if (status)
|
|
|
|
goto out_nolock;
|
2015-11-24 01:39:12 +03:00
|
|
|
|
2009-04-03 09:28:01 +04:00
|
|
|
switch (exid->spa_how) {
|
2013-04-13 22:27:29 +04:00
|
|
|
case SP4_MACH_CRED:
|
2016-06-15 19:52:09 +03:00
|
|
|
exid->spo_must_enforce[0] = 0;
|
|
|
|
exid->spo_must_enforce[1] = (
|
|
|
|
1 << (OP_BIND_CONN_TO_SESSION - 32) |
|
|
|
|
1 << (OP_EXCHANGE_ID - 32) |
|
|
|
|
1 << (OP_CREATE_SESSION - 32) |
|
|
|
|
1 << (OP_DESTROY_SESSION - 32) |
|
|
|
|
1 << (OP_DESTROY_CLIENTID - 32));
|
|
|
|
|
|
|
|
exid->spo_must_allow[0] &= (1 << (OP_CLOSE) |
|
|
|
|
1 << (OP_OPEN_DOWNGRADE) |
|
|
|
|
1 << (OP_LOCKU) |
|
|
|
|
1 << (OP_DELEGRETURN));
|
|
|
|
|
|
|
|
exid->spo_must_allow[1] &= (
|
|
|
|
1 << (OP_TEST_STATEID - 32) |
|
|
|
|
1 << (OP_FREE_STATEID - 32));
|
2015-11-24 01:39:12 +03:00
|
|
|
if (!svc_rqst_integrity_protected(rqstp)) {
|
|
|
|
status = nfserr_inval;
|
|
|
|
goto out_nolock;
|
2015-11-21 00:42:40 +03:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Sometimes userspace doesn't give us a principal.
|
|
|
|
* Which is a bug, really. Anyway, we can't enforce
|
|
|
|
* MACH_CRED in that case, better to give up now:
|
|
|
|
*/
|
2015-11-20 18:48:02 +03:00
|
|
|
if (!new->cl_cred.cr_principal &&
|
|
|
|
!new->cl_cred.cr_raw_principal) {
|
2015-11-21 00:42:40 +03:00
|
|
|
status = nfserr_serverfault;
|
|
|
|
goto out_nolock;
|
2015-11-24 01:39:12 +03:00
|
|
|
}
|
|
|
|
new->cl_mach_cred = true;
|
2020-11-20 21:26:40 +03:00
|
|
|
break;
|
2009-04-03 09:28:01 +04:00
|
|
|
case SP4_NONE:
|
|
|
|
break;
|
2012-11-25 23:48:10 +04:00
|
|
|
default: /* checked by xdr code */
|
|
|
|
WARN_ON_ONCE(1);
|
2020-08-24 01:36:59 +03:00
|
|
|
fallthrough;
|
2009-04-03 09:28:01 +04:00
|
|
|
case SP4_SSV:
|
2016-02-26 17:36:42 +03:00
|
|
|
status = nfserr_encr_alg_unsupp;
|
|
|
|
goto out_nolock;
|
2009-04-03 09:28:01 +04:00
|
|
|
}
|
|
|
|
|
2012-05-14 17:47:11 +04:00
|
|
|
/* Cases below refer to rfc 5661 section 18.35.4: */
|
2014-07-30 16:27:06 +04:00
|
|
|
spin_lock(&nn->client_lock);
|
2012-11-14 19:21:26 +04:00
|
|
|
conf = find_confirmed_client_by_name(&exid->clname, nn);
|
2009-04-03 09:28:01 +04:00
|
|
|
if (conf) {
|
2012-05-14 17:08:10 +04:00
|
|
|
bool creds_match = same_creds(&conf->cl_cred, &rqstp->rq_cred);
|
|
|
|
bool verfs_match = same_verf(&verf, &conf->cl_verifier);
|
|
|
|
|
2012-05-13 04:37:23 +04:00
|
|
|
if (update) {
|
|
|
|
if (!clp_used_exchangeid(conf)) { /* buggy client */
|
2012-05-14 17:47:11 +04:00
|
|
|
status = nfserr_inval;
|
2012-05-13 05:32:30 +04:00
|
|
|
goto out;
|
|
|
|
}
|
2016-06-15 19:52:08 +03:00
|
|
|
if (!nfsd4_mach_creds_match(conf, rqstp)) {
|
2013-04-13 22:27:29 +04:00
|
|
|
status = nfserr_wrong_cred;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-05-13 04:37:23 +04:00
|
|
|
if (!creds_match) { /* case 9 */
|
2012-05-13 05:08:41 +04:00
|
|
|
status = nfserr_perm;
|
2012-05-13 04:37:23 +04:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (!verfs_match) { /* case 8 */
|
2009-04-03 09:28:01 +04:00
|
|
|
status = nfserr_not_same;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-05-13 04:37:23 +04:00
|
|
|
/* case 6 */
|
|
|
|
exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
|
2021-05-14 22:56:19 +03:00
|
|
|
trace_nfsd_clid_confirmed_r(conf);
|
2012-05-13 04:37:23 +04:00
|
|
|
goto out_copy;
|
2009-04-03 09:28:01 +04:00
|
|
|
}
|
2012-05-13 04:37:23 +04:00
|
|
|
if (!creds_match) { /* case 3 */
|
2012-05-14 23:57:23 +04:00
|
|
|
if (client_has_state(conf)) {
|
|
|
|
status = nfserr_clid_inuse;
|
2021-05-14 22:55:29 +03:00
|
|
|
trace_nfsd_clid_cred_mismatch(conf, rqstp);
|
2009-04-03 09:28:01 +04:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
goto out_new;
|
|
|
|
}
|
2012-05-13 04:37:23 +04:00
|
|
|
if (verfs_match) { /* case 2 */
|
2012-05-26 05:24:40 +04:00
|
|
|
conf->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
|
2021-05-14 22:56:19 +03:00
|
|
|
trace_nfsd_clid_confirmed_r(conf);
|
2012-05-13 04:37:23 +04:00
|
|
|
goto out_copy;
|
|
|
|
}
|
|
|
|
/* case 5, client reboot */
|
2021-05-14 22:55:36 +03:00
|
|
|
trace_nfsd_clid_verf_mismatch(conf, rqstp, &verf);
|
2014-07-30 16:27:06 +04:00
|
|
|
conf = NULL;
|
2012-05-13 04:37:23 +04:00
|
|
|
goto out_new;
|
2009-06-16 05:20:47 +04:00
|
|
|
}
|
|
|
|
|
2012-05-14 17:47:11 +04:00
|
|
|
if (update) { /* case 7 */
|
2009-06-16 05:20:47 +04:00
|
|
|
status = nfserr_noent;
|
|
|
|
goto out;
|
2009-04-03 09:28:01 +04:00
|
|
|
}
|
|
|
|
|
2021-05-14 22:56:19 +03:00
|
|
|
unconf = find_unconfirmed_client_by_name(&exid->clname, nn);
|
2012-05-14 17:47:11 +04:00
|
|
|
if (unconf) /* case 4, possible retry or client restart */
|
2014-07-30 16:27:06 +04:00
|
|
|
unhash_client_locked(unconf);
|
2009-04-03 09:28:01 +04:00
|
|
|
|
2021-05-14 22:56:19 +03:00
|
|
|
/* case 1, new owner ID */
|
|
|
|
trace_nfsd_clid_fresh(new);
|
|
|
|
|
2009-04-03 09:28:01 +04:00
|
|
|
out_new:
|
2014-07-30 16:27:14 +04:00
|
|
|
if (conf) {
|
|
|
|
status = mark_client_expired_locked(conf);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
2021-05-14 22:56:06 +03:00
|
|
|
trace_nfsd_clid_replaced(&conf->cl_clientid);
|
2014-07-30 16:27:14 +04:00
|
|
|
}
|
2013-05-07 19:57:52 +04:00
|
|
|
new->cl_minorversion = cstate->minorversion;
|
2016-06-15 19:52:09 +03:00
|
|
|
new->cl_spo_must_allow.u.words[0] = exid->spo_must_allow[0];
|
|
|
|
new->cl_spo_must_allow.u.words[1] = exid->spo_must_allow[1];
|
2009-04-03 09:28:01 +04:00
|
|
|
|
2012-11-13 00:00:56 +04:00
|
|
|
add_to_unconfirmed(new);
|
2014-07-30 16:27:06 +04:00
|
|
|
swap(new, conf);
|
2009-04-03 09:28:01 +04:00
|
|
|
out_copy:
|
2014-07-30 16:27:05 +04:00
|
|
|
exid->clientid.cl_boot = conf->cl_clientid.cl_boot;
|
|
|
|
exid->clientid.cl_id = conf->cl_clientid.cl_id;
|
2009-04-03 09:28:01 +04:00
|
|
|
|
2014-07-30 16:27:05 +04:00
|
|
|
exid->seqid = conf->cl_cs_slot.sl_seqid + 1;
|
|
|
|
nfsd4_set_ex_flags(conf, exid);
|
2009-04-03 09:28:01 +04:00
|
|
|
|
|
|
|
dprintk("nfsd4_exchange_id seqid %d flags %x\n",
|
2014-07-30 16:27:05 +04:00
|
|
|
conf->cl_cs_slot.sl_seqid, conf->cl_exchange_flags);
|
2009-04-03 09:28:01 +04:00
|
|
|
status = nfs_ok;
|
|
|
|
|
|
|
|
out:
|
2014-07-30 16:27:06 +04:00
|
|
|
spin_unlock(&nn->client_lock);
|
2015-11-24 01:39:12 +03:00
|
|
|
out_nolock:
|
2014-07-30 16:27:05 +04:00
|
|
|
if (new)
|
2014-07-30 16:27:06 +04:00
|
|
|
expire_client(new);
|
2021-05-14 22:56:19 +03:00
|
|
|
if (unconf) {
|
|
|
|
trace_nfsd_clid_expire_unconf(&unconf->cl_clientid);
|
2014-07-30 16:27:06 +04:00
|
|
|
expire_client(unconf);
|
2021-05-14 22:56:19 +03:00
|
|
|
}
|
2009-04-03 09:28:01 +04:00
|
|
|
return status;
|
2009-04-03 09:27:58 +04:00
|
|
|
}
|
|
|
|
|
2012-04-26 01:58:50 +04:00
|
|
|
static __be32
|
2009-07-24 03:02:15 +04:00
|
|
|
check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
|
2009-04-03 09:28:08 +04:00
|
|
|
{
|
2009-07-24 03:02:15 +04:00
|
|
|
dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
|
|
|
|
slot_seqid);
|
2009-04-03 09:28:08 +04:00
|
|
|
|
|
|
|
/* The slot is in use, and no response has been sent. */
|
2009-07-24 03:02:15 +04:00
|
|
|
if (slot_inuse) {
|
|
|
|
if (seqid == slot_seqid)
|
2009-04-03 09:28:08 +04:00
|
|
|
return nfserr_jukebox;
|
|
|
|
else
|
|
|
|
return nfserr_seq_misordered;
|
|
|
|
}
|
2012-02-14 01:13:41 +04:00
|
|
|
/* Note unsigned 32-bit arithmetic handles wraparound: */
|
2009-07-24 03:02:15 +04:00
|
|
|
if (likely(seqid == slot_seqid + 1))
|
2009-04-03 09:28:08 +04:00
|
|
|
return nfs_ok;
|
2009-07-24 03:02:15 +04:00
|
|
|
if (seqid == slot_seqid)
|
2009-04-03 09:28:08 +04:00
|
|
|
return nfserr_replay_cache;
|
|
|
|
return nfserr_seq_misordered;
|
|
|
|
}
|
|
|
|
|
2009-07-24 03:02:16 +04:00
|
|
|
/*
|
|
|
|
* Cache the create session result into the create session single DRC
|
|
|
|
* slot cache by saving the xdr structure. sl_seqid has been set.
|
|
|
|
* Do this for solo or embedded create session operations.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
|
2012-04-26 01:58:50 +04:00
|
|
|
struct nfsd4_clid_slot *slot, __be32 nfserr)
|
2009-07-24 03:02:16 +04:00
|
|
|
{
|
|
|
|
slot->sl_status = nfserr;
|
|
|
|
memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
|
|
|
|
struct nfsd4_clid_slot *slot)
|
|
|
|
{
|
|
|
|
memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
|
|
|
|
return slot->sl_status;
|
|
|
|
}
|
|
|
|
|
2011-07-14 10:50:17 +04:00
|
|
|
#define NFSD_MIN_REQ_HDR_SEQ_SZ ((\
|
|
|
|
2 * 2 + /* credential,verifier: AUTH_NULL, length 0 */ \
|
|
|
|
1 + /* MIN tag is length with zero, only length */ \
|
|
|
|
3 + /* version, opcount, opcode */ \
|
|
|
|
XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
|
|
|
|
/* seqid, slotID, slotID, cache */ \
|
|
|
|
4 ) * sizeof(__be32))
|
|
|
|
|
|
|
|
#define NFSD_MIN_RESP_HDR_SEQ_SZ ((\
|
|
|
|
2 + /* verifier: AUTH_NULL, length 0 */\
|
|
|
|
1 + /* status */ \
|
|
|
|
1 + /* MIN tag is length with zero, only length */ \
|
|
|
|
3 + /* opcount, opcode, opstatus*/ \
|
|
|
|
XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
|
|
|
|
/* seqid, slotID, slotID, slotID, status */ \
|
|
|
|
5 ) * sizeof(__be32))
|
|
|
|
|
2013-04-09 00:44:14 +04:00
|
|
|
static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn)
|
2011-07-14 10:50:17 +04:00
|
|
|
{
|
2013-04-09 00:44:14 +04:00
|
|
|
u32 maxrpc = nn->nfsd_serv->sv_max_mesg;
|
|
|
|
|
2013-04-08 23:42:12 +04:00
|
|
|
if (ca->maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ)
|
|
|
|
return nfserr_toosmall;
|
|
|
|
if (ca->maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ)
|
|
|
|
return nfserr_toosmall;
|
2013-04-09 00:44:14 +04:00
|
|
|
ca->headerpadsz = 0;
|
|
|
|
ca->maxreq_sz = min_t(u32, ca->maxreq_sz, maxrpc);
|
|
|
|
ca->maxresp_sz = min_t(u32, ca->maxresp_sz, maxrpc);
|
|
|
|
ca->maxops = min_t(u32, ca->maxops, NFSD_MAX_OPS_PER_COMPOUND);
|
|
|
|
ca->maxresp_cached = min_t(u32, ca->maxresp_cached,
|
|
|
|
NFSD_SLOT_CACHE_SIZE + NFSD_MIN_HDR_SEQ_SZ);
|
|
|
|
ca->maxreqs = min_t(u32, ca->maxreqs, NFSD_MAX_SLOTS_PER_SESSION);
|
|
|
|
/*
|
|
|
|
* Note decreasing slot size below client's request may make it
|
|
|
|
* difficult for client to function correctly, whereas
|
|
|
|
* decreasing the number of slots will (just?) affect
|
|
|
|
* performance. When short on memory we therefore prefer to
|
|
|
|
* decrease number of slots instead of their size. Clients that
|
|
|
|
* request larger slots than they need will get poor results:
|
2019-09-20 09:33:16 +03:00
|
|
|
* Note that we always allow at least one slot, because our
|
|
|
|
* accounting is soft and provides no guarantees either way.
|
2013-04-09 00:44:14 +04:00
|
|
|
*/
|
2019-09-20 09:36:45 +03:00
|
|
|
ca->maxreqs = nfsd4_get_drc_mem(ca, nn);
|
2013-04-09 00:44:14 +04:00
|
|
|
|
2013-04-08 23:42:12 +04:00
|
|
|
return nfs_ok;
|
2011-07-14 10:50:17 +04:00
|
|
|
}
|
|
|
|
|
2016-03-01 21:06:02 +03:00
|
|
|
/*
|
|
|
|
* Server's NFSv4.1 backchannel support is AUTH_SYS-only for now.
|
|
|
|
* These are based on similar macros in linux/sunrpc/msg_prot.h .
|
|
|
|
*/
|
|
|
|
#define RPC_MAX_HEADER_WITH_AUTH_SYS \
|
|
|
|
(RPC_CALLHDRSIZE + 2 * (2 + UNX_CALLSLACK))
|
|
|
|
|
|
|
|
#define RPC_MAX_REPHEADER_WITH_AUTH_SYS \
|
|
|
|
(RPC_REPHDRSIZE + (2 + NUL_REPLYSLACK))
|
|
|
|
|
2013-12-23 14:11:02 +04:00
|
|
|
#define NFSD_CB_MAX_REQ_SZ ((NFS4_enc_cb_recall_sz + \
|
2016-03-01 21:06:02 +03:00
|
|
|
RPC_MAX_HEADER_WITH_AUTH_SYS) * sizeof(__be32))
|
2013-12-23 14:11:02 +04:00
|
|
|
#define NFSD_CB_MAX_RESP_SZ ((NFS4_dec_cb_recall_sz + \
|
2016-03-01 21:06:02 +03:00
|
|
|
RPC_MAX_REPHEADER_WITH_AUTH_SYS) * \
|
|
|
|
sizeof(__be32))
|
2013-12-23 14:11:02 +04:00
|
|
|
|
2013-04-09 19:34:36 +04:00
|
|
|
static __be32 check_backchannel_attrs(struct nfsd4_channel_attrs *ca)
|
2011-07-14 10:50:17 +04:00
|
|
|
{
|
2013-04-09 19:34:36 +04:00
|
|
|
ca->headerpadsz = 0;
|
|
|
|
|
2013-12-23 14:11:02 +04:00
|
|
|
if (ca->maxreq_sz < NFSD_CB_MAX_REQ_SZ)
|
2013-04-09 19:34:36 +04:00
|
|
|
return nfserr_toosmall;
|
2013-12-23 14:11:02 +04:00
|
|
|
if (ca->maxresp_sz < NFSD_CB_MAX_RESP_SZ)
|
2013-04-09 19:34:36 +04:00
|
|
|
return nfserr_toosmall;
|
|
|
|
ca->maxresp_cached = 0;
|
|
|
|
if (ca->maxops < 2)
|
|
|
|
return nfserr_toosmall;
|
|
|
|
|
|
|
|
return nfs_ok;
|
2011-07-14 10:50:17 +04:00
|
|
|
}
|
|
|
|
|
2013-05-16 01:34:39 +04:00
|
|
|
static __be32 nfsd4_check_cb_sec(struct nfsd4_cb_sec *cbs)
|
|
|
|
{
|
|
|
|
switch (cbs->flavor) {
|
|
|
|
case RPC_AUTH_NULL:
|
|
|
|
case RPC_AUTH_UNIX:
|
|
|
|
return nfs_ok;
|
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* GSS case: the spec doesn't allow us to return this
|
|
|
|
* error. But it also doesn't allow us not to support
|
|
|
|
* GSS.
|
|
|
|
* I'd rather this fail hard than return some error the
|
|
|
|
* client might think it can already handle:
|
|
|
|
*/
|
|
|
|
return nfserr_encr_alg_unsupp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-03 09:27:58 +04:00
|
|
|
__be32
|
|
|
|
nfsd4_create_session(struct svc_rqst *rqstp,
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
|
2009-04-03 09:27:58 +04:00
|
|
|
{
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_create_session *cr_ses = &u->create_session;
|
2009-08-14 20:57:56 +04:00
|
|
|
struct sockaddr *sa = svc_addr(rqstp);
|
2009-04-03 09:28:28 +04:00
|
|
|
struct nfs4_client *conf, *unconf;
|
2014-07-30 16:27:07 +04:00
|
|
|
struct nfs4_client *old = NULL;
|
2010-06-15 03:01:57 +04:00
|
|
|
struct nfsd4_session *new;
|
2012-09-12 19:04:33 +04:00
|
|
|
struct nfsd4_conn *conn;
|
2009-07-24 03:02:16 +04:00
|
|
|
struct nfsd4_clid_slot *cs_slot = NULL;
|
2012-04-26 01:58:50 +04:00
|
|
|
__be32 status = 0;
|
2012-11-14 19:21:21 +04:00
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
2009-04-03 09:28:28 +04:00
|
|
|
|
2011-03-23 12:57:07 +03:00
|
|
|
if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
|
|
|
|
return nfserr_inval;
|
2013-05-16 01:34:39 +04:00
|
|
|
status = nfsd4_check_cb_sec(&cr_ses->cb_sec);
|
|
|
|
if (status)
|
|
|
|
return status;
|
2013-04-09 00:44:14 +04:00
|
|
|
status = check_forechannel_attrs(&cr_ses->fore_channel, nn);
|
2013-04-09 19:34:36 +04:00
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
status = check_backchannel_attrs(&cr_ses->back_channel);
|
2013-04-08 23:42:12 +04:00
|
|
|
if (status)
|
2013-12-23 13:31:21 +04:00
|
|
|
goto out_release_drc_mem;
|
2012-09-12 19:04:33 +04:00
|
|
|
status = nfserr_jukebox;
|
2013-12-31 20:35:47 +04:00
|
|
|
new = alloc_session(&cr_ses->fore_channel, &cr_ses->back_channel);
|
2013-04-09 00:44:14 +04:00
|
|
|
if (!new)
|
|
|
|
goto out_release_drc_mem;
|
2012-09-12 19:04:33 +04:00
|
|
|
conn = alloc_conn_from_crses(rqstp, cr_ses);
|
|
|
|
if (!conn)
|
|
|
|
goto out_free_session;
|
2011-03-23 12:57:07 +03:00
|
|
|
|
2014-07-30 16:27:07 +04:00
|
|
|
spin_lock(&nn->client_lock);
|
2012-11-14 19:21:31 +04:00
|
|
|
unconf = find_unconfirmed_client(&cr_ses->clientid, true, nn);
|
2012-11-14 19:21:21 +04:00
|
|
|
conf = find_confirmed_client(&cr_ses->clientid, true, nn);
|
2013-03-12 18:12:37 +04:00
|
|
|
WARN_ON_ONCE(conf && unconf);
|
2009-04-03 09:28:28 +04:00
|
|
|
|
|
|
|
if (conf) {
|
2013-04-13 22:27:29 +04:00
|
|
|
status = nfserr_wrong_cred;
|
2016-06-15 19:52:08 +03:00
|
|
|
if (!nfsd4_mach_creds_match(conf, rqstp))
|
2013-04-13 22:27:29 +04:00
|
|
|
goto out_free_conn;
|
2009-07-24 03:02:16 +04:00
|
|
|
cs_slot = &conf->cl_cs_slot;
|
|
|
|
status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
|
2015-07-13 12:32:34 +03:00
|
|
|
if (status) {
|
|
|
|
if (status == nfserr_replay_cache)
|
|
|
|
status = nfsd4_replay_create_session(cr_ses, cs_slot);
|
2012-09-12 19:04:33 +04:00
|
|
|
goto out_free_conn;
|
2009-04-03 09:28:28 +04:00
|
|
|
}
|
|
|
|
} else if (unconf) {
|
2021-05-14 22:55:29 +03:00
|
|
|
status = nfserr_clid_inuse;
|
2009-04-03 09:28:28 +04:00
|
|
|
if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
|
2009-08-14 20:57:56 +04:00
|
|
|
!rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
|
2021-05-14 22:55:29 +03:00
|
|
|
trace_nfsd_clid_cred_mismatch(unconf, rqstp);
|
2012-09-12 19:04:33 +04:00
|
|
|
goto out_free_conn;
|
2009-04-03 09:28:28 +04:00
|
|
|
}
|
2013-04-13 22:27:29 +04:00
|
|
|
status = nfserr_wrong_cred;
|
2016-06-15 19:52:08 +03:00
|
|
|
if (!nfsd4_mach_creds_match(unconf, rqstp))
|
2013-04-13 22:27:29 +04:00
|
|
|
goto out_free_conn;
|
2009-07-24 03:02:16 +04:00
|
|
|
cs_slot = &unconf->cl_cs_slot;
|
|
|
|
status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
|
2009-04-03 09:28:32 +04:00
|
|
|
if (status) {
|
|
|
|
/* an unconfirmed replay returns misordered */
|
2009-04-03 09:28:28 +04:00
|
|
|
status = nfserr_seq_misordered;
|
2012-09-12 19:04:33 +04:00
|
|
|
goto out_free_conn;
|
2009-04-03 09:28:28 +04:00
|
|
|
}
|
2012-11-14 19:21:26 +04:00
|
|
|
old = find_confirmed_client_by_name(&unconf->cl_name, nn);
|
2013-04-02 06:23:49 +04:00
|
|
|
if (old) {
|
2014-07-30 16:27:07 +04:00
|
|
|
status = mark_client_expired_locked(old);
|
2014-07-30 16:27:13 +04:00
|
|
|
if (status) {
|
|
|
|
old = NULL;
|
2013-04-02 06:23:49 +04:00
|
|
|
goto out_free_conn;
|
2014-07-30 16:27:13 +04:00
|
|
|
}
|
2021-05-14 22:56:06 +03:00
|
|
|
trace_nfsd_clid_replaced(&old->cl_clientid);
|
2013-04-02 06:23:49 +04:00
|
|
|
}
|
2012-09-12 22:41:31 +04:00
|
|
|
move_to_confirmed(unconf);
|
2009-04-03 09:28:28 +04:00
|
|
|
conf = unconf;
|
|
|
|
} else {
|
|
|
|
status = nfserr_stale_clientid;
|
2012-09-12 19:04:33 +04:00
|
|
|
goto out_free_conn;
|
2009-04-03 09:28:28 +04:00
|
|
|
}
|
2012-09-12 19:04:33 +04:00
|
|
|
status = nfs_ok;
|
2016-03-01 21:05:27 +03:00
|
|
|
/* Persistent sessions are not supported */
|
2010-04-15 23:11:09 +04:00
|
|
|
cr_ses->flags &= ~SESSION4_PERSIST;
|
2016-03-01 21:05:27 +03:00
|
|
|
/* Upshifting from TCP to RDMA is not supported */
|
2010-04-15 23:11:09 +04:00
|
|
|
cr_ses->flags &= ~SESSION4_RDMA;
|
|
|
|
|
2012-09-12 19:04:33 +04:00
|
|
|
init_session(rqstp, new, conf, cr_ses);
|
2014-07-30 16:27:07 +04:00
|
|
|
nfsd4_get_session_locked(new);
|
2012-09-12 19:04:33 +04:00
|
|
|
|
2010-06-15 03:01:57 +04:00
|
|
|
memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
|
2009-04-03 09:28:28 +04:00
|
|
|
NFS4_MAX_SESSIONID_LEN);
|
2010-10-03 01:04:00 +04:00
|
|
|
cs_slot->sl_seqid++;
|
2009-07-24 03:02:16 +04:00
|
|
|
cr_ses->seqid = cs_slot->sl_seqid;
|
2009-04-03 09:28:28 +04:00
|
|
|
|
2014-07-30 16:27:07 +04:00
|
|
|
/* cache solo and embedded create sessions under the client_lock */
|
2009-07-24 03:02:16 +04:00
|
|
|
nfsd4_cache_create_session(cr_ses, cs_slot, status);
|
2014-07-30 16:27:07 +04:00
|
|
|
spin_unlock(&nn->client_lock);
|
2021-05-25 21:53:44 +03:00
|
|
|
if (conf == unconf)
|
|
|
|
fsnotify_dentry(conf->cl_nfsd_info_dentry, FS_MODIFY);
|
2014-07-30 16:27:07 +04:00
|
|
|
/* init connection and backchannel */
|
|
|
|
nfsd4_init_conn(rqstp, conn, new);
|
|
|
|
nfsd4_put_session(new);
|
|
|
|
if (old)
|
|
|
|
expire_client(old);
|
2009-04-03 09:28:28 +04:00
|
|
|
return status;
|
2012-09-12 19:04:33 +04:00
|
|
|
out_free_conn:
|
2014-07-30 16:27:07 +04:00
|
|
|
spin_unlock(&nn->client_lock);
|
2012-09-12 19:04:33 +04:00
|
|
|
free_conn(conn);
|
2014-07-30 16:27:07 +04:00
|
|
|
if (old)
|
|
|
|
expire_client(old);
|
2012-09-12 19:04:33 +04:00
|
|
|
out_free_session:
|
|
|
|
__free_session(new);
|
2013-04-09 00:44:14 +04:00
|
|
|
out_release_drc_mem:
|
|
|
|
nfsd4_put_drc_mem(&cr_ses->fore_channel);
|
2013-03-15 02:12:03 +04:00
|
|
|
return status;
|
2009-04-03 09:27:58 +04:00
|
|
|
}
|
|
|
|
|
2010-10-05 07:12:59 +04:00
|
|
|
static __be32 nfsd4_map_bcts_dir(u32 *dir)
|
|
|
|
{
|
|
|
|
switch (*dir) {
|
|
|
|
case NFS4_CDFC4_FORE:
|
|
|
|
case NFS4_CDFC4_BACK:
|
|
|
|
return nfs_ok;
|
|
|
|
case NFS4_CDFC4_FORE_OR_BOTH:
|
|
|
|
case NFS4_CDFC4_BACK_OR_BOTH:
|
|
|
|
*dir = NFS4_CDFC4_BOTH;
|
|
|
|
return nfs_ok;
|
2019-12-19 12:29:20 +03:00
|
|
|
}
|
2010-10-05 07:12:59 +04:00
|
|
|
return nfserr_inval;
|
|
|
|
}
|
|
|
|
|
2017-05-08 21:58:35 +03:00
|
|
|
__be32 nfsd4_backchannel_ctl(struct svc_rqst *rqstp,
|
|
|
|
struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
2012-11-02 02:09:48 +04:00
|
|
|
{
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_backchannel_ctl *bc = &u->backchannel_ctl;
|
2012-11-02 02:09:48 +04:00
|
|
|
struct nfsd4_session *session = cstate->session;
|
2012-11-26 16:21:58 +04:00
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
2013-05-16 01:34:39 +04:00
|
|
|
__be32 status;
|
2012-11-02 02:09:48 +04:00
|
|
|
|
2013-05-16 01:34:39 +04:00
|
|
|
status = nfsd4_check_cb_sec(&bc->bc_cb_sec);
|
|
|
|
if (status)
|
|
|
|
return status;
|
2012-11-26 16:21:58 +04:00
|
|
|
spin_lock(&nn->client_lock);
|
2012-11-02 02:09:48 +04:00
|
|
|
session->se_cb_prog = bc->bc_cb_program;
|
|
|
|
session->se_cb_sec = bc->bc_cb_sec;
|
2012-11-26 16:21:58 +04:00
|
|
|
spin_unlock(&nn->client_lock);
|
2012-11-02 02:09:48 +04:00
|
|
|
|
|
|
|
nfsd4_probe_callback(session->se_client);
|
|
|
|
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2020-04-28 00:59:01 +03:00
|
|
|
static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
|
|
|
|
{
|
|
|
|
struct nfsd4_conn *c;
|
|
|
|
|
|
|
|
list_for_each_entry(c, &s->se_conns, cn_persession) {
|
|
|
|
if (c->cn_xprt == xpt) {
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32 nfsd4_match_existing_connection(struct svc_rqst *rqst,
|
|
|
|
struct nfsd4_session *session, u32 req)
|
|
|
|
{
|
|
|
|
struct nfs4_client *clp = session->se_client;
|
|
|
|
struct svc_xprt *xpt = rqst->rq_xprt;
|
|
|
|
struct nfsd4_conn *c;
|
|
|
|
__be32 status;
|
|
|
|
|
|
|
|
/* Following the last paragraph of RFC 5661 Section 18.34.3: */
|
|
|
|
spin_lock(&clp->cl_lock);
|
|
|
|
c = __nfsd4_find_conn(xpt, session);
|
|
|
|
if (!c)
|
|
|
|
status = nfserr_noent;
|
|
|
|
else if (req == c->cn_flags)
|
|
|
|
status = nfs_ok;
|
|
|
|
else if (req == NFS4_CDFC4_FORE_OR_BOTH &&
|
|
|
|
c->cn_flags != NFS4_CDFC4_BACK)
|
|
|
|
status = nfs_ok;
|
|
|
|
else if (req == NFS4_CDFC4_BACK_OR_BOTH &&
|
|
|
|
c->cn_flags != NFS4_CDFC4_FORE)
|
|
|
|
status = nfs_ok;
|
|
|
|
else
|
|
|
|
status = nfserr_inval;
|
|
|
|
spin_unlock(&clp->cl_lock);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2010-10-05 07:12:59 +04:00
|
|
|
__be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
|
|
|
|
struct nfsd4_compound_state *cstate,
|
2017-05-08 21:58:35 +03:00
|
|
|
union nfsd4_op_u *u)
|
2010-10-05 07:12:59 +04:00
|
|
|
{
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_bind_conn_to_session *bcts = &u->bind_conn_to_session;
|
2010-10-05 07:12:59 +04:00
|
|
|
__be32 status;
|
2012-09-11 23:37:40 +04:00
|
|
|
struct nfsd4_conn *conn;
|
2013-03-19 01:31:30 +04:00
|
|
|
struct nfsd4_session *session;
|
2014-06-30 19:48:42 +04:00
|
|
|
struct net *net = SVC_NET(rqstp);
|
|
|
|
struct nfsd_net *nn = net_generic(net, nfsd_net_id);
|
2010-10-05 07:12:59 +04:00
|
|
|
|
|
|
|
if (!nfsd4_last_compound_op(rqstp))
|
|
|
|
return nfserr_not_only_op;
|
2012-11-26 16:21:58 +04:00
|
|
|
spin_lock(&nn->client_lock);
|
2014-06-30 19:48:42 +04:00
|
|
|
session = find_in_sessionid_hashtbl(&bcts->sessionid, net, &status);
|
2012-11-26 16:21:58 +04:00
|
|
|
spin_unlock(&nn->client_lock);
|
2013-03-19 01:31:30 +04:00
|
|
|
if (!session)
|
2014-06-30 19:48:42 +04:00
|
|
|
goto out_no_session;
|
2013-04-13 22:27:29 +04:00
|
|
|
status = nfserr_wrong_cred;
|
2016-06-15 19:52:08 +03:00
|
|
|
if (!nfsd4_mach_creds_match(session->se_client, rqstp))
|
2013-04-13 22:27:29 +04:00
|
|
|
goto out;
|
2020-04-28 00:59:01 +03:00
|
|
|
status = nfsd4_match_existing_connection(rqstp, session, bcts->dir);
|
|
|
|
if (status == nfs_ok || status == nfserr_inval)
|
|
|
|
goto out;
|
2010-10-05 07:12:59 +04:00
|
|
|
status = nfsd4_map_bcts_dir(&bcts->dir);
|
2012-09-11 23:37:40 +04:00
|
|
|
if (status)
|
2013-03-19 01:31:30 +04:00
|
|
|
goto out;
|
2012-09-11 23:37:40 +04:00
|
|
|
conn = alloc_conn(rqstp, bcts->dir);
|
2013-03-19 01:31:30 +04:00
|
|
|
status = nfserr_jukebox;
|
2012-09-11 23:37:40 +04:00
|
|
|
if (!conn)
|
2013-03-19 01:31:30 +04:00
|
|
|
goto out;
|
|
|
|
nfsd4_init_conn(rqstp, conn, session);
|
|
|
|
status = nfs_ok;
|
|
|
|
out:
|
2014-06-30 19:48:42 +04:00
|
|
|
nfsd4_put_session(session);
|
|
|
|
out_no_session:
|
2013-03-19 01:31:30 +04:00
|
|
|
return status;
|
2010-10-05 07:12:59 +04:00
|
|
|
}
|
|
|
|
|
2018-04-11 23:53:36 +03:00
|
|
|
static bool nfsd4_compound_in_session(struct nfsd4_compound_state *cstate, struct nfs4_sessionid *sid)
|
2010-05-01 20:56:06 +04:00
|
|
|
{
|
2018-04-11 23:53:36 +03:00
|
|
|
if (!cstate->session)
|
2018-03-22 08:37:20 +03:00
|
|
|
return false;
|
2018-04-11 23:53:36 +03:00
|
|
|
return !memcmp(sid, &cstate->session->se_sessionid, sizeof(*sid));
|
2010-05-01 20:56:06 +04:00
|
|
|
}
|
|
|
|
|
2009-04-03 09:27:58 +04:00
|
|
|
__be32
|
2017-05-08 21:58:35 +03:00
|
|
|
nfsd4_destroy_session(struct svc_rqst *r, struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
2009-04-03 09:27:58 +04:00
|
|
|
{
|
2018-04-12 00:01:53 +03:00
|
|
|
struct nfs4_sessionid *sessionid = &u->destroy_session.sessionid;
|
2009-04-03 09:28:38 +04:00
|
|
|
struct nfsd4_session *ses;
|
2013-03-15 03:55:33 +04:00
|
|
|
__be32 status;
|
2013-06-18 22:26:02 +04:00
|
|
|
int ref_held_by_me = 0;
|
2014-06-30 19:48:42 +04:00
|
|
|
struct net *net = SVC_NET(r);
|
|
|
|
struct nfsd_net *nn = net_generic(net, nfsd_net_id);
|
2009-04-03 09:28:38 +04:00
|
|
|
|
2013-03-15 03:55:33 +04:00
|
|
|
status = nfserr_not_only_op;
|
2018-04-12 00:01:53 +03:00
|
|
|
if (nfsd4_compound_in_session(cstate, sessionid)) {
|
2010-04-21 20:27:19 +04:00
|
|
|
if (!nfsd4_last_compound_op(r))
|
2013-03-15 03:55:33 +04:00
|
|
|
goto out;
|
2013-06-18 22:26:02 +04:00
|
|
|
ref_held_by_me++;
|
2010-04-21 20:27:19 +04:00
|
|
|
}
|
2018-04-12 00:01:53 +03:00
|
|
|
dump_sessionid(__func__, sessionid);
|
2012-11-26 16:21:58 +04:00
|
|
|
spin_lock(&nn->client_lock);
|
2018-04-12 00:01:53 +03:00
|
|
|
ses = find_in_sessionid_hashtbl(sessionid, net, &status);
|
2013-03-15 03:55:33 +04:00
|
|
|
if (!ses)
|
|
|
|
goto out_client_lock;
|
2013-04-13 22:27:29 +04:00
|
|
|
status = nfserr_wrong_cred;
|
2016-06-15 19:52:08 +03:00
|
|
|
if (!nfsd4_mach_creds_match(ses->se_client, r))
|
2014-06-30 19:48:42 +04:00
|
|
|
goto out_put_session;
|
2013-06-18 22:26:02 +04:00
|
|
|
status = mark_session_dead_locked(ses, 1 + ref_held_by_me);
|
2013-03-19 20:05:39 +04:00
|
|
|
if (status)
|
2013-06-18 22:26:02 +04:00
|
|
|
goto out_put_session;
|
2009-04-03 09:28:38 +04:00
|
|
|
unhash_session(ses);
|
2012-11-26 16:21:58 +04:00
|
|
|
spin_unlock(&nn->client_lock);
|
2009-04-03 09:28:38 +04:00
|
|
|
|
2010-12-09 23:52:19 +03:00
|
|
|
nfsd4_probe_callback_sync(ses->se_client);
|
2010-06-07 02:37:16 +04:00
|
|
|
|
2012-11-26 16:21:58 +04:00
|
|
|
spin_lock(&nn->client_lock);
|
2009-04-03 09:28:38 +04:00
|
|
|
status = nfs_ok;
|
2013-06-18 22:26:02 +04:00
|
|
|
out_put_session:
|
2014-06-30 19:48:42 +04:00
|
|
|
nfsd4_put_session_locked(ses);
|
2013-03-15 03:55:33 +04:00
|
|
|
out_client_lock:
|
|
|
|
spin_unlock(&nn->client_lock);
|
2009-04-03 09:28:38 +04:00
|
|
|
out:
|
|
|
|
return status;
|
2009-04-03 09:27:58 +04:00
|
|
|
}
|
|
|
|
|
2013-04-13 22:27:29 +04:00
|
|
|
static __be32 nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
|
2010-09-30 00:11:06 +04:00
|
|
|
{
|
|
|
|
struct nfs4_client *clp = ses->se_client;
|
2010-10-22 01:17:31 +04:00
|
|
|
struct nfsd4_conn *c;
|
2013-04-13 22:27:29 +04:00
|
|
|
__be32 status = nfs_ok;
|
2010-10-26 18:07:17 +04:00
|
|
|
int ret;
|
2010-09-30 00:11:06 +04:00
|
|
|
|
|
|
|
spin_lock(&clp->cl_lock);
|
2010-10-22 01:17:31 +04:00
|
|
|
c = __nfsd4_find_conn(new->cn_xprt, ses);
|
2013-04-13 22:27:29 +04:00
|
|
|
if (c)
|
|
|
|
goto out_free;
|
|
|
|
status = nfserr_conn_not_bound_to_session;
|
|
|
|
if (clp->cl_mach_cred)
|
|
|
|
goto out_free;
|
2010-09-30 00:11:06 +04:00
|
|
|
__nfsd4_hash_conn(new, ses);
|
|
|
|
spin_unlock(&clp->cl_lock);
|
2010-10-26 18:07:17 +04:00
|
|
|
ret = nfsd4_register_conn(new);
|
|
|
|
if (ret)
|
|
|
|
/* oops; xprt is already down: */
|
|
|
|
nfsd4_conn_lost(&new->cn_xpt_user);
|
2013-04-13 22:27:29 +04:00
|
|
|
return nfs_ok;
|
|
|
|
out_free:
|
|
|
|
spin_unlock(&clp->cl_lock);
|
|
|
|
free_conn(new);
|
|
|
|
return status;
|
2010-09-30 00:11:06 +04:00
|
|
|
}
|
|
|
|
|
2011-04-27 05:09:58 +04:00
|
|
|
static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
|
|
|
|
{
|
|
|
|
struct nfsd4_compoundargs *args = rqstp->rq_argp;
|
|
|
|
|
|
|
|
return args->opcnt > session->se_fchannel.maxops;
|
|
|
|
}
|
|
|
|
|
2011-07-14 10:56:02 +04:00
|
|
|
static bool nfsd4_request_too_big(struct svc_rqst *rqstp,
|
|
|
|
struct nfsd4_session *session)
|
|
|
|
{
|
|
|
|
struct xdr_buf *xb = &rqstp->rq_arg;
|
|
|
|
|
|
|
|
return xb->len > session->se_fchannel.maxreq_sz;
|
|
|
|
}
|
|
|
|
|
2017-10-18 03:38:49 +03:00
|
|
|
static bool replay_matches_cache(struct svc_rqst *rqstp,
|
|
|
|
struct nfsd4_sequence *seq, struct nfsd4_slot *slot)
|
|
|
|
{
|
|
|
|
struct nfsd4_compoundargs *argp = rqstp->rq_argp;
|
|
|
|
|
|
|
|
if ((bool)(slot->sl_flags & NFSD4_SLOT_CACHETHIS) !=
|
|
|
|
(bool)seq->cachethis)
|
|
|
|
return false;
|
|
|
|
/*
|
2019-10-09 22:11:37 +03:00
|
|
|
* If there's an error then the reply can have fewer ops than
|
|
|
|
* the call.
|
2017-10-18 03:38:49 +03:00
|
|
|
*/
|
2019-10-09 22:11:37 +03:00
|
|
|
if (slot->sl_opcnt < argp->opcnt && !slot->sl_status)
|
|
|
|
return false;
|
|
|
|
/*
|
|
|
|
* But if we cached a reply with *more* ops than the call you're
|
|
|
|
* sending us now, then this new call is clearly not really a
|
|
|
|
* replay of the old one:
|
|
|
|
*/
|
|
|
|
if (slot->sl_opcnt > argp->opcnt)
|
2017-10-18 03:38:49 +03:00
|
|
|
return false;
|
|
|
|
/* This is the only check explicitly called by spec: */
|
|
|
|
if (!same_creds(&rqstp->rq_cred, &slot->sl_cred))
|
|
|
|
return false;
|
|
|
|
/*
|
|
|
|
* There may be more comparisons we could actually do, but the
|
|
|
|
* spec doesn't require us to catch every case where the calls
|
|
|
|
* don't match (that would require caching the call as well as
|
|
|
|
* the reply), so we don't bother.
|
|
|
|
*/
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2009-04-03 09:27:58 +04:00
|
|
|
__be32
|
2017-05-08 21:58:35 +03:00
|
|
|
nfsd4_sequence(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
2009-04-03 09:27:58 +04:00
|
|
|
{
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_sequence *seq = &u->sequence;
|
2009-04-03 09:28:12 +04:00
|
|
|
struct nfsd4_compoundres *resp = rqstp->rq_resp;
|
2020-10-27 22:53:42 +03:00
|
|
|
struct xdr_stream *xdr = resp->xdr;
|
2009-04-03 09:28:08 +04:00
|
|
|
struct nfsd4_session *session;
|
2013-04-02 06:23:49 +04:00
|
|
|
struct nfs4_client *clp;
|
2009-04-03 09:28:08 +04:00
|
|
|
struct nfsd4_slot *slot;
|
2010-10-22 01:17:31 +04:00
|
|
|
struct nfsd4_conn *conn;
|
2012-04-26 01:58:50 +04:00
|
|
|
__be32 status;
|
2014-03-13 05:39:35 +04:00
|
|
|
int buflen;
|
2014-06-30 19:48:42 +04:00
|
|
|
struct net *net = SVC_NET(rqstp);
|
|
|
|
struct nfsd_net *nn = net_generic(net, nfsd_net_id);
|
2009-04-03 09:28:08 +04:00
|
|
|
|
2009-04-03 09:28:12 +04:00
|
|
|
if (resp->opcnt != 1)
|
|
|
|
return nfserr_sequence_pos;
|
|
|
|
|
2010-10-22 01:17:31 +04:00
|
|
|
/*
|
|
|
|
* Will be either used or freed by nfsd4_sequence_check_conn
|
|
|
|
* below.
|
|
|
|
*/
|
|
|
|
conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
|
|
|
|
if (!conn)
|
|
|
|
return nfserr_jukebox;
|
|
|
|
|
2012-11-26 16:21:58 +04:00
|
|
|
spin_lock(&nn->client_lock);
|
2014-06-30 19:48:42 +04:00
|
|
|
session = find_in_sessionid_hashtbl(&seq->sessionid, net, &status);
|
2009-04-03 09:28:08 +04:00
|
|
|
if (!session)
|
2013-04-02 06:23:49 +04:00
|
|
|
goto out_no_session;
|
|
|
|
clp = session->se_client;
|
2009-04-03 09:28:08 +04:00
|
|
|
|
2011-04-27 05:09:58 +04:00
|
|
|
status = nfserr_too_many_ops;
|
|
|
|
if (nfsd4_session_too_many_ops(rqstp, session))
|
2013-03-19 20:05:39 +04:00
|
|
|
goto out_put_session;
|
2011-04-27 05:09:58 +04:00
|
|
|
|
2011-07-14 10:56:02 +04:00
|
|
|
status = nfserr_req_too_big;
|
|
|
|
if (nfsd4_request_too_big(rqstp, session))
|
2013-03-19 20:05:39 +04:00
|
|
|
goto out_put_session;
|
2011-07-14 10:56:02 +04:00
|
|
|
|
2009-04-03 09:28:08 +04:00
|
|
|
status = nfserr_badslot;
|
2009-06-16 05:19:13 +04:00
|
|
|
if (seq->slotid >= session->se_fchannel.maxreqs)
|
2013-03-19 20:05:39 +04:00
|
|
|
goto out_put_session;
|
2009-04-03 09:28:08 +04:00
|
|
|
|
2009-08-28 16:45:04 +04:00
|
|
|
slot = session->se_slots[seq->slotid];
|
2009-04-03 09:28:08 +04:00
|
|
|
dprintk("%s: slotid %d\n", __func__, seq->slotid);
|
|
|
|
|
2009-08-28 16:45:02 +04:00
|
|
|
/* We do not negotiate the number of slots yet, so set the
|
|
|
|
* maxslots to the session maxreqs which is used to encode
|
|
|
|
* sr_highest_slotid and the sr_target_slot id to maxslots */
|
|
|
|
seq->maxslots = session->se_fchannel.maxreqs;
|
|
|
|
|
2012-02-14 01:39:00 +04:00
|
|
|
status = check_slot_seqid(seq->seqid, slot->sl_seqid,
|
|
|
|
slot->sl_flags & NFSD4_SLOT_INUSE);
|
2009-04-03 09:28:08 +04:00
|
|
|
if (status == nfserr_replay_cache) {
|
2012-02-14 01:56:19 +04:00
|
|
|
status = nfserr_seq_misordered;
|
|
|
|
if (!(slot->sl_flags & NFSD4_SLOT_INITIALIZED))
|
2013-03-19 20:05:39 +04:00
|
|
|
goto out_put_session;
|
2017-10-18 03:38:49 +03:00
|
|
|
status = nfserr_seq_false_retry;
|
|
|
|
if (!replay_matches_cache(rqstp, seq, slot))
|
|
|
|
goto out_put_session;
|
2009-04-03 09:28:08 +04:00
|
|
|
cstate->slot = slot;
|
|
|
|
cstate->session = session;
|
2014-06-30 19:48:44 +04:00
|
|
|
cstate->clp = clp;
|
2009-04-03 09:28:22 +04:00
|
|
|
/* Return the cached reply status and set cstate->status
|
2009-08-28 16:45:04 +04:00
|
|
|
* for nfsd4_proc_compound processing */
|
2009-04-03 09:28:35 +04:00
|
|
|
status = nfsd4_replay_cache_entry(resp, seq);
|
2009-04-03 09:28:22 +04:00
|
|
|
cstate->status = nfserr_replay_cache;
|
2009-08-20 04:21:56 +04:00
|
|
|
goto out;
|
2009-04-03 09:28:08 +04:00
|
|
|
}
|
|
|
|
if (status)
|
2013-03-19 20:05:39 +04:00
|
|
|
goto out_put_session;
|
2009-04-03 09:28:08 +04:00
|
|
|
|
2013-04-13 22:27:29 +04:00
|
|
|
status = nfsd4_sequence_check_conn(conn, session);
|
2010-10-22 01:17:31 +04:00
|
|
|
conn = NULL;
|
2013-04-13 22:27:29 +04:00
|
|
|
if (status)
|
|
|
|
goto out_put_session;
|
2010-09-30 00:11:06 +04:00
|
|
|
|
2014-03-13 05:39:35 +04:00
|
|
|
buflen = (seq->cachethis) ?
|
|
|
|
session->se_fchannel.maxresp_cached :
|
|
|
|
session->se_fchannel.maxresp_sz;
|
|
|
|
status = (seq->cachethis) ? nfserr_rep_too_big_to_cache :
|
|
|
|
nfserr_rep_too_big;
|
2014-05-13 02:10:58 +04:00
|
|
|
if (xdr_restrict_buflen(xdr, buflen - rqstp->rq_auth_slack))
|
2014-03-13 05:39:35 +04:00
|
|
|
goto out_put_session;
|
2014-03-21 04:47:41 +04:00
|
|
|
svc_reserve(rqstp, buflen);
|
2014-03-13 05:39:35 +04:00
|
|
|
|
|
|
|
status = nfs_ok;
|
2009-04-03 09:28:08 +04:00
|
|
|
/* Success! bump slot seqid */
|
|
|
|
slot->sl_seqid = seq->seqid;
|
2012-02-14 01:56:19 +04:00
|
|
|
slot->sl_flags |= NFSD4_SLOT_INUSE;
|
2012-02-14 01:39:00 +04:00
|
|
|
if (seq->cachethis)
|
|
|
|
slot->sl_flags |= NFSD4_SLOT_CACHETHIS;
|
2012-02-14 01:56:19 +04:00
|
|
|
else
|
|
|
|
slot->sl_flags &= ~NFSD4_SLOT_CACHETHIS;
|
2009-04-03 09:28:08 +04:00
|
|
|
|
|
|
|
cstate->slot = slot;
|
|
|
|
cstate->session = session;
|
2014-06-30 19:48:44 +04:00
|
|
|
cstate->clp = clp;
|
2009-04-03 09:28:08 +04:00
|
|
|
|
|
|
|
out:
|
2013-04-02 06:23:49 +04:00
|
|
|
switch (clp->cl_cb_state) {
|
|
|
|
case NFSD4_CB_DOWN:
|
|
|
|
seq->status_flags = SEQ4_STATUS_CB_PATH_DOWN;
|
|
|
|
break;
|
|
|
|
case NFSD4_CB_FAULT:
|
|
|
|
seq->status_flags = SEQ4_STATUS_BACKCHANNEL_FAULT;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
seq->status_flags = 0;
|
2009-08-20 04:21:56 +04:00
|
|
|
}
|
2013-04-10 01:02:51 +04:00
|
|
|
if (!list_empty(&clp->cl_revoked))
|
|
|
|
seq->status_flags |= SEQ4_STATUS_RECALLABLE_STATE_REVOKED;
|
2013-04-02 06:23:49 +04:00
|
|
|
out_no_session:
|
2014-03-24 07:56:59 +04:00
|
|
|
if (conn)
|
|
|
|
free_conn(conn);
|
2012-11-26 16:21:58 +04:00
|
|
|
spin_unlock(&nn->client_lock);
|
2009-04-03 09:28:08 +04:00
|
|
|
return status;
|
2013-03-19 20:05:39 +04:00
|
|
|
out_put_session:
|
2014-06-30 19:48:42 +04:00
|
|
|
nfsd4_put_session_locked(session);
|
2013-04-02 06:23:49 +04:00
|
|
|
goto out_no_session;
|
2009-04-03 09:27:58 +04:00
|
|
|
}
|
|
|
|
|
2014-06-30 19:48:35 +04:00
|
|
|
void
|
|
|
|
nfsd4_sequence_done(struct nfsd4_compoundres *resp)
|
|
|
|
{
|
|
|
|
struct nfsd4_compound_state *cs = &resp->cstate;
|
|
|
|
|
|
|
|
if (nfsd4_has_session(cs)) {
|
|
|
|
if (cs->status != nfserr_replay_cache) {
|
|
|
|
nfsd4_store_cache_entry(resp);
|
|
|
|
cs->slot->sl_flags &= ~NFSD4_SLOT_INUSE;
|
|
|
|
}
|
2014-06-30 19:48:42 +04:00
|
|
|
/* Drop session reference that was taken in nfsd4_sequence() */
|
2014-06-30 19:48:35 +04:00
|
|
|
nfsd4_put_session(cs->session);
|
2014-06-30 19:48:44 +04:00
|
|
|
} else if (cs->clp)
|
|
|
|
put_client_renew(cs->clp);
|
2014-06-30 19:48:35 +04:00
|
|
|
}
|
|
|
|
|
2011-10-20 13:51:39 +04:00
|
|
|
__be32
|
2017-05-08 21:58:35 +03:00
|
|
|
nfsd4_destroy_clientid(struct svc_rqst *rqstp,
|
|
|
|
struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
2011-10-20 13:51:39 +04:00
|
|
|
{
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_destroy_clientid *dc = &u->destroy_clientid;
|
2014-07-30 16:27:08 +04:00
|
|
|
struct nfs4_client *conf, *unconf;
|
|
|
|
struct nfs4_client *clp = NULL;
|
2012-04-26 01:58:50 +04:00
|
|
|
__be32 status = 0;
|
2012-11-14 19:21:21 +04:00
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
2011-10-20 13:51:39 +04:00
|
|
|
|
2014-07-30 16:27:08 +04:00
|
|
|
spin_lock(&nn->client_lock);
|
2012-11-14 19:21:31 +04:00
|
|
|
unconf = find_unconfirmed_client(&dc->clientid, true, nn);
|
2012-11-14 19:21:21 +04:00
|
|
|
conf = find_confirmed_client(&dc->clientid, true, nn);
|
2013-03-12 18:12:37 +04:00
|
|
|
WARN_ON_ONCE(conf && unconf);
|
2011-10-20 13:51:39 +04:00
|
|
|
|
|
|
|
if (conf) {
|
2013-03-15 02:20:01 +04:00
|
|
|
if (client_has_state(conf)) {
|
2011-10-20 13:51:39 +04:00
|
|
|
status = nfserr_clientid_busy;
|
|
|
|
goto out;
|
|
|
|
}
|
2014-07-30 16:27:14 +04:00
|
|
|
status = mark_client_expired_locked(conf);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
2014-07-30 16:27:08 +04:00
|
|
|
clp = conf;
|
2011-10-20 13:51:39 +04:00
|
|
|
} else if (unconf)
|
|
|
|
clp = unconf;
|
|
|
|
else {
|
|
|
|
status = nfserr_stale_clientid;
|
|
|
|
goto out;
|
|
|
|
}
|
2016-06-15 19:52:08 +03:00
|
|
|
if (!nfsd4_mach_creds_match(clp, rqstp)) {
|
2014-07-30 16:27:08 +04:00
|
|
|
clp = NULL;
|
2013-04-13 22:27:29 +04:00
|
|
|
status = nfserr_wrong_cred;
|
|
|
|
goto out;
|
|
|
|
}
|
2021-05-14 22:56:00 +03:00
|
|
|
trace_nfsd_clid_destroyed(&clp->cl_clientid);
|
2014-07-30 16:27:08 +04:00
|
|
|
unhash_client_locked(clp);
|
2011-10-20 13:51:39 +04:00
|
|
|
out:
|
2014-07-30 16:27:08 +04:00
|
|
|
spin_unlock(&nn->client_lock);
|
|
|
|
if (clp)
|
|
|
|
expire_client(clp);
|
2011-10-20 13:51:39 +04:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2010-04-19 23:11:28 +04:00
|
|
|
__be32
|
2017-05-08 21:58:35 +03:00
|
|
|
nfsd4_reclaim_complete(struct svc_rqst *rqstp,
|
|
|
|
struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
|
2010-04-19 23:11:28 +04:00
|
|
|
{
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_reclaim_complete *rc = &u->reclaim_complete;
|
2021-01-22 01:57:45 +03:00
|
|
|
struct nfs4_client *clp = cstate->clp;
|
2012-04-26 01:58:50 +04:00
|
|
|
__be32 status = 0;
|
2011-04-27 05:14:30 +04:00
|
|
|
|
2010-04-19 23:11:28 +04:00
|
|
|
if (rc->rca_one_fs) {
|
|
|
|
if (!cstate->current_fh.fh_dentry)
|
|
|
|
return nfserr_nofilehandle;
|
|
|
|
/*
|
|
|
|
* We don't take advantage of the rca_one_fs case.
|
|
|
|
* That's OK, it's optional, we can safely ignore it.
|
|
|
|
*/
|
2016-07-02 09:24:32 +03:00
|
|
|
return nfs_ok;
|
2010-04-19 23:11:28 +04:00
|
|
|
}
|
2011-04-27 05:14:30 +04:00
|
|
|
|
|
|
|
status = nfserr_complete_already;
|
2021-01-22 01:57:45 +03:00
|
|
|
if (test_and_set_bit(NFSD4_CLIENT_RECLAIM_COMPLETE, &clp->cl_flags))
|
2011-04-27 05:14:30 +04:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
status = nfserr_stale_clientid;
|
2021-01-22 01:57:45 +03:00
|
|
|
if (is_client_expired(clp))
|
2010-04-19 23:11:28 +04:00
|
|
|
/*
|
|
|
|
* The following error isn't really legal.
|
|
|
|
* But we only get here if the client just explicitly
|
|
|
|
* destroyed the client. Surely it no longer cares what
|
|
|
|
* error it gets back on an operation for the dead
|
|
|
|
* client.
|
|
|
|
*/
|
2011-04-27 05:14:30 +04:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
status = nfs_ok;
|
2021-05-14 22:55:54 +03:00
|
|
|
trace_nfsd_clid_reclaim_complete(&clp->cl_clientid);
|
2021-01-22 01:57:45 +03:00
|
|
|
nfsd4_client_record_create(clp);
|
|
|
|
inc_reclaim_complete(clp);
|
2011-04-27 05:14:30 +04:00
|
|
|
out:
|
|
|
|
return status;
|
2010-04-19 23:11:28 +04:00
|
|
|
}
|
|
|
|
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32
|
2006-12-13 11:35:38 +03:00
|
|
|
nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2017-05-08 21:58:35 +03:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_setclientid *setclid = &u->setclientid;
|
2011-10-10 23:07:40 +04:00
|
|
|
struct xdr_netobj clname = setclid->se_name;
|
2005-04-17 02:20:36 +04:00
|
|
|
nfs4_verifier clverifier = setclid->se_verf;
|
2014-07-30 16:27:06 +04:00
|
|
|
struct nfs4_client *conf, *new;
|
|
|
|
struct nfs4_client *unconf = NULL;
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32 status;
|
2012-11-14 19:21:10 +04:00
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
|
|
|
|
2014-07-30 16:27:05 +04:00
|
|
|
new = create_client(clname, rqstp, &clverifier);
|
|
|
|
if (new == NULL)
|
|
|
|
return nfserr_jukebox;
|
2014-07-30 16:27:06 +04:00
|
|
|
spin_lock(&nn->client_lock);
|
2012-11-14 19:21:26 +04:00
|
|
|
conf = find_confirmed_client_by_name(&clname, nn);
|
2015-10-15 22:33:23 +03:00
|
|
|
if (conf && client_has_state(conf)) {
|
2005-04-17 02:20:36 +04:00
|
|
|
status = nfserr_clid_inuse;
|
2010-11-25 01:30:54 +03:00
|
|
|
if (clp_used_exchangeid(conf))
|
|
|
|
goto out;
|
2009-03-18 22:06:26 +03:00
|
|
|
if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
|
2021-05-14 22:55:29 +03:00
|
|
|
trace_nfsd_clid_cred_mismatch(conf, rqstp);
|
2005-04-17 02:20:36 +04:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2012-11-14 19:21:36 +04:00
|
|
|
unconf = find_unconfirmed_client_by_name(&clname, nn);
|
2012-05-19 06:06:41 +04:00
|
|
|
if (unconf)
|
2014-07-30 16:27:06 +04:00
|
|
|
unhash_client_locked(unconf);
|
2021-05-14 22:55:36 +03:00
|
|
|
if (conf) {
|
|
|
|
if (same_verf(&conf->cl_verifier, &clverifier)) {
|
|
|
|
copy_clid(new, conf);
|
|
|
|
gen_confirm(new, nn);
|
|
|
|
} else
|
|
|
|
trace_nfsd_clid_verf_mismatch(conf, rqstp,
|
|
|
|
&clverifier);
|
2021-05-14 22:56:13 +03:00
|
|
|
} else
|
|
|
|
trace_nfsd_clid_fresh(new);
|
2010-10-20 03:36:51 +04:00
|
|
|
new->cl_minorversion = 0;
|
2010-12-15 08:09:01 +03:00
|
|
|
gen_callback(new, setclid, rqstp);
|
2012-11-13 00:00:56 +04:00
|
|
|
add_to_unconfirmed(new);
|
2005-04-17 02:20:36 +04:00
|
|
|
setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
|
|
|
|
setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
|
|
|
|
memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
|
2014-07-30 16:27:05 +04:00
|
|
|
new = NULL;
|
2005-04-17 02:20:36 +04:00
|
|
|
status = nfs_ok;
|
|
|
|
out:
|
2014-07-30 16:27:06 +04:00
|
|
|
spin_unlock(&nn->client_lock);
|
2014-07-30 16:27:05 +04:00
|
|
|
if (new)
|
|
|
|
free_client(new);
|
2021-05-14 22:56:13 +03:00
|
|
|
if (unconf) {
|
|
|
|
trace_nfsd_clid_expire_unconf(&unconf->cl_clientid);
|
2014-07-30 16:27:06 +04:00
|
|
|
expire_client(unconf);
|
2021-05-14 22:56:13 +03:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32
|
2006-12-13 11:35:38 +03:00
|
|
|
nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_setclientid_confirm *setclientid_confirm =
|
|
|
|
&u->setclientid_confirm;
|
2005-06-24 09:04:14 +04:00
|
|
|
struct nfs4_client *conf, *unconf;
|
2014-07-30 16:27:07 +04:00
|
|
|
struct nfs4_client *old = NULL;
|
2005-04-17 02:20:36 +04:00
|
|
|
nfs4_verifier confirm = setclientid_confirm->sc_confirm;
|
|
|
|
clientid_t * clid = &setclientid_confirm->sc_clientid;
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32 status;
|
2012-11-14 19:21:05 +04:00
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2012-07-25 16:57:45 +04:00
|
|
|
if (STALE_CLIENTID(clid, nn))
|
2005-04-17 02:20:36 +04:00
|
|
|
return nfserr_stale_clientid;
|
2005-06-24 09:04:14 +04:00
|
|
|
|
2014-07-30 16:27:07 +04:00
|
|
|
spin_lock(&nn->client_lock);
|
2012-11-14 19:21:21 +04:00
|
|
|
conf = find_confirmed_client(clid, false, nn);
|
2012-11-14 19:21:31 +04:00
|
|
|
unconf = find_unconfirmed_client(clid, false, nn);
|
2007-11-21 00:11:27 +03:00
|
|
|
/*
|
2012-05-19 18:05:58 +04:00
|
|
|
* We try hard to give out unique clientid's, so if we get an
|
|
|
|
* attempt to confirm the same clientid with a different cred,
|
2015-09-01 20:40:53 +03:00
|
|
|
* the client may be buggy; this should never happen.
|
|
|
|
*
|
|
|
|
* Nevertheless, RFC 7530 recommends INUSE for this case:
|
2007-11-21 00:11:27 +03:00
|
|
|
*/
|
2015-09-01 20:40:53 +03:00
|
|
|
status = nfserr_clid_inuse;
|
2021-05-14 22:55:29 +03:00
|
|
|
if (unconf && !same_creds(&unconf->cl_cred, &rqstp->rq_cred)) {
|
|
|
|
trace_nfsd_clid_cred_mismatch(unconf, rqstp);
|
2012-05-19 18:05:58 +04:00
|
|
|
goto out;
|
2021-05-14 22:55:29 +03:00
|
|
|
}
|
|
|
|
if (conf && !same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
|
|
|
|
trace_nfsd_clid_cred_mismatch(conf, rqstp);
|
2012-05-19 18:05:58 +04:00
|
|
|
goto out;
|
2021-05-14 22:55:29 +03:00
|
|
|
}
|
2012-05-19 21:55:22 +04:00
|
|
|
if (!unconf || !same_verf(&confirm, &unconf->cl_confirm)) {
|
2016-09-21 03:55:36 +03:00
|
|
|
if (conf && same_verf(&confirm, &conf->cl_confirm)) {
|
2005-04-17 02:20:36 +04:00
|
|
|
status = nfs_ok;
|
2021-05-14 22:56:13 +03:00
|
|
|
} else
|
2012-05-19 21:55:22 +04:00
|
|
|
status = nfserr_stale_clientid;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
status = nfs_ok;
|
2021-05-14 22:56:13 +03:00
|
|
|
if (conf) {
|
2014-07-30 16:27:07 +04:00
|
|
|
old = unconf;
|
|
|
|
unhash_client_locked(old);
|
2012-05-19 18:05:58 +04:00
|
|
|
nfsd4_change_callback(conf, &unconf->cl_cb_conn);
|
2021-05-14 22:56:13 +03:00
|
|
|
} else {
|
2014-07-30 16:27:07 +04:00
|
|
|
old = find_confirmed_client_by_name(&unconf->cl_name, nn);
|
|
|
|
if (old) {
|
2015-10-15 22:33:23 +03:00
|
|
|
status = nfserr_clid_inuse;
|
|
|
|
if (client_has_state(old)
|
|
|
|
&& !same_creds(&unconf->cl_cred,
|
|
|
|
&old->cl_cred))
|
|
|
|
goto out;
|
2014-07-30 16:27:07 +04:00
|
|
|
status = mark_client_expired_locked(old);
|
2014-07-30 16:27:13 +04:00
|
|
|
if (status) {
|
|
|
|
old = NULL;
|
2013-04-02 06:23:49 +04:00
|
|
|
goto out;
|
2014-07-30 16:27:13 +04:00
|
|
|
}
|
2021-05-14 22:56:06 +03:00
|
|
|
trace_nfsd_clid_replaced(&old->cl_clientid);
|
2013-04-02 06:23:49 +04:00
|
|
|
}
|
2012-05-19 18:05:58 +04:00
|
|
|
move_to_confirmed(unconf);
|
2014-07-30 16:27:07 +04:00
|
|
|
conf = unconf;
|
2005-06-24 09:04:11 +04:00
|
|
|
}
|
2014-07-30 16:27:07 +04:00
|
|
|
get_client_locked(conf);
|
|
|
|
spin_unlock(&nn->client_lock);
|
2021-05-25 21:53:44 +03:00
|
|
|
if (conf == unconf)
|
|
|
|
fsnotify_dentry(conf->cl_nfsd_info_dentry, FS_MODIFY);
|
2014-07-30 16:27:07 +04:00
|
|
|
nfsd4_probe_callback(conf);
|
|
|
|
spin_lock(&nn->client_lock);
|
|
|
|
put_client_renew_locked(conf);
|
2005-04-17 02:20:36 +04:00
|
|
|
out:
|
2014-07-30 16:27:07 +04:00
|
|
|
spin_unlock(&nn->client_lock);
|
|
|
|
if (old)
|
|
|
|
expire_client(old);
|
2005-04-17 02:20:36 +04:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2011-10-14 00:00:16 +04:00
|
|
|
static struct nfs4_file *nfsd4_alloc_file(void)
|
|
|
|
{
|
|
|
|
return kmem_cache_alloc(file_slab, GFP_KERNEL);
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* OPEN Share state helper functions */
|
2021-04-16 21:00:15 +03:00
|
|
|
static void nfsd4_init_file(struct svc_fh *fh, unsigned int hashval,
|
2014-10-23 16:01:02 +04:00
|
|
|
struct nfs4_file *fp)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2014-06-30 19:48:31 +04:00
|
|
|
lockdep_assert_held(&state_lock);
|
|
|
|
|
2017-10-20 12:53:30 +03:00
|
|
|
refcount_set(&fp->fi_ref, 1);
|
2014-07-10 22:07:25 +04:00
|
|
|
spin_lock_init(&fp->fi_lock);
|
2011-10-14 00:00:16 +04:00
|
|
|
INIT_LIST_HEAD(&fp->fi_stateids);
|
|
|
|
INIT_LIST_HEAD(&fp->fi_delegations);
|
2015-04-27 15:50:14 +03:00
|
|
|
INIT_LIST_HEAD(&fp->fi_clnt_odstate);
|
2021-04-16 21:00:15 +03:00
|
|
|
fh_copy_shallow(&fp->fi_fhandle, &fh->fh_handle);
|
2014-08-22 20:05:43 +04:00
|
|
|
fp->fi_deleg_file = NULL;
|
2011-10-14 00:00:16 +04:00
|
|
|
fp->fi_had_conflict = false;
|
nfsd: make deny mode enforcement more efficient and close races in it
The current enforcement of deny modes is both inefficient and scattered
across several places, which makes it hard to guarantee atomicity. The
inefficiency is a problem now, and the lack of atomicity will mean races
once the client_mutex is removed.
First, we address the inefficiency. We have to track deny modes on a
per-stateid basis to ensure that open downgrades are sane, but when the
server goes to enforce them it has to walk the entire list of stateids
and check against each one.
Instead of doing that, maintain a per-nfs4_file deny mode. When a file
is opened, we simply set any deny bits in that mode that were specified
in the OPEN call. We can then use that unified deny mode to do a simple
check to see whether there are any conflicts without needing to walk the
entire stateid list.
The only time we'll need to walk the entire list of stateids is when a
stateid that has a deny mode on it is being released, or one is having
its deny mode downgraded. In that case, we must walk the entire list and
recalculate the fi_share_deny field. Since deny modes are pretty rare
today, this should be very rare under normal workloads.
To address the potential for races once the client_mutex is removed,
protect fi_share_deny with the fi_lock. In nfs4_get_vfs_file, check to
make sure that any deny mode we want to apply won't conflict with
existing access. If that's ok, then have nfs4_file_get_access check that
new access to the file won't conflict with existing deny modes.
If that also passes, then get file access references, set the correct
access and deny bits in the stateid, and update the fi_share_deny field.
If opening the file or truncating it fails, then unwind the whole mess
and return the appropriate error.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-10 22:07:34 +04:00
|
|
|
fp->fi_share_deny = 0;
|
2011-10-14 00:00:16 +04:00
|
|
|
memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
|
|
|
|
memset(fp->fi_access, 0, sizeof(fp->fi_access));
|
2021-04-16 21:00:16 +03:00
|
|
|
fp->fi_aliased = false;
|
|
|
|
fp->fi_inode = d_inode(fh->fh_dentry);
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 15:11:59 +04:00
|
|
|
#ifdef CONFIG_NFSD_PNFS
|
|
|
|
INIT_LIST_HEAD(&fp->fi_lo_states);
|
2014-09-23 14:38:48 +04:00
|
|
|
atomic_set(&fp->fi_lo_recalls, 0);
|
nfsd: implement pNFS operations
Add support for the GETDEVICEINFO, LAYOUTGET, LAYOUTCOMMIT and
LAYOUTRETURN NFSv4.1 operations, as well as backing code to manage
outstanding layouts and devices.
Layout management is very straight forward, with a nfs4_layout_stateid
structure that extends nfs4_stid to manage layout stateids as the
top-level structure. It is linked into the nfs4_file and nfs4_client
structures like the other stateids, and contains a linked list of
layouts that hang of the stateid. The actual layout operations are
implemented in layout drivers that are not part of this commit, but
will be added later.
The worst part of this commit is the management of the pNFS device IDs,
which suffers from a specification that is not sanely implementable due
to the fact that the device-IDs are global and not bound to an export,
and have a small enough size so that we can't store the fsid portion of
a file handle, and must never be reused. As we still do need perform all
export authentication and validation checks on a device ID passed to
GETDEVICEINFO we are caught between a rock and a hard place. To work
around this issue we add a new hash that maps from a 64-bit integer to a
fsid so that we can look up the export to authenticate against it,
a 32-bit integer as a generation that we can bump when changing the device,
and a currently unused 32-bit integer that could be used in the future
to handle more than a single device per export. Entries in this hash
table are never deleted as we can't reuse the ids anyway, and would have
a severe lifetime problem anyway as Linux export structures are temporary
structures that can go away under load.
Parts of the XDR data, structures and marshaling/unmarshaling code, as
well as many concepts are derived from the old pNFS server implementation
from Andy Adamson, Benny Halevy, Dean Hildebrand, Marc Eshel, Fred Isaman,
Mike Sager, Ricardo Labiaga and many others.
Signed-off-by: Christoph Hellwig <hch@lst.de>
2014-05-05 15:11:59 +04:00
|
|
|
#endif
|
2014-10-23 16:01:02 +04:00
|
|
|
hlist_add_head_rcu(&fp->fi_hash, &file_hashtbl[hashval]);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2007-08-01 23:30:59 +04:00
|
|
|
void
|
2005-04-17 02:20:36 +04:00
|
|
|
nfsd4_free_slabs(void)
|
|
|
|
{
|
2018-03-16 16:47:22 +03:00
|
|
|
kmem_cache_destroy(client_slab);
|
2014-05-21 18:43:03 +04:00
|
|
|
kmem_cache_destroy(openowner_slab);
|
|
|
|
kmem_cache_destroy(lockowner_slab);
|
|
|
|
kmem_cache_destroy(file_slab);
|
|
|
|
kmem_cache_destroy(stateid_slab);
|
|
|
|
kmem_cache_destroy(deleg_slab);
|
2018-03-16 16:47:22 +03:00
|
|
|
kmem_cache_destroy(odstate_slab);
|
2005-06-24 09:03:01 +04:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-11-01 23:24:59 +04:00
|
|
|
int
|
2005-06-24 09:03:01 +04:00
|
|
|
nfsd4_init_slabs(void)
|
|
|
|
{
|
2018-03-16 16:47:22 +03:00
|
|
|
client_slab = kmem_cache_create("nfsd4_clients",
|
|
|
|
sizeof(struct nfs4_client), 0, 0, NULL);
|
|
|
|
if (client_slab == NULL)
|
|
|
|
goto out;
|
2011-07-31 07:33:59 +04:00
|
|
|
openowner_slab = kmem_cache_create("nfsd4_openowners",
|
|
|
|
sizeof(struct nfs4_openowner), 0, 0, NULL);
|
|
|
|
if (openowner_slab == NULL)
|
2018-03-16 16:47:22 +03:00
|
|
|
goto out_free_client_slab;
|
2011-07-31 07:33:59 +04:00
|
|
|
lockowner_slab = kmem_cache_create("nfsd4_lockowners",
|
2012-10-24 10:44:19 +04:00
|
|
|
sizeof(struct nfs4_lockowner), 0, 0, NULL);
|
2011-07-31 07:33:59 +04:00
|
|
|
if (lockowner_slab == NULL)
|
2014-05-21 18:43:03 +04:00
|
|
|
goto out_free_openowner_slab;
|
2005-06-24 09:03:01 +04:00
|
|
|
file_slab = kmem_cache_create("nfsd4_files",
|
2007-07-20 05:11:58 +04:00
|
|
|
sizeof(struct nfs4_file), 0, 0, NULL);
|
2005-06-24 09:03:01 +04:00
|
|
|
if (file_slab == NULL)
|
2014-05-21 18:43:03 +04:00
|
|
|
goto out_free_lockowner_slab;
|
2005-06-24 09:03:03 +04:00
|
|
|
stateid_slab = kmem_cache_create("nfsd4_stateids",
|
2011-09-08 00:06:42 +04:00
|
|
|
sizeof(struct nfs4_ol_stateid), 0, 0, NULL);
|
2005-06-24 09:03:03 +04:00
|
|
|
if (stateid_slab == NULL)
|
2014-05-21 18:43:03 +04:00
|
|
|
goto out_free_file_slab;
|
2005-06-24 09:03:04 +04:00
|
|
|
deleg_slab = kmem_cache_create("nfsd4_delegations",
|
2007-07-20 05:11:58 +04:00
|
|
|
sizeof(struct nfs4_delegation), 0, 0, NULL);
|
2005-06-24 09:03:04 +04:00
|
|
|
if (deleg_slab == NULL)
|
2014-05-21 18:43:03 +04:00
|
|
|
goto out_free_stateid_slab;
|
2015-04-27 15:50:14 +03:00
|
|
|
odstate_slab = kmem_cache_create("nfsd4_odstate",
|
|
|
|
sizeof(struct nfs4_clnt_odstate), 0, 0, NULL);
|
|
|
|
if (odstate_slab == NULL)
|
|
|
|
goto out_free_deleg_slab;
|
2005-06-24 09:03:01 +04:00
|
|
|
return 0;
|
2014-05-21 18:43:03 +04:00
|
|
|
|
2015-04-27 15:50:14 +03:00
|
|
|
out_free_deleg_slab:
|
|
|
|
kmem_cache_destroy(deleg_slab);
|
2014-05-21 18:43:03 +04:00
|
|
|
out_free_stateid_slab:
|
|
|
|
kmem_cache_destroy(stateid_slab);
|
|
|
|
out_free_file_slab:
|
|
|
|
kmem_cache_destroy(file_slab);
|
|
|
|
out_free_lockowner_slab:
|
|
|
|
kmem_cache_destroy(lockowner_slab);
|
|
|
|
out_free_openowner_slab:
|
|
|
|
kmem_cache_destroy(openowner_slab);
|
2018-03-16 16:47:22 +03:00
|
|
|
out_free_client_slab:
|
|
|
|
kmem_cache_destroy(client_slab);
|
2014-05-21 18:43:03 +04:00
|
|
|
out:
|
2005-06-24 09:03:01 +04:00
|
|
|
return -ENOMEM;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2011-08-12 17:42:57 +04:00
|
|
|
static void init_nfs4_replay(struct nfs4_replay *rp)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2011-08-12 17:42:57 +04:00
|
|
|
rp->rp_status = nfserr_serverfault;
|
|
|
|
rp->rp_buflen = 0;
|
|
|
|
rp->rp_buf = rp->rp_ibuf;
|
2014-07-30 05:34:27 +04:00
|
|
|
mutex_init(&rp->rp_mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nfsd4_cstate_assign_replay(struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfs4_stateowner *so)
|
|
|
|
{
|
|
|
|
if (!nfsd4_has_session(cstate)) {
|
|
|
|
mutex_lock(&so->so_replay.rp_mutex);
|
2014-08-22 18:18:43 +04:00
|
|
|
cstate->replay_owner = nfs4_get_stateowner(so);
|
2014-07-30 05:34:27 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void nfsd4_cstate_clear_replay(struct nfsd4_compound_state *cstate)
|
|
|
|
{
|
|
|
|
struct nfs4_stateowner *so = cstate->replay_owner;
|
|
|
|
|
|
|
|
if (so != NULL) {
|
|
|
|
cstate->replay_owner = NULL;
|
|
|
|
mutex_unlock(&so->so_replay.rp_mutex);
|
|
|
|
nfs4_put_stateowner(so);
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2011-07-31 07:33:59 +04:00
|
|
|
static inline void *alloc_stateowner(struct kmem_cache *slab, struct xdr_netobj *owner, struct nfs4_client *clp)
|
2011-08-12 17:42:57 +04:00
|
|
|
{
|
2005-04-17 02:20:36 +04:00
|
|
|
struct nfs4_stateowner *sop;
|
|
|
|
|
2011-07-31 07:33:59 +04:00
|
|
|
sop = kmem_cache_alloc(slab, GFP_KERNEL);
|
2011-08-12 17:42:57 +04:00
|
|
|
if (!sop)
|
|
|
|
return NULL;
|
|
|
|
|
2019-06-19 21:30:33 +03:00
|
|
|
xdr_netobj_dup(&sop->so_owner, owner, GFP_KERNEL);
|
2011-08-12 17:42:57 +04:00
|
|
|
if (!sop->so_owner.data) {
|
2011-07-31 07:33:59 +04:00
|
|
|
kmem_cache_free(slab, sop);
|
2005-04-17 02:20:36 +04:00
|
|
|
return NULL;
|
2011-08-12 17:42:57 +04:00
|
|
|
}
|
|
|
|
|
2005-06-24 09:04:17 +04:00
|
|
|
INIT_LIST_HEAD(&sop->so_stateids);
|
2011-08-12 17:42:57 +04:00
|
|
|
sop->so_client = clp;
|
|
|
|
init_nfs4_replay(&sop->so_replay);
|
2014-07-30 05:34:26 +04:00
|
|
|
atomic_set(&sop->so_count, 1);
|
2011-08-12 17:42:57 +04:00
|
|
|
return sop;
|
|
|
|
}
|
|
|
|
|
2011-07-31 07:33:59 +04:00
|
|
|
static void hash_openowner(struct nfs4_openowner *oo, struct nfs4_client *clp, unsigned int strhashval)
|
2011-08-12 17:42:57 +04:00
|
|
|
{
|
2014-07-30 05:34:36 +04:00
|
|
|
lockdep_assert_held(&clp->cl_lock);
|
2012-11-14 19:21:41 +04:00
|
|
|
|
2014-07-30 05:34:36 +04:00
|
|
|
list_add(&oo->oo_owner.so_strhash,
|
|
|
|
&clp->cl_ownerstr_hashtbl[strhashval]);
|
2011-07-31 07:33:59 +04:00
|
|
|
list_add(&oo->oo_perclient, &clp->cl_openowners);
|
2011-08-12 17:42:57 +04:00
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:29 +04:00
|
|
|
static void nfs4_unhash_openowner(struct nfs4_stateowner *so)
|
|
|
|
{
|
2014-07-30 05:34:36 +04:00
|
|
|
unhash_openowner_locked(openowner(so));
|
2014-07-30 05:34:29 +04:00
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:26 +04:00
|
|
|
static void nfs4_free_openowner(struct nfs4_stateowner *so)
|
|
|
|
{
|
|
|
|
struct nfs4_openowner *oo = openowner(so);
|
|
|
|
|
|
|
|
kmem_cache_free(openowner_slab, oo);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct nfs4_stateowner_operations openowner_ops = {
|
2014-07-30 05:34:29 +04:00
|
|
|
.so_unhash = nfs4_unhash_openowner,
|
|
|
|
.so_free = nfs4_free_openowner,
|
2014-07-30 05:34:26 +04:00
|
|
|
};
|
|
|
|
|
2015-11-06 04:42:43 +03:00
|
|
|
static struct nfs4_ol_stateid *
|
|
|
|
nfsd4_find_existing_open(struct nfs4_file *fp, struct nfsd4_open *open)
|
|
|
|
{
|
|
|
|
struct nfs4_ol_stateid *local, *ret = NULL;
|
|
|
|
struct nfs4_openowner *oo = open->op_openowner;
|
|
|
|
|
|
|
|
lockdep_assert_held(&fp->fi_lock);
|
|
|
|
|
|
|
|
list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
|
|
|
|
/* ignore lock owners */
|
|
|
|
if (local->st_stateowner->so_is_open_owner == 0)
|
|
|
|
continue;
|
2017-11-03 15:00:10 +03:00
|
|
|
if (local->st_stateowner != &oo->oo_owner)
|
|
|
|
continue;
|
|
|
|
if (local->st_stid.sc_type == NFS4_OPEN_STID) {
|
2015-11-06 04:42:43 +03:00
|
|
|
ret = local;
|
2017-10-20 12:53:28 +03:00
|
|
|
refcount_inc(&ret->st_stid.sc_count);
|
2015-11-06 04:42:43 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-11-03 15:00:10 +03:00
|
|
|
static __be32
|
|
|
|
nfsd4_verify_open_stid(struct nfs4_stid *s)
|
|
|
|
{
|
|
|
|
__be32 ret = nfs_ok;
|
|
|
|
|
|
|
|
switch (s->sc_type) {
|
|
|
|
default:
|
|
|
|
break;
|
2018-01-13 01:42:30 +03:00
|
|
|
case 0:
|
2017-11-03 15:00:10 +03:00
|
|
|
case NFS4_CLOSED_STID:
|
|
|
|
case NFS4_CLOSED_DELEG_STID:
|
|
|
|
ret = nfserr_bad_stateid;
|
|
|
|
break;
|
|
|
|
case NFS4_REVOKED_DELEG_STID:
|
|
|
|
ret = nfserr_deleg_revoked;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Lock the stateid st_mutex, and deal with races with CLOSE */
|
|
|
|
static __be32
|
|
|
|
nfsd4_lock_ol_stateid(struct nfs4_ol_stateid *stp)
|
|
|
|
{
|
|
|
|
__be32 ret;
|
|
|
|
|
2017-11-09 01:29:51 +03:00
|
|
|
mutex_lock_nested(&stp->st_mutex, LOCK_STATEID_MUTEX);
|
2017-11-03 15:00:10 +03:00
|
|
|
ret = nfsd4_verify_open_stid(&stp->st_stid);
|
|
|
|
if (ret != nfs_ok)
|
|
|
|
mutex_unlock(&stp->st_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct nfs4_ol_stateid *
|
|
|
|
nfsd4_find_and_lock_existing_open(struct nfs4_file *fp, struct nfsd4_open *open)
|
|
|
|
{
|
|
|
|
struct nfs4_ol_stateid *stp;
|
|
|
|
for (;;) {
|
|
|
|
spin_lock(&fp->fi_lock);
|
|
|
|
stp = nfsd4_find_existing_open(fp, open);
|
|
|
|
spin_unlock(&fp->fi_lock);
|
|
|
|
if (!stp || nfsd4_lock_ol_stateid(stp) == nfs_ok)
|
|
|
|
break;
|
|
|
|
nfs4_put_stid(&stp->st_stid);
|
|
|
|
}
|
|
|
|
return stp;
|
|
|
|
}
|
|
|
|
|
2011-07-31 07:33:59 +04:00
|
|
|
static struct nfs4_openowner *
|
2014-06-30 19:48:45 +04:00
|
|
|
alloc_init_open_stateowner(unsigned int strhashval, struct nfsd4_open *open,
|
2014-06-30 19:48:36 +04:00
|
|
|
struct nfsd4_compound_state *cstate)
|
|
|
|
{
|
2014-06-30 19:48:45 +04:00
|
|
|
struct nfs4_client *clp = cstate->clp;
|
2014-07-30 05:34:34 +04:00
|
|
|
struct nfs4_openowner *oo, *ret;
|
2011-08-12 17:42:57 +04:00
|
|
|
|
2011-07-31 07:33:59 +04:00
|
|
|
oo = alloc_stateowner(openowner_slab, &open->op_owner, clp);
|
|
|
|
if (!oo)
|
2011-08-12 17:42:57 +04:00
|
|
|
return NULL;
|
2014-07-30 05:34:26 +04:00
|
|
|
oo->oo_owner.so_ops = &openowner_ops;
|
2011-07-31 07:33:59 +04:00
|
|
|
oo->oo_owner.so_is_open_owner = 1;
|
|
|
|
oo->oo_owner.so_seqid = open->op_seqid;
|
2014-07-30 05:34:32 +04:00
|
|
|
oo->oo_flags = 0;
|
2014-06-30 19:48:36 +04:00
|
|
|
if (nfsd4_has_session(cstate))
|
|
|
|
oo->oo_flags |= NFS4_OO_CONFIRMED;
|
2011-07-31 07:33:59 +04:00
|
|
|
oo->oo_time = 0;
|
2011-09-17 01:42:48 +04:00
|
|
|
oo->oo_last_closed_stid = NULL;
|
2011-07-31 07:33:59 +04:00
|
|
|
INIT_LIST_HEAD(&oo->oo_close_lru);
|
2014-07-30 05:34:36 +04:00
|
|
|
spin_lock(&clp->cl_lock);
|
|
|
|
ret = find_openstateowner_str_locked(strhashval, open, clp);
|
2014-07-30 05:34:34 +04:00
|
|
|
if (ret == NULL) {
|
|
|
|
hash_openowner(oo, clp, strhashval);
|
|
|
|
ret = oo;
|
|
|
|
} else
|
2015-07-16 07:05:07 +03:00
|
|
|
nfs4_free_stateowner(&oo->oo_owner);
|
|
|
|
|
2014-07-30 05:34:36 +04:00
|
|
|
spin_unlock(&clp->cl_lock);
|
2015-03-23 17:53:42 +03:00
|
|
|
return ret;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2015-11-06 04:42:43 +03:00
|
|
|
static struct nfs4_ol_stateid *
|
2016-06-15 06:28:06 +03:00
|
|
|
init_open_stateid(struct nfs4_file *fp, struct nfsd4_open *open)
|
2015-11-06 04:42:43 +03:00
|
|
|
{
|
|
|
|
|
2011-07-31 07:33:59 +04:00
|
|
|
struct nfs4_openowner *oo = open->op_openowner;
|
2015-11-06 04:42:43 +03:00
|
|
|
struct nfs4_ol_stateid *retstp = NULL;
|
2016-06-15 06:28:06 +03:00
|
|
|
struct nfs4_ol_stateid *stp;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2016-06-15 06:28:06 +03:00
|
|
|
stp = open->op_stp;
|
2016-06-15 06:28:05 +03:00
|
|
|
/* We are moving these outside of the spinlocks to avoid the warnings */
|
|
|
|
mutex_init(&stp->st_mutex);
|
2017-11-09 01:29:51 +03:00
|
|
|
mutex_lock_nested(&stp->st_mutex, OPEN_STATEID_MUTEX);
|
2016-06-15 06:28:05 +03:00
|
|
|
|
2017-11-03 15:00:10 +03:00
|
|
|
retry:
|
2015-11-06 04:42:43 +03:00
|
|
|
spin_lock(&oo->oo_owner.so_client->cl_lock);
|
|
|
|
spin_lock(&fp->fi_lock);
|
|
|
|
|
|
|
|
retstp = nfsd4_find_existing_open(fp, open);
|
|
|
|
if (retstp)
|
|
|
|
goto out_unlock;
|
2016-06-15 06:28:06 +03:00
|
|
|
|
|
|
|
open->op_stp = NULL;
|
2017-10-20 12:53:28 +03:00
|
|
|
refcount_inc(&stp->st_stid.sc_count);
|
2013-02-03 21:23:01 +04:00
|
|
|
stp->st_stid.sc_type = NFS4_OPEN_STID;
|
2014-06-30 19:48:38 +04:00
|
|
|
INIT_LIST_HEAD(&stp->st_locks);
|
2014-08-22 18:18:43 +04:00
|
|
|
stp->st_stateowner = nfs4_get_stateowner(&oo->oo_owner);
|
2005-06-24 09:03:10 +04:00
|
|
|
get_nfs4_file(fp);
|
2014-07-30 05:34:08 +04:00
|
|
|
stp->st_stid.sc_file = fp;
|
2005-04-17 02:20:36 +04:00
|
|
|
stp->st_access_bmap = 0;
|
|
|
|
stp->st_deny_bmap = 0;
|
2005-07-08 04:59:27 +04:00
|
|
|
stp->st_openstp = NULL;
|
2014-07-30 05:34:12 +04:00
|
|
|
list_add(&stp->st_perstateowner, &oo->oo_owner.so_stateids);
|
2014-07-10 22:07:25 +04:00
|
|
|
list_add(&stp->st_perfile, &fp->fi_stateids);
|
2015-11-06 04:42:43 +03:00
|
|
|
|
|
|
|
out_unlock:
|
2014-07-10 22:07:25 +04:00
|
|
|
spin_unlock(&fp->fi_lock);
|
2014-07-30 05:34:12 +04:00
|
|
|
spin_unlock(&oo->oo_owner.so_client->cl_lock);
|
2016-06-15 06:28:05 +03:00
|
|
|
if (retstp) {
|
2017-11-03 15:00:10 +03:00
|
|
|
/* Handle races with CLOSE */
|
|
|
|
if (nfsd4_lock_ol_stateid(retstp) != nfs_ok) {
|
|
|
|
nfs4_put_stid(&retstp->st_stid);
|
|
|
|
goto retry;
|
|
|
|
}
|
2016-06-15 06:28:06 +03:00
|
|
|
/* To keep mutex tracking happy */
|
2016-06-15 06:28:05 +03:00
|
|
|
mutex_unlock(&stp->st_mutex);
|
2016-06-15 06:28:06 +03:00
|
|
|
stp = retstp;
|
2016-06-15 06:28:05 +03:00
|
|
|
}
|
2016-06-15 06:28:06 +03:00
|
|
|
return stp;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:32 +04:00
|
|
|
/*
|
|
|
|
* In the 4.0 case we need to keep the owners around a little while to handle
|
|
|
|
* CLOSE replay. We still do need to release any file access that is held by
|
|
|
|
* them before returning however.
|
|
|
|
*/
|
2005-06-24 09:04:03 +04:00
|
|
|
static void
|
2014-07-30 05:34:32 +04:00
|
|
|
move_to_close_lru(struct nfs4_ol_stateid *s, struct net *net)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2014-07-30 16:27:11 +04:00
|
|
|
struct nfs4_ol_stateid *last;
|
2014-07-30 05:34:32 +04:00
|
|
|
struct nfs4_openowner *oo = openowner(s->st_stateowner);
|
|
|
|
struct nfsd_net *nn = net_generic(s->st_stid.sc_client->net,
|
|
|
|
nfsd_net_id);
|
2012-11-14 19:22:01 +04:00
|
|
|
|
2011-07-31 07:33:59 +04:00
|
|
|
dprintk("NFSD: move_to_close_lru nfs4_openowner %p\n", oo);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2014-07-30 05:34:33 +04:00
|
|
|
/*
|
|
|
|
* We know that we hold one reference via nfsd4_close, and another
|
|
|
|
* "persistent" reference for the client. If the refcount is higher
|
|
|
|
* than 2, then there are still calls in progress that are using this
|
|
|
|
* stateid. We can't put the sc_file reference until they are finished.
|
|
|
|
* Wait for the refcount to drop to 2. Since it has been unhashed,
|
|
|
|
* there should be no danger of the refcount going back up again at
|
|
|
|
* this point.
|
|
|
|
*/
|
2017-10-20 12:53:28 +03:00
|
|
|
wait_event(close_wq, refcount_read(&s->st_stid.sc_count) == 2);
|
2014-07-30 05:34:33 +04:00
|
|
|
|
2014-07-30 05:34:32 +04:00
|
|
|
release_all_access(s);
|
|
|
|
if (s->st_stid.sc_file) {
|
|
|
|
put_nfs4_file(s->st_stid.sc_file);
|
|
|
|
s->st_stid.sc_file = NULL;
|
|
|
|
}
|
2014-07-30 16:27:11 +04:00
|
|
|
|
|
|
|
spin_lock(&nn->client_lock);
|
|
|
|
last = oo->oo_last_closed_stid;
|
2014-07-30 05:34:32 +04:00
|
|
|
oo->oo_last_closed_stid = s;
|
2012-11-14 19:22:01 +04:00
|
|
|
list_move_tail(&oo->oo_close_lru, &nn->close_lru);
|
2019-11-04 18:31:52 +03:00
|
|
|
oo->oo_time = ktime_get_boottime_seconds();
|
2014-07-30 16:27:11 +04:00
|
|
|
spin_unlock(&nn->client_lock);
|
|
|
|
if (last)
|
|
|
|
nfs4_put_stid(&last->st_stid);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* search file_hashtbl[] for file */
|
|
|
|
static struct nfs4_file *
|
2021-04-16 21:00:15 +03:00
|
|
|
find_file_locked(struct svc_fh *fh, unsigned int hashval)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
struct nfs4_file *fp;
|
|
|
|
|
2020-02-13 18:03:31 +03:00
|
|
|
hlist_for_each_entry_rcu(fp, &file_hashtbl[hashval], fi_hash,
|
|
|
|
lockdep_is_held(&state_lock)) {
|
2021-04-16 21:00:15 +03:00
|
|
|
if (fh_match(&fp->fi_fhandle, &fh->fh_handle)) {
|
2017-10-20 12:53:30 +03:00
|
|
|
if (refcount_inc_not_zero(&fp->fi_ref))
|
2014-10-23 16:01:02 +04:00
|
|
|
return fp;
|
2005-06-24 09:03:10 +04:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2021-04-16 21:00:16 +03:00
|
|
|
static struct nfs4_file *insert_file(struct nfs4_file *new, struct svc_fh *fh,
|
|
|
|
unsigned int hashval)
|
|
|
|
{
|
|
|
|
struct nfs4_file *fp;
|
|
|
|
struct nfs4_file *ret = NULL;
|
|
|
|
bool alias_found = false;
|
|
|
|
|
|
|
|
spin_lock(&state_lock);
|
|
|
|
hlist_for_each_entry_rcu(fp, &file_hashtbl[hashval], fi_hash,
|
|
|
|
lockdep_is_held(&state_lock)) {
|
|
|
|
if (fh_match(&fp->fi_fhandle, &fh->fh_handle)) {
|
|
|
|
if (refcount_inc_not_zero(&fp->fi_ref))
|
|
|
|
ret = fp;
|
|
|
|
} else if (d_inode(fh->fh_dentry) == fp->fi_inode)
|
|
|
|
fp->fi_aliased = alias_found = true;
|
|
|
|
}
|
|
|
|
if (likely(ret == NULL)) {
|
|
|
|
nfsd4_init_file(fh, hashval, new);
|
|
|
|
new->fi_aliased = alias_found;
|
|
|
|
ret = new;
|
|
|
|
}
|
|
|
|
spin_unlock(&state_lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2021-04-16 21:00:15 +03:00
|
|
|
static struct nfs4_file * find_file(struct svc_fh *fh)
|
2014-06-30 19:48:31 +04:00
|
|
|
{
|
|
|
|
struct nfs4_file *fp;
|
2014-10-23 16:01:02 +04:00
|
|
|
unsigned int hashval = file_hashval(fh);
|
2014-06-30 19:48:31 +04:00
|
|
|
|
2014-10-23 16:01:02 +04:00
|
|
|
rcu_read_lock();
|
|
|
|
fp = find_file_locked(fh, hashval);
|
|
|
|
rcu_read_unlock();
|
2014-06-30 19:48:31 +04:00
|
|
|
return fp;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct nfs4_file *
|
2021-04-16 21:00:15 +03:00
|
|
|
find_or_add_file(struct nfs4_file *new, struct svc_fh *fh)
|
2014-06-30 19:48:31 +04:00
|
|
|
{
|
|
|
|
struct nfs4_file *fp;
|
2014-10-23 16:01:02 +04:00
|
|
|
unsigned int hashval = file_hashval(fh);
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
fp = find_file_locked(fh, hashval);
|
|
|
|
rcu_read_unlock();
|
|
|
|
if (fp)
|
|
|
|
return fp;
|
2014-06-30 19:48:31 +04:00
|
|
|
|
2021-04-16 21:00:16 +03:00
|
|
|
return insert_file(new, fh, hashval);
|
2014-06-30 19:48:31 +04:00
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* Called to check deny when READ with all zero stateid or
|
|
|
|
* WRITE with all zero or all one stateid
|
|
|
|
*/
|
2006-10-20 10:28:59 +04:00
|
|
|
static __be32
|
2005-04-17 02:20:36 +04:00
|
|
|
nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
|
|
|
|
{
|
|
|
|
struct nfs4_file *fp;
|
nfsd: make deny mode enforcement more efficient and close races in it
The current enforcement of deny modes is both inefficient and scattered
across several places, which makes it hard to guarantee atomicity. The
inefficiency is a problem now, and the lack of atomicity will mean races
once the client_mutex is removed.
First, we address the inefficiency. We have to track deny modes on a
per-stateid basis to ensure that open downgrades are sane, but when the
server goes to enforce them it has to walk the entire list of stateids
and check against each one.
Instead of doing that, maintain a per-nfs4_file deny mode. When a file
is opened, we simply set any deny bits in that mode that were specified
in the OPEN call. We can then use that unified deny mode to do a simple
check to see whether there are any conflicts without needing to walk the
entire stateid list.
The only time we'll need to walk the entire list of stateids is when a
stateid that has a deny mode on it is being released, or one is having
its deny mode downgraded. In that case, we must walk the entire list and
recalculate the fi_share_deny field. Since deny modes are pretty rare
today, this should be very rare under normal workloads.
To address the potential for races once the client_mutex is removed,
protect fi_share_deny with the fi_lock. In nfs4_get_vfs_file, check to
make sure that any deny mode we want to apply won't conflict with
existing access. If that's ok, then have nfs4_file_get_access check that
new access to the file won't conflict with existing deny modes.
If that also passes, then get file access references, set the correct
access and deny bits in the stateid, and update the fi_share_deny field.
If opening the file or truncating it fails, then unwind the whole mess
and return the appropriate error.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-10 22:07:34 +04:00
|
|
|
__be32 ret = nfs_ok;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2021-04-16 21:00:15 +03:00
|
|
|
fp = find_file(current_fh);
|
2005-06-24 09:03:10 +04:00
|
|
|
if (!fp)
|
nfsd: make deny mode enforcement more efficient and close races in it
The current enforcement of deny modes is both inefficient and scattered
across several places, which makes it hard to guarantee atomicity. The
inefficiency is a problem now, and the lack of atomicity will mean races
once the client_mutex is removed.
First, we address the inefficiency. We have to track deny modes on a
per-stateid basis to ensure that open downgrades are sane, but when the
server goes to enforce them it has to walk the entire list of stateids
and check against each one.
Instead of doing that, maintain a per-nfs4_file deny mode. When a file
is opened, we simply set any deny bits in that mode that were specified
in the OPEN call. We can then use that unified deny mode to do a simple
check to see whether there are any conflicts without needing to walk the
entire stateid list.
The only time we'll need to walk the entire list of stateids is when a
stateid that has a deny mode on it is being released, or one is having
its deny mode downgraded. In that case, we must walk the entire list and
recalculate the fi_share_deny field. Since deny modes are pretty rare
today, this should be very rare under normal workloads.
To address the potential for races once the client_mutex is removed,
protect fi_share_deny with the fi_lock. In nfs4_get_vfs_file, check to
make sure that any deny mode we want to apply won't conflict with
existing access. If that's ok, then have nfs4_file_get_access check that
new access to the file won't conflict with existing deny modes.
If that also passes, then get file access references, set the correct
access and deny bits in the stateid, and update the fi_share_deny field.
If opening the file or truncating it fails, then unwind the whole mess
and return the appropriate error.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-10 22:07:34 +04:00
|
|
|
return ret;
|
|
|
|
/* Check for conflicting share reservations */
|
2014-07-10 22:07:25 +04:00
|
|
|
spin_lock(&fp->fi_lock);
|
nfsd: make deny mode enforcement more efficient and close races in it
The current enforcement of deny modes is both inefficient and scattered
across several places, which makes it hard to guarantee atomicity. The
inefficiency is a problem now, and the lack of atomicity will mean races
once the client_mutex is removed.
First, we address the inefficiency. We have to track deny modes on a
per-stateid basis to ensure that open downgrades are sane, but when the
server goes to enforce them it has to walk the entire list of stateids
and check against each one.
Instead of doing that, maintain a per-nfs4_file deny mode. When a file
is opened, we simply set any deny bits in that mode that were specified
in the OPEN call. We can then use that unified deny mode to do a simple
check to see whether there are any conflicts without needing to walk the
entire stateid list.
The only time we'll need to walk the entire list of stateids is when a
stateid that has a deny mode on it is being released, or one is having
its deny mode downgraded. In that case, we must walk the entire list and
recalculate the fi_share_deny field. Since deny modes are pretty rare
today, this should be very rare under normal workloads.
To address the potential for races once the client_mutex is removed,
protect fi_share_deny with the fi_lock. In nfs4_get_vfs_file, check to
make sure that any deny mode we want to apply won't conflict with
existing access. If that's ok, then have nfs4_file_get_access check that
new access to the file won't conflict with existing deny modes.
If that also passes, then get file access references, set the correct
access and deny bits in the stateid, and update the fi_share_deny field.
If opening the file or truncating it fails, then unwind the whole mess
and return the appropriate error.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-10 22:07:34 +04:00
|
|
|
if (fp->fi_share_deny & deny_type)
|
|
|
|
ret = nfserr_locked;
|
2014-07-10 22:07:25 +04:00
|
|
|
spin_unlock(&fp->fi_lock);
|
2005-06-24 09:03:10 +04:00
|
|
|
put_nfs4_file(fp);
|
|
|
|
return ret;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2014-09-24 14:19:19 +04:00
|
|
|
static void nfsd4_cb_recall_prepare(struct nfsd4_callback *cb)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2014-09-24 14:19:19 +04:00
|
|
|
struct nfs4_delegation *dp = cb_to_delegation(cb);
|
2014-07-30 05:34:08 +04:00
|
|
|
struct nfsd_net *nn = net_generic(dp->dl_stid.sc_client->net,
|
|
|
|
nfsd_net_id);
|
2013-03-21 23:19:33 +04:00
|
|
|
|
2014-07-30 05:34:08 +04:00
|
|
|
block_delegations(&dp->dl_stid.sc_file->fi_fhandle);
|
2014-07-25 15:34:26 +04:00
|
|
|
|
nfsd: close potential race between delegation break and laundromat
Bruce says:
There's also a preexisting expire_client/laundromat vs break race:
- expire_client/laundromat adds a delegation to its local
reaplist using the same dl_recall_lru field that a delegation
uses to track its position on the recall lru and drops the
state lock.
- a concurrent break_lease adds the delegation to the lru.
- expire/client/laundromat then walks it reaplist and sees the
lru head as just another delegation on the list....
Fix this race by checking the dl_time under the state_lock. If we find
that it's not 0, then we know that it has already been queued to the LRU
list and that we shouldn't queue it again.
In the case of destroy_client, we must also ensure that we don't hit
similar races by ensuring that we don't move any delegations to the
reaplist with a dl_time of 0. Just bump the dl_time by one before we
drop the state_lock. We're destroying the delegations anyway, so a 1s
difference there won't matter.
The fault injection code also requires a bit of surgery here:
First, in the case of nfsd_forget_client_delegations, we must prevent
the same sort of race vs. the delegation break callback. For that, we
just increment the dl_time to ensure that a delegation callback can't
race in while we're working on it.
We can't do that for nfsd_recall_client_delegations, as we need to have
it actually queue the delegation, and that won't happen if we increment
the dl_time. The state lock is held over that function, so we don't need
to worry about these sorts of races there.
There is one other potential bug nfsd_recall_client_delegations though.
Entries on the victims list are not dequeued before calling
nfsd_break_one_deleg. That's a potential list corruptor, so ensure that
we do that there.
Reported-by: "J. Bruce Fields" <bfields@fieldses.org>
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-08 22:02:49 +04:00
|
|
|
/*
|
2014-07-25 15:34:26 +04:00
|
|
|
* We can't do this in nfsd_break_deleg_cb because it is
|
|
|
|
* already holding inode->i_lock.
|
|
|
|
*
|
nfsd: close potential race between delegation break and laundromat
Bruce says:
There's also a preexisting expire_client/laundromat vs break race:
- expire_client/laundromat adds a delegation to its local
reaplist using the same dl_recall_lru field that a delegation
uses to track its position on the recall lru and drops the
state lock.
- a concurrent break_lease adds the delegation to the lru.
- expire/client/laundromat then walks it reaplist and sees the
lru head as just another delegation on the list....
Fix this race by checking the dl_time under the state_lock. If we find
that it's not 0, then we know that it has already been queued to the LRU
list and that we shouldn't queue it again.
In the case of destroy_client, we must also ensure that we don't hit
similar races by ensuring that we don't move any delegations to the
reaplist with a dl_time of 0. Just bump the dl_time by one before we
drop the state_lock. We're destroying the delegations anyway, so a 1s
difference there won't matter.
The fault injection code also requires a bit of surgery here:
First, in the case of nfsd_forget_client_delegations, we must prevent
the same sort of race vs. the delegation break callback. For that, we
just increment the dl_time to ensure that a delegation callback can't
race in while we're working on it.
We can't do that for nfsd_recall_client_delegations, as we need to have
it actually queue the delegation, and that won't happen if we increment
the dl_time. The state lock is held over that function, so we don't need
to worry about these sorts of races there.
There is one other potential bug nfsd_recall_client_delegations though.
Entries on the victims list are not dequeued before calling
nfsd_break_one_deleg. That's a potential list corruptor, so ensure that
we do that there.
Reported-by: "J. Bruce Fields" <bfields@fieldses.org>
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-08 22:02:49 +04:00
|
|
|
* If the dl_time != 0, then we know that it has already been
|
|
|
|
* queued for a lease break. Don't queue it again.
|
|
|
|
*/
|
2014-07-25 15:34:26 +04:00
|
|
|
spin_lock(&state_lock);
|
nfsd: close potential race between delegation break and laundromat
Bruce says:
There's also a preexisting expire_client/laundromat vs break race:
- expire_client/laundromat adds a delegation to its local
reaplist using the same dl_recall_lru field that a delegation
uses to track its position on the recall lru and drops the
state lock.
- a concurrent break_lease adds the delegation to the lru.
- expire/client/laundromat then walks it reaplist and sees the
lru head as just another delegation on the list....
Fix this race by checking the dl_time under the state_lock. If we find
that it's not 0, then we know that it has already been queued to the LRU
list and that we shouldn't queue it again.
In the case of destroy_client, we must also ensure that we don't hit
similar races by ensuring that we don't move any delegations to the
reaplist with a dl_time of 0. Just bump the dl_time by one before we
drop the state_lock. We're destroying the delegations anyway, so a 1s
difference there won't matter.
The fault injection code also requires a bit of surgery here:
First, in the case of nfsd_forget_client_delegations, we must prevent
the same sort of race vs. the delegation break callback. For that, we
just increment the dl_time to ensure that a delegation callback can't
race in while we're working on it.
We can't do that for nfsd_recall_client_delegations, as we need to have
it actually queue the delegation, and that won't happen if we increment
the dl_time. The state lock is held over that function, so we don't need
to worry about these sorts of races there.
There is one other potential bug nfsd_recall_client_delegations though.
Entries on the victims list are not dequeued before calling
nfsd_break_one_deleg. That's a potential list corruptor, so ensure that
we do that there.
Reported-by: "J. Bruce Fields" <bfields@fieldses.org>
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-08 22:02:49 +04:00
|
|
|
if (dp->dl_time == 0) {
|
2019-11-04 18:31:52 +03:00
|
|
|
dp->dl_time = ktime_get_boottime_seconds();
|
2014-07-16 18:31:57 +04:00
|
|
|
list_add_tail(&dp->dl_recall_lru, &nn->del_recall_lru);
|
nfsd: close potential race between delegation break and laundromat
Bruce says:
There's also a preexisting expire_client/laundromat vs break race:
- expire_client/laundromat adds a delegation to its local
reaplist using the same dl_recall_lru field that a delegation
uses to track its position on the recall lru and drops the
state lock.
- a concurrent break_lease adds the delegation to the lru.
- expire/client/laundromat then walks it reaplist and sees the
lru head as just another delegation on the list....
Fix this race by checking the dl_time under the state_lock. If we find
that it's not 0, then we know that it has already been queued to the LRU
list and that we shouldn't queue it again.
In the case of destroy_client, we must also ensure that we don't hit
similar races by ensuring that we don't move any delegations to the
reaplist with a dl_time of 0. Just bump the dl_time by one before we
drop the state_lock. We're destroying the delegations anyway, so a 1s
difference there won't matter.
The fault injection code also requires a bit of surgery here:
First, in the case of nfsd_forget_client_delegations, we must prevent
the same sort of race vs. the delegation break callback. For that, we
just increment the dl_time to ensure that a delegation callback can't
race in while we're working on it.
We can't do that for nfsd_recall_client_delegations, as we need to have
it actually queue the delegation, and that won't happen if we increment
the dl_time. The state lock is held over that function, so we don't need
to worry about these sorts of races there.
There is one other potential bug nfsd_recall_client_delegations though.
Entries on the victims list are not dequeued before calling
nfsd_break_one_deleg. That's a potential list corruptor, so ensure that
we do that there.
Reported-by: "J. Bruce Fields" <bfields@fieldses.org>
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-08 22:02:49 +04:00
|
|
|
}
|
2014-07-16 18:31:57 +04:00
|
|
|
spin_unlock(&state_lock);
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2014-09-24 14:19:19 +04:00
|
|
|
static int nfsd4_cb_recall_done(struct nfsd4_callback *cb,
|
|
|
|
struct rpc_task *task)
|
|
|
|
{
|
|
|
|
struct nfs4_delegation *dp = cb_to_delegation(cb);
|
|
|
|
|
2020-07-31 23:20:05 +03:00
|
|
|
if (dp->dl_stid.sc_type == NFS4_CLOSED_DELEG_STID ||
|
|
|
|
dp->dl_stid.sc_type == NFS4_REVOKED_DELEG_STID)
|
2015-08-31 19:06:41 +03:00
|
|
|
return 1;
|
|
|
|
|
2014-09-24 14:19:19 +04:00
|
|
|
switch (task->tk_status) {
|
|
|
|
case 0:
|
|
|
|
return 1;
|
2019-05-02 20:32:12 +03:00
|
|
|
case -NFS4ERR_DELAY:
|
|
|
|
rpc_delay(task, 2 * HZ);
|
|
|
|
return 0;
|
2014-09-24 14:19:19 +04:00
|
|
|
case -EBADHANDLE:
|
|
|
|
case -NFS4ERR_BAD_STATEID:
|
|
|
|
/*
|
|
|
|
* Race: client probably got cb_recall before open reply
|
|
|
|
* granting delegation.
|
|
|
|
*/
|
|
|
|
if (dp->dl_retries--) {
|
|
|
|
rpc_delay(task, 2 * HZ);
|
|
|
|
return 0;
|
|
|
|
}
|
2020-08-24 01:36:59 +03:00
|
|
|
fallthrough;
|
2014-09-24 14:19:19 +04:00
|
|
|
default:
|
2019-05-02 20:32:12 +03:00
|
|
|
return 1;
|
2014-09-24 14:19:19 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nfsd4_cb_recall_release(struct nfsd4_callback *cb)
|
|
|
|
{
|
|
|
|
struct nfs4_delegation *dp = cb_to_delegation(cb);
|
|
|
|
|
|
|
|
nfs4_put_stid(&dp->dl_stid);
|
|
|
|
}
|
|
|
|
|
2015-11-22 00:57:39 +03:00
|
|
|
static const struct nfsd4_callback_ops nfsd4_cb_recall_ops = {
|
2014-09-24 14:19:19 +04:00
|
|
|
.prepare = nfsd4_cb_recall_prepare,
|
|
|
|
.done = nfsd4_cb_recall_done,
|
|
|
|
.release = nfsd4_cb_recall_release,
|
|
|
|
};
|
|
|
|
|
2014-07-16 18:31:57 +04:00
|
|
|
static void nfsd_break_one_deleg(struct nfs4_delegation *dp)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* We're assuming the state code never drops its reference
|
|
|
|
* without first removing the lease. Since we're in this lease
|
2018-04-14 00:34:35 +03:00
|
|
|
* callback (and since the lease code is serialized by the
|
|
|
|
* i_lock) we know the server hasn't removed the lease yet, and
|
|
|
|
* we know it's safe to take a reference.
|
2014-07-16 18:31:57 +04:00
|
|
|
*/
|
2017-10-20 12:53:28 +03:00
|
|
|
refcount_inc(&dp->dl_stid.sc_count);
|
2014-09-24 14:19:18 +04:00
|
|
|
nfsd4_run_cb(&dp->dl_recall);
|
2011-01-31 19:54:04 +03:00
|
|
|
}
|
|
|
|
|
2013-06-21 16:58:15 +04:00
|
|
|
/* Called from break_lease() with i_lock held. */
|
2014-09-01 23:06:54 +04:00
|
|
|
static bool
|
|
|
|
nfsd_break_deleg_cb(struct file_lock *fl)
|
2011-01-31 19:54:04 +03:00
|
|
|
{
|
2014-09-01 23:06:54 +04:00
|
|
|
bool ret = false;
|
2018-02-16 06:08:45 +03:00
|
|
|
struct nfs4_delegation *dp = (struct nfs4_delegation *)fl->fl_owner;
|
|
|
|
struct nfs4_file *fp = dp->dl_stid.sc_file;
|
2011-01-31 19:54:04 +03:00
|
|
|
|
2021-05-14 22:57:20 +03:00
|
|
|
trace_nfsd_cb_recall(&dp->dl_stid);
|
2020-04-05 18:42:29 +03:00
|
|
|
|
2007-09-13 02:56:12 +04:00
|
|
|
/*
|
|
|
|
* We don't want the locks code to timeout the lease for us;
|
2011-02-01 03:20:39 +03:00
|
|
|
* we'll remove it ourself if a delegation isn't returned
|
2011-01-31 19:54:04 +03:00
|
|
|
* in time:
|
2007-09-13 02:56:12 +04:00
|
|
|
*/
|
|
|
|
fl->fl_break_time = 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2014-07-16 18:31:57 +04:00
|
|
|
spin_lock(&fp->fi_lock);
|
2014-07-21 17:34:57 +04:00
|
|
|
fp->fi_had_conflict = true;
|
2018-02-16 22:29:42 +03:00
|
|
|
nfsd_break_one_deleg(dp);
|
2014-07-16 18:31:57 +04:00
|
|
|
spin_unlock(&fp->fi_lock);
|
2014-09-01 23:06:54 +04:00
|
|
|
return ret;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2017-07-28 23:35:15 +03:00
|
|
|
static bool nfsd_breaker_owns_lease(struct file_lock *fl)
|
|
|
|
{
|
|
|
|
struct nfs4_delegation *dl = fl->fl_owner;
|
|
|
|
struct svc_rqst *rqst;
|
|
|
|
struct nfs4_client *clp;
|
|
|
|
|
|
|
|
if (!i_am_nfsd())
|
|
|
|
return NULL;
|
|
|
|
rqst = kthread_data(current);
|
2020-09-25 17:12:39 +03:00
|
|
|
/* Note rq_prog == NFS_ACL_PROGRAM is also possible: */
|
|
|
|
if (rqst->rq_prog != NFS_PROGRAM || rqst->rq_vers < 4)
|
2020-08-05 22:10:11 +03:00
|
|
|
return NULL;
|
2017-07-28 23:35:15 +03:00
|
|
|
clp = *(rqst->rq_lease_breaker);
|
|
|
|
return dl->dl_stid.sc_client == clp;
|
|
|
|
}
|
|
|
|
|
2014-09-01 15:12:07 +04:00
|
|
|
static int
|
2015-01-16 23:05:57 +03:00
|
|
|
nfsd_change_deleg_cb(struct file_lock *onlist, int arg,
|
|
|
|
struct list_head *dispose)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
if (arg & F_UNLCK)
|
2014-09-01 15:12:07 +04:00
|
|
|
return lease_modify(onlist, arg, dispose);
|
2005-04-17 02:20:36 +04:00
|
|
|
else
|
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
2009-09-22 04:01:12 +04:00
|
|
|
static const struct lock_manager_operations nfsd_lease_mng_ops = {
|
2017-07-28 23:35:15 +03:00
|
|
|
.lm_breaker_owns_lease = nfsd_breaker_owns_lease,
|
2011-07-21 04:21:59 +04:00
|
|
|
.lm_break = nfsd_break_deleg_cb,
|
|
|
|
.lm_change = nfsd_change_deleg_cb,
|
2005-04-17 02:20:36 +04:00
|
|
|
};
|
|
|
|
|
2011-09-02 17:03:37 +04:00
|
|
|
static __be32 nfsd4_check_seqid(struct nfsd4_compound_state *cstate, struct nfs4_stateowner *so, u32 seqid)
|
|
|
|
{
|
|
|
|
if (nfsd4_has_session(cstate))
|
|
|
|
return nfs_ok;
|
|
|
|
if (seqid == so->so_seqid - 1)
|
|
|
|
return nfserr_replay_me;
|
|
|
|
if (seqid == so->so_seqid)
|
|
|
|
return nfs_ok;
|
|
|
|
return nfserr_bad_seqid;
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2021-01-22 01:57:41 +03:00
|
|
|
static struct nfs4_client *lookup_clientid(clientid_t *clid, bool sessions,
|
|
|
|
struct nfsd_net *nn)
|
|
|
|
{
|
|
|
|
struct nfs4_client *found;
|
|
|
|
|
|
|
|
spin_lock(&nn->client_lock);
|
|
|
|
found = find_confirmed_client(clid, sessions, nn);
|
|
|
|
if (found)
|
|
|
|
atomic_inc(&found->cl_rpc_users);
|
|
|
|
spin_unlock(&nn->client_lock);
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
2021-01-22 01:57:40 +03:00
|
|
|
static __be32 set_client(clientid_t *clid,
|
2014-06-30 19:48:44 +04:00
|
|
|
struct nfsd4_compound_state *cstate,
|
2021-01-22 01:57:43 +03:00
|
|
|
struct nfsd_net *nn)
|
2014-06-30 19:48:44 +04:00
|
|
|
{
|
|
|
|
if (cstate->clp) {
|
2021-01-22 01:57:41 +03:00
|
|
|
if (!same_clid(&cstate->clp->cl_clientid, clid))
|
2014-06-30 19:48:44 +04:00
|
|
|
return nfserr_stale_clientid;
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
if (STALE_CLIENTID(clid, nn))
|
|
|
|
return nfserr_stale_clientid;
|
|
|
|
/*
|
2021-01-22 01:57:43 +03:00
|
|
|
* We're in the 4.0 case (otherwise the SEQUENCE op would have
|
|
|
|
* set cstate->clp), so session = false:
|
2014-06-30 19:48:44 +04:00
|
|
|
*/
|
2021-01-22 01:57:43 +03:00
|
|
|
cstate->clp = lookup_clientid(clid, false, nn);
|
2021-01-22 01:57:41 +03:00
|
|
|
if (!cstate->clp)
|
2014-06-30 19:48:44 +04:00
|
|
|
return nfserr_expired;
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32
|
2009-04-03 09:28:45 +04:00
|
|
|
nfsd4_process_open1(struct nfsd4_compound_state *cstate,
|
2012-11-14 19:22:07 +04:00
|
|
|
struct nfsd4_open *open, struct nfsd_net *nn)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
clientid_t *clientid = &open->op_clientid;
|
|
|
|
struct nfs4_client *clp = NULL;
|
|
|
|
unsigned int strhashval;
|
2011-07-31 07:33:59 +04:00
|
|
|
struct nfs4_openowner *oo = NULL;
|
2011-10-17 23:57:47 +04:00
|
|
|
__be32 status;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-10-14 00:00:16 +04:00
|
|
|
/*
|
|
|
|
* In case we need it later, after we've already created the
|
|
|
|
* file and don't want to risk a further failure:
|
|
|
|
*/
|
|
|
|
open->op_file = nfsd4_alloc_file();
|
|
|
|
if (open->op_file == NULL)
|
|
|
|
return nfserr_jukebox;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2021-01-22 01:57:43 +03:00
|
|
|
status = set_client(clientid, cstate, nn);
|
2014-06-30 19:48:46 +04:00
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
clp = cstate->clp;
|
|
|
|
|
2014-07-30 05:34:36 +04:00
|
|
|
strhashval = ownerstr_hashval(&open->op_owner);
|
|
|
|
oo = find_openstateowner_str(strhashval, open, clp);
|
2011-07-31 07:33:59 +04:00
|
|
|
open->op_openowner = oo;
|
|
|
|
if (!oo) {
|
2011-10-13 04:44:20 +04:00
|
|
|
goto new_owner;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2011-09-12 20:24:13 +04:00
|
|
|
if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) {
|
2006-01-19 04:43:34 +03:00
|
|
|
/* Replace unconfirmed owners without checking for replay. */
|
2011-07-31 07:33:59 +04:00
|
|
|
release_openowner(oo);
|
|
|
|
open->op_openowner = NULL;
|
2011-10-13 04:44:20 +04:00
|
|
|
goto new_owner;
|
2006-01-19 04:43:34 +03:00
|
|
|
}
|
2011-10-17 23:57:47 +04:00
|
|
|
status = nfsd4_check_seqid(cstate, &oo->oo_owner, open->op_seqid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
goto alloc_stateid;
|
2011-10-13 04:44:20 +04:00
|
|
|
new_owner:
|
2014-06-30 19:48:45 +04:00
|
|
|
oo = alloc_init_open_stateowner(strhashval, open, cstate);
|
2011-10-13 04:44:20 +04:00
|
|
|
if (oo == NULL)
|
|
|
|
return nfserr_jukebox;
|
|
|
|
open->op_openowner = oo;
|
2011-10-17 23:57:47 +04:00
|
|
|
alloc_stateid:
|
2014-07-30 05:34:11 +04:00
|
|
|
open->op_stp = nfs4_alloc_open_stateid(clp);
|
2011-10-17 23:57:47 +04:00
|
|
|
if (!open->op_stp)
|
|
|
|
return nfserr_jukebox;
|
2015-04-27 15:50:14 +03:00
|
|
|
|
|
|
|
if (nfsd4_has_session(cstate) &&
|
|
|
|
(cstate->current_fh.fh_export->ex_flags & NFSEXP_PNFS)) {
|
|
|
|
open->op_odstate = alloc_clnt_odstate(clp);
|
|
|
|
if (!open->op_odstate)
|
|
|
|
return nfserr_jukebox;
|
|
|
|
}
|
|
|
|
|
2006-01-19 04:43:34 +03:00
|
|
|
return nfs_ok;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2006-10-20 10:28:59 +04:00
|
|
|
static inline __be32
|
2005-06-24 09:02:50 +04:00
|
|
|
nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
|
|
|
|
{
|
|
|
|
if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
|
|
|
|
return nfserr_openmode;
|
|
|
|
else
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2011-09-09 17:06:12 +04:00
|
|
|
static int share_access_to_flags(u32 share_access)
|
2005-06-24 09:02:49 +04:00
|
|
|
{
|
2011-09-09 17:06:12 +04:00
|
|
|
return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
|
2005-06-24 09:02:49 +04:00
|
|
|
}
|
|
|
|
|
2011-09-24 01:01:19 +04:00
|
|
|
static struct nfs4_delegation *find_deleg_stateid(struct nfs4_client *cl, stateid_t *s)
|
2010-05-19 04:01:35 +04:00
|
|
|
{
|
2011-09-09 17:06:12 +04:00
|
|
|
struct nfs4_stid *ret;
|
2010-05-19 04:01:35 +04:00
|
|
|
|
2017-11-03 21:06:31 +03:00
|
|
|
ret = find_stateid_by_type(cl, s,
|
|
|
|
NFS4_DELEG_STID|NFS4_REVOKED_DELEG_STID);
|
2011-09-09 17:06:12 +04:00
|
|
|
if (!ret)
|
|
|
|
return NULL;
|
|
|
|
return delegstateid(ret);
|
2010-05-19 04:01:35 +04:00
|
|
|
}
|
|
|
|
|
2011-10-19 19:52:12 +04:00
|
|
|
static bool nfsd4_is_deleg_cur(struct nfsd4_open *open)
|
|
|
|
{
|
|
|
|
return open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR ||
|
|
|
|
open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH;
|
|
|
|
}
|
|
|
|
|
2006-10-20 10:28:59 +04:00
|
|
|
static __be32
|
2013-03-21 23:49:47 +04:00
|
|
|
nfs4_check_deleg(struct nfs4_client *cl, struct nfsd4_open *open,
|
2005-06-24 09:02:53 +04:00
|
|
|
struct nfs4_delegation **dp)
|
|
|
|
{
|
|
|
|
int flags;
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32 status = nfserr_bad_stateid;
|
2014-07-30 05:34:18 +04:00
|
|
|
struct nfs4_delegation *deleg;
|
2005-06-24 09:02:53 +04:00
|
|
|
|
2014-07-30 05:34:18 +04:00
|
|
|
deleg = find_deleg_stateid(cl, &open->op_delegate_stateid);
|
|
|
|
if (deleg == NULL)
|
2005-06-24 09:02:54 +04:00
|
|
|
goto out;
|
2017-11-03 21:06:31 +03:00
|
|
|
if (deleg->dl_stid.sc_type == NFS4_REVOKED_DELEG_STID) {
|
|
|
|
nfs4_put_stid(&deleg->dl_stid);
|
|
|
|
if (cl->cl_minorversion)
|
|
|
|
status = nfserr_deleg_revoked;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-05-19 04:01:35 +04:00
|
|
|
flags = share_access_to_flags(open->op_share_access);
|
2014-07-30 05:34:18 +04:00
|
|
|
status = nfs4_check_delegmode(deleg, flags);
|
|
|
|
if (status) {
|
|
|
|
nfs4_put_stid(&deleg->dl_stid);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
*dp = deleg;
|
2005-06-24 09:02:54 +04:00
|
|
|
out:
|
2011-10-19 19:52:12 +04:00
|
|
|
if (!nfsd4_is_deleg_cur(open))
|
2005-06-24 09:02:54 +04:00
|
|
|
return nfs_ok;
|
|
|
|
if (status)
|
|
|
|
return status;
|
2011-09-12 20:24:13 +04:00
|
|
|
open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
|
2005-06-24 09:02:54 +04:00
|
|
|
return nfs_ok;
|
2005-06-24 09:02:53 +04:00
|
|
|
}
|
|
|
|
|
2010-07-28 20:21:23 +04:00
|
|
|
static inline int nfs4_access_to_access(u32 nfs4_access)
|
|
|
|
{
|
|
|
|
int flags = 0;
|
|
|
|
|
|
|
|
if (nfs4_access & NFS4_SHARE_ACCESS_READ)
|
|
|
|
flags |= NFSD_MAY_READ;
|
|
|
|
if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
|
|
|
|
flags |= NFSD_MAY_WRITE;
|
|
|
|
return flags;
|
|
|
|
}
|
|
|
|
|
2014-06-30 19:48:30 +04:00
|
|
|
static inline __be32
|
|
|
|
nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
|
|
|
|
struct nfsd4_open *open)
|
|
|
|
{
|
|
|
|
struct iattr iattr = {
|
|
|
|
.ia_valid = ATTR_SIZE,
|
|
|
|
.ia_size = 0,
|
|
|
|
};
|
|
|
|
if (!open->op_truncate)
|
|
|
|
return 0;
|
|
|
|
if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
|
|
|
|
return nfserr_inval;
|
2019-11-03 19:50:18 +03:00
|
|
|
return nfsd_setattr(rqstp, fh, &iattr, 0, (time64_t)0);
|
2014-06-30 19:48:30 +04:00
|
|
|
}
|
|
|
|
|
2011-07-23 22:58:10 +04:00
|
|
|
static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file *fp,
|
2014-07-10 22:07:31 +04:00
|
|
|
struct svc_fh *cur_fh, struct nfs4_ol_stateid *stp,
|
|
|
|
struct nfsd4_open *open)
|
2010-07-08 19:02:09 +04:00
|
|
|
{
|
2019-08-18 21:18:52 +03:00
|
|
|
struct nfsd_file *nf = NULL;
|
2010-07-08 19:02:09 +04:00
|
|
|
__be32 status;
|
2011-07-23 22:58:10 +04:00
|
|
|
int oflag = nfs4_access_to_omode(open->op_share_access);
|
|
|
|
int access = nfs4_access_to_access(open->op_share_access);
|
nfsd: make deny mode enforcement more efficient and close races in it
The current enforcement of deny modes is both inefficient and scattered
across several places, which makes it hard to guarantee atomicity. The
inefficiency is a problem now, and the lack of atomicity will mean races
once the client_mutex is removed.
First, we address the inefficiency. We have to track deny modes on a
per-stateid basis to ensure that open downgrades are sane, but when the
server goes to enforce them it has to walk the entire list of stateids
and check against each one.
Instead of doing that, maintain a per-nfs4_file deny mode. When a file
is opened, we simply set any deny bits in that mode that were specified
in the OPEN call. We can then use that unified deny mode to do a simple
check to see whether there are any conflicts without needing to walk the
entire stateid list.
The only time we'll need to walk the entire list of stateids is when a
stateid that has a deny mode on it is being released, or one is having
its deny mode downgraded. In that case, we must walk the entire list and
recalculate the fi_share_deny field. Since deny modes are pretty rare
today, this should be very rare under normal workloads.
To address the potential for races once the client_mutex is removed,
protect fi_share_deny with the fi_lock. In nfs4_get_vfs_file, check to
make sure that any deny mode we want to apply won't conflict with
existing access. If that's ok, then have nfs4_file_get_access check that
new access to the file won't conflict with existing deny modes.
If that also passes, then get file access references, set the correct
access and deny bits in the stateid, and update the fi_share_deny field.
If opening the file or truncating it fails, then unwind the whole mess
and return the appropriate error.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-10 22:07:34 +04:00
|
|
|
unsigned char old_access_bmap, old_deny_bmap;
|
2011-07-23 22:58:10 +04:00
|
|
|
|
2014-07-10 22:07:26 +04:00
|
|
|
spin_lock(&fp->fi_lock);
|
nfsd: make deny mode enforcement more efficient and close races in it
The current enforcement of deny modes is both inefficient and scattered
across several places, which makes it hard to guarantee atomicity. The
inefficiency is a problem now, and the lack of atomicity will mean races
once the client_mutex is removed.
First, we address the inefficiency. We have to track deny modes on a
per-stateid basis to ensure that open downgrades are sane, but when the
server goes to enforce them it has to walk the entire list of stateids
and check against each one.
Instead of doing that, maintain a per-nfs4_file deny mode. When a file
is opened, we simply set any deny bits in that mode that were specified
in the OPEN call. We can then use that unified deny mode to do a simple
check to see whether there are any conflicts without needing to walk the
entire stateid list.
The only time we'll need to walk the entire list of stateids is when a
stateid that has a deny mode on it is being released, or one is having
its deny mode downgraded. In that case, we must walk the entire list and
recalculate the fi_share_deny field. Since deny modes are pretty rare
today, this should be very rare under normal workloads.
To address the potential for races once the client_mutex is removed,
protect fi_share_deny with the fi_lock. In nfs4_get_vfs_file, check to
make sure that any deny mode we want to apply won't conflict with
existing access. If that's ok, then have nfs4_file_get_access check that
new access to the file won't conflict with existing deny modes.
If that also passes, then get file access references, set the correct
access and deny bits in the stateid, and update the fi_share_deny field.
If opening the file or truncating it fails, then unwind the whole mess
and return the appropriate error.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-10 22:07:34 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Are we trying to set a deny mode that would conflict with
|
|
|
|
* current access?
|
|
|
|
*/
|
|
|
|
status = nfs4_file_check_deny(fp, open->op_share_deny);
|
|
|
|
if (status != nfs_ok) {
|
|
|
|
spin_unlock(&fp->fi_lock);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set access to the file */
|
|
|
|
status = nfs4_file_get_access(fp, open->op_share_access);
|
|
|
|
if (status != nfs_ok) {
|
|
|
|
spin_unlock(&fp->fi_lock);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set access bits in stateid */
|
|
|
|
old_access_bmap = stp->st_access_bmap;
|
|
|
|
set_access(open->op_share_access, stp);
|
|
|
|
|
|
|
|
/* Set new deny mask */
|
|
|
|
old_deny_bmap = stp->st_deny_bmap;
|
|
|
|
set_deny(open->op_share_deny, stp);
|
|
|
|
fp->fi_share_deny |= (open->op_share_deny & NFS4_SHARE_DENY_BOTH);
|
|
|
|
|
2010-07-08 19:02:09 +04:00
|
|
|
if (!fp->fi_fds[oflag]) {
|
2014-07-10 22:07:26 +04:00
|
|
|
spin_unlock(&fp->fi_lock);
|
2019-08-18 21:18:52 +03:00
|
|
|
status = nfsd_file_acquire(rqstp, cur_fh, access, &nf);
|
2010-07-08 19:02:09 +04:00
|
|
|
if (status)
|
nfsd: make deny mode enforcement more efficient and close races in it
The current enforcement of deny modes is both inefficient and scattered
across several places, which makes it hard to guarantee atomicity. The
inefficiency is a problem now, and the lack of atomicity will mean races
once the client_mutex is removed.
First, we address the inefficiency. We have to track deny modes on a
per-stateid basis to ensure that open downgrades are sane, but when the
server goes to enforce them it has to walk the entire list of stateids
and check against each one.
Instead of doing that, maintain a per-nfs4_file deny mode. When a file
is opened, we simply set any deny bits in that mode that were specified
in the OPEN call. We can then use that unified deny mode to do a simple
check to see whether there are any conflicts without needing to walk the
entire stateid list.
The only time we'll need to walk the entire list of stateids is when a
stateid that has a deny mode on it is being released, or one is having
its deny mode downgraded. In that case, we must walk the entire list and
recalculate the fi_share_deny field. Since deny modes are pretty rare
today, this should be very rare under normal workloads.
To address the potential for races once the client_mutex is removed,
protect fi_share_deny with the fi_lock. In nfs4_get_vfs_file, check to
make sure that any deny mode we want to apply won't conflict with
existing access. If that's ok, then have nfs4_file_get_access check that
new access to the file won't conflict with existing deny modes.
If that also passes, then get file access references, set the correct
access and deny bits in the stateid, and update the fi_share_deny field.
If opening the file or truncating it fails, then unwind the whole mess
and return the appropriate error.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-10 22:07:34 +04:00
|
|
|
goto out_put_access;
|
2014-07-10 22:07:26 +04:00
|
|
|
spin_lock(&fp->fi_lock);
|
|
|
|
if (!fp->fi_fds[oflag]) {
|
2019-08-18 21:18:52 +03:00
|
|
|
fp->fi_fds[oflag] = nf;
|
|
|
|
nf = NULL;
|
2014-07-10 22:07:26 +04:00
|
|
|
}
|
2010-07-08 19:02:09 +04:00
|
|
|
}
|
2014-07-10 22:07:26 +04:00
|
|
|
spin_unlock(&fp->fi_lock);
|
2019-08-18 21:18:52 +03:00
|
|
|
if (nf)
|
|
|
|
nfsd_file_put(nf);
|
2010-07-08 19:02:09 +04:00
|
|
|
|
2021-04-16 21:00:14 +03:00
|
|
|
status = nfserrno(nfsd_open_break_lease(cur_fh->fh_dentry->d_inode,
|
|
|
|
access));
|
|
|
|
if (status)
|
|
|
|
goto out_put_access;
|
|
|
|
|
2014-06-30 19:48:30 +04:00
|
|
|
status = nfsd4_truncate(rqstp, cur_fh, open);
|
|
|
|
if (status)
|
|
|
|
goto out_put_access;
|
|
|
|
out:
|
|
|
|
return status;
|
nfsd: make deny mode enforcement more efficient and close races in it
The current enforcement of deny modes is both inefficient and scattered
across several places, which makes it hard to guarantee atomicity. The
inefficiency is a problem now, and the lack of atomicity will mean races
once the client_mutex is removed.
First, we address the inefficiency. We have to track deny modes on a
per-stateid basis to ensure that open downgrades are sane, but when the
server goes to enforce them it has to walk the entire list of stateids
and check against each one.
Instead of doing that, maintain a per-nfs4_file deny mode. When a file
is opened, we simply set any deny bits in that mode that were specified
in the OPEN call. We can then use that unified deny mode to do a simple
check to see whether there are any conflicts without needing to walk the
entire stateid list.
The only time we'll need to walk the entire list of stateids is when a
stateid that has a deny mode on it is being released, or one is having
its deny mode downgraded. In that case, we must walk the entire list and
recalculate the fi_share_deny field. Since deny modes are pretty rare
today, this should be very rare under normal workloads.
To address the potential for races once the client_mutex is removed,
protect fi_share_deny with the fi_lock. In nfs4_get_vfs_file, check to
make sure that any deny mode we want to apply won't conflict with
existing access. If that's ok, then have nfs4_file_get_access check that
new access to the file won't conflict with existing deny modes.
If that also passes, then get file access references, set the correct
access and deny bits in the stateid, and update the fi_share_deny field.
If opening the file or truncating it fails, then unwind the whole mess
and return the appropriate error.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-10 22:07:34 +04:00
|
|
|
out_put_access:
|
|
|
|
stp->st_access_bmap = old_access_bmap;
|
|
|
|
nfs4_file_put_access(fp, open->op_share_access);
|
|
|
|
reset_union_bmap_deny(bmap_to_share_mode(old_deny_bmap), stp);
|
|
|
|
goto out;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2006-10-20 10:28:59 +04:00
|
|
|
static __be32
|
2011-09-08 00:06:42 +04:00
|
|
|
nfs4_upgrade_open(struct svc_rqst *rqstp, struct nfs4_file *fp, struct svc_fh *cur_fh, struct nfs4_ol_stateid *stp, struct nfsd4_open *open)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32 status;
|
2015-05-13 00:31:29 +03:00
|
|
|
unsigned char old_deny_bmap = stp->st_deny_bmap;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2014-07-10 22:07:31 +04:00
|
|
|
if (!test_access(open->op_share_access, stp))
|
nfsd: make deny mode enforcement more efficient and close races in it
The current enforcement of deny modes is both inefficient and scattered
across several places, which makes it hard to guarantee atomicity. The
inefficiency is a problem now, and the lack of atomicity will mean races
once the client_mutex is removed.
First, we address the inefficiency. We have to track deny modes on a
per-stateid basis to ensure that open downgrades are sane, but when the
server goes to enforce them it has to walk the entire list of stateids
and check against each one.
Instead of doing that, maintain a per-nfs4_file deny mode. When a file
is opened, we simply set any deny bits in that mode that were specified
in the OPEN call. We can then use that unified deny mode to do a simple
check to see whether there are any conflicts without needing to walk the
entire stateid list.
The only time we'll need to walk the entire list of stateids is when a
stateid that has a deny mode on it is being released, or one is having
its deny mode downgraded. In that case, we must walk the entire list and
recalculate the fi_share_deny field. Since deny modes are pretty rare
today, this should be very rare under normal workloads.
To address the potential for races once the client_mutex is removed,
protect fi_share_deny with the fi_lock. In nfs4_get_vfs_file, check to
make sure that any deny mode we want to apply won't conflict with
existing access. If that's ok, then have nfs4_file_get_access check that
new access to the file won't conflict with existing deny modes.
If that also passes, then get file access references, set the correct
access and deny bits in the stateid, and update the fi_share_deny field.
If opening the file or truncating it fails, then unwind the whole mess
and return the appropriate error.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-10 22:07:34 +04:00
|
|
|
return nfs4_get_vfs_file(rqstp, fp, cur_fh, stp, open);
|
2014-06-30 19:48:30 +04:00
|
|
|
|
nfsd: make deny mode enforcement more efficient and close races in it
The current enforcement of deny modes is both inefficient and scattered
across several places, which makes it hard to guarantee atomicity. The
inefficiency is a problem now, and the lack of atomicity will mean races
once the client_mutex is removed.
First, we address the inefficiency. We have to track deny modes on a
per-stateid basis to ensure that open downgrades are sane, but when the
server goes to enforce them it has to walk the entire list of stateids
and check against each one.
Instead of doing that, maintain a per-nfs4_file deny mode. When a file
is opened, we simply set any deny bits in that mode that were specified
in the OPEN call. We can then use that unified deny mode to do a simple
check to see whether there are any conflicts without needing to walk the
entire stateid list.
The only time we'll need to walk the entire list of stateids is when a
stateid that has a deny mode on it is being released, or one is having
its deny mode downgraded. In that case, we must walk the entire list and
recalculate the fi_share_deny field. Since deny modes are pretty rare
today, this should be very rare under normal workloads.
To address the potential for races once the client_mutex is removed,
protect fi_share_deny with the fi_lock. In nfs4_get_vfs_file, check to
make sure that any deny mode we want to apply won't conflict with
existing access. If that's ok, then have nfs4_file_get_access check that
new access to the file won't conflict with existing deny modes.
If that also passes, then get file access references, set the correct
access and deny bits in the stateid, and update the fi_share_deny field.
If opening the file or truncating it fails, then unwind the whole mess
and return the appropriate error.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-10 22:07:34 +04:00
|
|
|
/* test and set deny mode */
|
|
|
|
spin_lock(&fp->fi_lock);
|
|
|
|
status = nfs4_file_check_deny(fp, open->op_share_deny);
|
|
|
|
if (status == nfs_ok) {
|
|
|
|
set_deny(open->op_share_deny, stp);
|
|
|
|
fp->fi_share_deny |=
|
|
|
|
(open->op_share_deny & NFS4_SHARE_DENY_BOTH);
|
|
|
|
}
|
|
|
|
spin_unlock(&fp->fi_lock);
|
|
|
|
|
|
|
|
if (status != nfs_ok)
|
2005-04-17 02:20:36 +04:00
|
|
|
return status;
|
|
|
|
|
nfsd: make deny mode enforcement more efficient and close races in it
The current enforcement of deny modes is both inefficient and scattered
across several places, which makes it hard to guarantee atomicity. The
inefficiency is a problem now, and the lack of atomicity will mean races
once the client_mutex is removed.
First, we address the inefficiency. We have to track deny modes on a
per-stateid basis to ensure that open downgrades are sane, but when the
server goes to enforce them it has to walk the entire list of stateids
and check against each one.
Instead of doing that, maintain a per-nfs4_file deny mode. When a file
is opened, we simply set any deny bits in that mode that were specified
in the OPEN call. We can then use that unified deny mode to do a simple
check to see whether there are any conflicts without needing to walk the
entire stateid list.
The only time we'll need to walk the entire list of stateids is when a
stateid that has a deny mode on it is being released, or one is having
its deny mode downgraded. In that case, we must walk the entire list and
recalculate the fi_share_deny field. Since deny modes are pretty rare
today, this should be very rare under normal workloads.
To address the potential for races once the client_mutex is removed,
protect fi_share_deny with the fi_lock. In nfs4_get_vfs_file, check to
make sure that any deny mode we want to apply won't conflict with
existing access. If that's ok, then have nfs4_file_get_access check that
new access to the file won't conflict with existing deny modes.
If that also passes, then get file access references, set the correct
access and deny bits in the stateid, and update the fi_share_deny field.
If opening the file or truncating it fails, then unwind the whole mess
and return the appropriate error.
Signed-off-by: Jeff Layton <jlayton@primarydata.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2014-07-10 22:07:34 +04:00
|
|
|
status = nfsd4_truncate(rqstp, cur_fh, open);
|
|
|
|
if (status != nfs_ok)
|
|
|
|
reset_union_bmap_deny(old_deny_bmap, stp);
|
|
|
|
return status;
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2010-12-11 03:02:49 +03:00
|
|
|
/* Should we give out recallable state?: */
|
|
|
|
static bool nfsd4_cb_channel_good(struct nfs4_client *clp)
|
|
|
|
{
|
|
|
|
if (clp->cl_cb_state == NFSD4_CB_UP)
|
|
|
|
return true;
|
|
|
|
/*
|
|
|
|
* In the sessions case, since we don't have to establish a
|
|
|
|
* separate connection for callbacks, we assume it's OK
|
|
|
|
* until we hear otherwise:
|
|
|
|
*/
|
|
|
|
return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN;
|
|
|
|
}
|
|
|
|
|
2018-02-16 06:08:45 +03:00
|
|
|
static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp,
|
|
|
|
int flag)
|
2011-01-31 19:55:12 +03:00
|
|
|
{
|
|
|
|
struct file_lock *fl;
|
|
|
|
|
|
|
|
fl = locks_alloc_lock();
|
|
|
|
if (!fl)
|
|
|
|
return NULL;
|
|
|
|
fl->fl_lmops = &nfsd_lease_mng_ops;
|
2011-07-01 23:18:34 +04:00
|
|
|
fl->fl_flags = FL_DELEG;
|
2011-01-31 19:55:12 +03:00
|
|
|
fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
|
|
|
|
fl->fl_end = OFFSET_MAX;
|
2018-02-16 06:08:45 +03:00
|
|
|
fl->fl_owner = (fl_owner_t)dp;
|
2011-01-31 19:55:12 +03:00
|
|
|
fl->fl_pid = current->tgid;
|
2019-08-18 21:18:53 +03:00
|
|
|
fl->fl_file = dp->dl_stid.sc_file->fi_deleg_file->nf_file;
|
2011-01-31 19:55:12 +03:00
|
|
|
return fl;
|
|
|
|
}
|
|
|
|
|
2021-04-16 21:00:18 +03:00
|
|
|
static int nfsd4_check_conflicting_opens(struct nfs4_client *clp,
|
|
|
|
struct nfs4_file *fp)
|
|
|
|
{
|
|
|
|
struct nfs4_ol_stateid *st;
|
|
|
|
struct file *f = fp->fi_deleg_file->nf_file;
|
|
|
|
struct inode *ino = locks_inode(f);
|
|
|
|
int writes;
|
|
|
|
|
|
|
|
writes = atomic_read(&ino->i_writecount);
|
|
|
|
if (!writes)
|
|
|
|
return 0;
|
|
|
|
/*
|
|
|
|
* There could be multiple filehandles (hence multiple
|
|
|
|
* nfs4_files) referencing this file, but that's not too
|
|
|
|
* common; let's just give up in that case rather than
|
|
|
|
* trying to go look up all the clients using that other
|
|
|
|
* nfs4_file as well:
|
|
|
|
*/
|
|
|
|
if (fp->fi_aliased)
|
|
|
|
return -EAGAIN;
|
|
|
|
/*
|
|
|
|
* If there's a close in progress, make sure that we see it
|
|
|
|
* clear any fi_fds[] entries before we see it decrement
|
|
|
|
* i_writecount:
|
|
|
|
*/
|
|
|
|
smp_mb__after_atomic();
|
|
|
|
|
|
|
|
if (fp->fi_fds[O_WRONLY])
|
|
|
|
writes--;
|
|
|
|
if (fp->fi_fds[O_RDWR])
|
|
|
|
writes--;
|
|
|
|
if (writes > 0)
|
|
|
|
return -EAGAIN; /* There may be non-NFSv4 writers */
|
|
|
|
/*
|
|
|
|
* It's possible there are non-NFSv4 write opens in progress,
|
|
|
|
* but if they haven't incremented i_writecount yet then they
|
|
|
|
* also haven't called break lease yet; so, they'll break this
|
|
|
|
* lease soon enough. So, all that's left to check for is NFSv4
|
|
|
|
* opens:
|
|
|
|
*/
|
|
|
|
spin_lock(&fp->fi_lock);
|
|
|
|
list_for_each_entry(st, &fp->fi_stateids, st_perfile) {
|
|
|
|
if (st->st_openstp == NULL /* it's an open */ &&
|
|
|
|
access_permit_write(st) &&
|
|
|
|
st->st_stid.sc_client != clp) {
|
|
|
|
spin_unlock(&fp->fi_lock);
|
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock(&fp->fi_lock);
|
|
|
|
/*
|
|
|
|
* There's a small chance that we could be racing with another
|
|
|
|
* NFSv4 open. However, any open that hasn't added itself to
|
|
|
|
* the fi_stateids list also hasn't called break_lease yet; so,
|
|
|
|
* they'll break this lease soon enough.
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-07-25 15:34:25 +04:00
|
|
|
static struct nfs4_delegation *
|
|
|
|
nfs4_set_delegation(struct nfs4_client *clp, struct svc_fh *fh,
|
2015-04-27 15:50:14 +03:00
|
|
|
struct nfs4_file *fp, struct nfs4_clnt_odstate *odstate)
|
2011-02-01 03:20:39 +03:00
|
|
|
{
|
2018-02-19 19:38:33 +03:00
|
|
|
int status = 0;
|
2014-07-25 15:34:25 +04:00
|
|
|
struct nfs4_delegation *dp;
|
2019-08-18 21:18:53 +03:00
|
|
|
struct nfsd_file *nf;
|
2018-02-16 22:29:42 +03:00
|
|
|
struct file_lock *fl;
|
2014-07-21 17:34:57 +04:00
|
|
|
|
2018-02-16 22:29:42 +03:00
|
|
|
/*
|
|
|
|
* The fi_had_conflict and nfs_get_existing_delegation checks
|
|
|
|
* here are just optimizations; we'll need to recheck them at
|
|
|
|
* the end:
|
|
|
|
*/
|
2013-08-16 00:55:26 +04:00
|
|
|
if (fp->fi_had_conflict)
|
2014-07-25 15:34:25 +04:00
|
|
|
return ERR_PTR(-EAGAIN);
|
|
|
|
|
2019-08-18 21:18:53 +03:00
|
|
|
nf = find_readable_file(fp);
|
|
|
|
if (!nf) {
|
2021-04-16 21:00:18 +03:00
|
|
|
/*
|
|
|
|
* We probably could attempt another open and get a read
|
|
|
|
* delegation, but for now, don't bother until the
|
|
|
|
* client actually sends us one.
|
|
|
|
*/
|
|
|
|
return ERR_PTR(-EAGAIN);
|
2018-02-16 22:29:42 +03:00
|
|
|
}
|
2015-10-15 19:07:28 +03:00
|
|
|
spin_lock(&state_lock);
|
|
|
|
spin_lock(&fp->fi_lock);
|
2018-02-19 19:38:33 +03:00
|
|
|
if (nfs4_delegation_exists(clp, fp))
|
|
|
|
status = -EAGAIN;
|
2018-02-16 22:29:42 +03:00
|
|
|
else if (!fp->fi_deleg_file) {
|
2019-08-18 21:18:53 +03:00
|
|
|
fp->fi_deleg_file = nf;
|
2018-02-16 22:29:42 +03:00
|
|
|
/* increment early to prevent fi_deleg_file from being
|
|
|
|
* cleared */
|
|
|
|
fp->fi_delegees = 1;
|
2019-08-18 21:18:53 +03:00
|
|
|
nf = NULL;
|
2018-02-16 22:29:42 +03:00
|
|
|
} else
|
|
|
|
fp->fi_delegees++;
|
2015-10-15 19:07:28 +03:00
|
|
|
spin_unlock(&fp->fi_lock);
|
|
|
|
spin_unlock(&state_lock);
|
2019-08-18 21:18:53 +03:00
|
|
|
if (nf)
|
|
|
|
nfsd_file_put(nf);
|
2015-10-15 19:07:28 +03:00
|
|
|
if (status)
|
|
|
|
return ERR_PTR(status);
|
|
|
|
|
2018-02-16 22:29:42 +03:00
|
|
|
status = -ENOMEM;
|
2018-02-21 23:27:28 +03:00
|
|
|
dp = alloc_init_deleg(clp, fp, fh, odstate);
|
2014-07-25 15:34:25 +04:00
|
|
|
if (!dp)
|
2018-02-16 22:29:42 +03:00
|
|
|
goto out_delegees;
|
|
|
|
|
|
|
|
fl = nfs4_alloc_init_lease(dp, NFS4_OPEN_DELEGATE_READ);
|
|
|
|
if (!fl)
|
2018-10-05 16:32:08 +03:00
|
|
|
goto out_clnt_odstate;
|
2018-02-16 22:29:42 +03:00
|
|
|
|
2019-08-18 21:18:53 +03:00
|
|
|
status = vfs_setlease(fp->fi_deleg_file->nf_file, fl->fl_type, &fl, NULL);
|
2018-02-16 22:29:42 +03:00
|
|
|
if (fl)
|
|
|
|
locks_free_lock(fl);
|
|
|
|
if (status)
|
|
|
|
goto out_clnt_odstate;
|
2021-04-16 21:00:18 +03:00
|
|
|
status = nfsd4_check_conflicting_opens(clp, fp);
|
|
|
|
if (status)
|
|
|
|
goto out_unlock;
|
2014-07-25 15:34:25 +04:00
|
|
|
|
2014-07-21 17:34:57 +04:00
|
|
|
spin_lock(&state_lock);
|
|
|
|
spin_lock(&fp->fi_lock);
|
2018-02-16 22:29:42 +03:00
|
|
|
if (fp->fi_had_conflict)
|
2014-07-21 17:34:57 +04:00
|
|
|
status = -EAGAIN;
|
2018-02-16 22:29:42 +03:00
|
|
|
else
|
|
|
|
status = hash_delegation_locked(dp, fp);
|
2014-07-21 17:34:57 +04:00
|
|
|
spin_unlock(&fp->fi_lock);
|
2014-05-30 17:09:30 +04:00
|
|
|
spin_unlock(&state_lock);
|
2018-02-16 22:29:42 +03:00
|
|
|
|
|
|
|
if (status)
|
2018-04-19 00:04:37 +03:00
|
|
|
goto out_unlock;
|
|
|
|
|
2014-07-25 15:34:25 +04:00
|
|
|
return dp;
|
2018-04-19 00:04:37 +03:00
|
|
|
out_unlock:
|
2019-08-18 21:18:53 +03:00
|
|
|
vfs_setlease(fp->fi_deleg_file->nf_file, F_UNLCK, NULL, (void **)&dp);
|
2018-02-16 22:29:42 +03:00
|
|
|
out_clnt_odstate:
|
|
|
|
put_clnt_odstate(dp->dl_clnt_odstate);
|
|
|
|
nfs4_put_stid(&dp->dl_stid);
|
|
|
|
out_delegees:
|
|
|
|
put_deleg_file(fp);
|
|
|
|
return ERR_PTR(status);
|
2011-02-01 01:58:10 +03:00
|
|
|
}
|
|
|
|
|
2012-02-22 02:16:44 +04:00
|
|
|
static void nfsd4_open_deleg_none_ext(struct nfsd4_open *open, int status)
|
|
|
|
{
|
|
|
|
open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
|
|
|
|
if (status == -EAGAIN)
|
|
|
|
open->op_why_no_deleg = WND4_CONTENTION;
|
|
|
|
else {
|
|
|
|
open->op_why_no_deleg = WND4_RESOURCE;
|
|
|
|
switch (open->op_deleg_want) {
|
|
|
|
case NFS4_SHARE_WANT_READ_DELEG:
|
|
|
|
case NFS4_SHARE_WANT_WRITE_DELEG:
|
|
|
|
case NFS4_SHARE_WANT_ANY_DELEG:
|
|
|
|
break;
|
|
|
|
case NFS4_SHARE_WANT_CANCEL:
|
|
|
|
open->op_why_no_deleg = WND4_CANCELLED;
|
|
|
|
break;
|
|
|
|
case NFS4_SHARE_WANT_NO_DELEG:
|
2012-11-25 23:48:10 +04:00
|
|
|
WARN_ON_ONCE(1);
|
2012-02-22 02:16:44 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* Attempt to hand out a delegation.
|
2013-05-22 00:21:25 +04:00
|
|
|
*
|
|
|
|
* Note we don't support write delegations, and won't until the vfs has
|
|
|
|
* proper support for them.
|
2005-04-17 02:20:36 +04:00
|
|
|
*/
|
|
|
|
static void
|
2014-07-25 15:34:24 +04:00
|
|
|
nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open,
|
|
|
|
struct nfs4_ol_stateid *stp)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
struct nfs4_delegation *dp;
|
2014-07-25 15:34:24 +04:00
|
|
|
struct nfs4_openowner *oo = openowner(stp->st_stateowner);
|
|
|
|
struct nfs4_client *clp = stp->st_stid.sc_client;
|
2010-12-11 03:02:49 +03:00
|
|
|
int cb_up;
|
2013-05-22 00:21:25 +04:00
|
|
|
int status = 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-07-31 07:33:59 +04:00
|
|
|
cb_up = nfsd4_cb_channel_good(oo->oo_owner.so_client);
|
2005-06-24 09:03:23 +04:00
|
|
|
open->op_recall = 0;
|
|
|
|
switch (open->op_claim_type) {
|
|
|
|
case NFS4_OPEN_CLAIM_PREVIOUS:
|
2010-03-08 20:37:27 +03:00
|
|
|
if (!cb_up)
|
2005-06-24 09:03:23 +04:00
|
|
|
open->op_recall = 1;
|
2013-05-22 00:21:25 +04:00
|
|
|
if (open->op_delegate_type != NFS4_OPEN_DELEGATE_READ)
|
|
|
|
goto out_no_deleg;
|
2005-06-24 09:03:23 +04:00
|
|
|
break;
|
|
|
|
case NFS4_OPEN_CLAIM_NULL:
|
2014-01-10 01:26:10 +04:00
|
|
|
case NFS4_OPEN_CLAIM_FH:
|
2013-05-22 00:21:25 +04:00
|
|
|
/*
|
|
|
|
* Let's not give out any delegations till everyone's
|
2015-08-06 19:47:02 +03:00
|
|
|
* had the chance to reclaim theirs, *and* until
|
|
|
|
* NLM locks have all been reclaimed:
|
2013-05-22 00:21:25 +04:00
|
|
|
*/
|
2014-07-25 15:34:24 +04:00
|
|
|
if (locks_in_grace(clp->net))
|
2013-05-22 00:21:25 +04:00
|
|
|
goto out_no_deleg;
|
2011-09-12 20:24:13 +04:00
|
|
|
if (!cb_up || !(oo->oo_flags & NFS4_OO_CONFIRMED))
|
2013-05-22 00:21:25 +04:00
|
|
|
goto out_no_deleg;
|
2005-06-24 09:03:23 +04:00
|
|
|
break;
|
|
|
|
default:
|
2013-05-22 00:21:25 +04:00
|
|
|
goto out_no_deleg;
|
2005-06-24 09:03:23 +04:00
|
|
|
}
|
2015-04-27 15:50:14 +03:00
|
|
|
dp = nfs4_set_delegation(clp, fh, stp->st_stid.sc_file, stp->st_clnt_odstate);
|
2014-07-25 15:34:25 +04:00
|
|
|
if (IS_ERR(dp))
|
2011-02-01 01:14:55 +03:00
|
|
|
goto out_no_deleg;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-09-08 20:07:44 +04:00
|
|
|
memcpy(&open->op_delegate_stateid, &dp->dl_stid.sc_stateid, sizeof(dp->dl_stid.sc_stateid));
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2020-08-28 10:02:55 +03:00
|
|
|
trace_nfsd_deleg_read(&dp->dl_stid.sc_stateid);
|
2013-05-22 00:21:25 +04:00
|
|
|
open->op_delegate_type = NFS4_OPEN_DELEGATE_READ;
|
2014-07-30 05:34:17 +04:00
|
|
|
nfs4_put_stid(&dp->dl_stid);
|
2011-02-01 01:14:55 +03:00
|
|
|
return;
|
|
|
|
out_no_deleg:
|
2013-05-22 00:21:25 +04:00
|
|
|
open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE;
|
|
|
|
if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS &&
|
2013-06-21 19:05:32 +04:00
|
|
|
open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE) {
|
2013-05-22 00:21:25 +04:00
|
|
|
dprintk("NFSD: WARNING: refusing delegation reclaim\n");
|
2013-06-21 19:05:32 +04:00
|
|
|
open->op_recall = 1;
|
|
|
|
}
|
2013-05-22 00:21:25 +04:00
|
|
|
|
|
|
|
/* 4.1 client asking for a delegation? */
|
|
|
|
if (open->op_deleg_want)
|
|
|
|
nfsd4_open_deleg_none_ext(open, status);
|
|
|
|
return;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2012-02-22 02:16:54 +04:00
|
|
|
static void nfsd4_deleg_xgrade_none_ext(struct nfsd4_open *open,
|
|
|
|
struct nfs4_delegation *dp)
|
|
|
|
{
|
|
|
|
if (open->op_deleg_want == NFS4_SHARE_WANT_READ_DELEG &&
|
|
|
|
dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
|
|
|
|
open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
|
|
|
|
open->op_why_no_deleg = WND4_NOT_SUPP_DOWNGRADE;
|
|
|
|
} else if (open->op_deleg_want == NFS4_SHARE_WANT_WRITE_DELEG &&
|
|
|
|
dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
|
|
|
|
open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
|
|
|
|
open->op_why_no_deleg = WND4_NOT_SUPP_UPGRADE;
|
|
|
|
}
|
|
|
|
/* Otherwise the client must be confused wanting a delegation
|
|
|
|
* it already has, therefore we don't return
|
|
|
|
* NFS4_OPEN_DELEGATE_NONE_EXT and reason.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32
|
2005-04-17 02:20:36 +04:00
|
|
|
nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
|
|
|
|
{
|
2009-04-03 09:28:45 +04:00
|
|
|
struct nfsd4_compoundres *resp = rqstp->rq_resp;
|
2011-09-24 01:01:19 +04:00
|
|
|
struct nfs4_client *cl = open->op_openowner->oo_owner.so_client;
|
2005-04-17 02:20:36 +04:00
|
|
|
struct nfs4_file *fp = NULL;
|
2011-09-08 00:06:42 +04:00
|
|
|
struct nfs4_ol_stateid *stp = NULL;
|
2005-06-24 09:02:53 +04:00
|
|
|
struct nfs4_delegation *dp = NULL;
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32 status;
|
2017-11-03 15:00:11 +03:00
|
|
|
bool new_stp = false;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Lookup file; if found, lookup stateid and check open request,
|
|
|
|
* and check for delegations in the process of being recalled.
|
|
|
|
* If not found, create the nfs4_file struct
|
|
|
|
*/
|
2021-04-16 21:00:15 +03:00
|
|
|
fp = find_or_add_file(open->op_file, current_fh);
|
2014-06-30 19:48:31 +04:00
|
|
|
if (fp != open->op_file) {
|
2013-03-21 23:49:47 +04:00
|
|
|
status = nfs4_check_deleg(cl, open, &dp);
|
2005-06-24 09:02:54 +04:00
|
|
|
if (status)
|
|
|
|
goto out;
|
2017-11-03 15:00:10 +03:00
|
|
|
stp = nfsd4_find_and_lock_existing_open(fp, open);
|
2005-04-17 02:20:36 +04:00
|
|
|
} else {
|
2014-06-30 19:48:31 +04:00
|
|
|
open->op_file = NULL;
|
2005-06-24 09:02:54 +04:00
|
|
|
status = nfserr_bad_stateid;
|
2011-10-19 19:52:12 +04:00
|
|
|
if (nfsd4_is_deleg_cur(open))
|
2005-06-24 09:02:54 +04:00
|
|
|
goto out;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2017-11-03 15:00:11 +03:00
|
|
|
if (!stp) {
|
|
|
|
stp = init_open_stateid(fp, open);
|
|
|
|
if (!open->op_stp)
|
|
|
|
new_stp = true;
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* OPEN the file, or upgrade an existing OPEN.
|
|
|
|
* If truncate fails, the OPEN fails.
|
2017-11-03 15:00:11 +03:00
|
|
|
*
|
|
|
|
* stp is already locked.
|
2005-04-17 02:20:36 +04:00
|
|
|
*/
|
2017-11-03 15:00:11 +03:00
|
|
|
if (!new_stp) {
|
2005-04-17 02:20:36 +04:00
|
|
|
/* Stateid was found, this is an OPEN upgrade */
|
2010-07-08 19:02:09 +04:00
|
|
|
status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
|
2015-09-17 14:47:08 +03:00
|
|
|
if (status) {
|
2016-06-15 06:28:04 +03:00
|
|
|
mutex_unlock(&stp->st_mutex);
|
2005-04-17 02:20:36 +04:00
|
|
|
goto out;
|
2015-09-17 14:47:08 +03:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
} else {
|
2014-07-10 22:07:31 +04:00
|
|
|
status = nfs4_get_vfs_file(rqstp, fp, current_fh, stp, open);
|
|
|
|
if (status) {
|
2017-11-03 15:00:11 +03:00
|
|
|
stp->st_stid.sc_type = NFS4_CLOSED_STID;
|
2014-07-10 22:07:31 +04:00
|
|
|
release_open_stateid(stp);
|
2017-11-03 15:00:11 +03:00
|
|
|
mutex_unlock(&stp->st_mutex);
|
2014-07-10 22:07:31 +04:00
|
|
|
goto out;
|
|
|
|
}
|
2015-04-27 15:50:14 +03:00
|
|
|
|
|
|
|
stp->st_clnt_odstate = find_or_hash_clnt_odstate(fp,
|
|
|
|
open->op_odstate);
|
|
|
|
if (stp->st_clnt_odstate == open->op_odstate)
|
|
|
|
open->op_odstate = NULL;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2017-11-03 15:00:11 +03:00
|
|
|
|
2015-10-01 16:05:50 +03:00
|
|
|
nfs4_inc_and_copy_stateid(&open->op_stateid, &stp->st_stid);
|
2016-06-15 06:28:04 +03:00
|
|
|
mutex_unlock(&stp->st_mutex);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2012-02-16 22:57:17 +04:00
|
|
|
if (nfsd4_has_session(&resp->cstate)) {
|
|
|
|
if (open->op_deleg_want & NFS4_SHARE_WANT_NO_DELEG) {
|
|
|
|
open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
|
|
|
|
open->op_why_no_deleg = WND4_NOT_WANTED;
|
|
|
|
goto nodeleg;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* Attempt to hand out a delegation. No error return, because the
|
|
|
|
* OPEN succeeds even if we fail.
|
|
|
|
*/
|
2014-07-25 15:34:24 +04:00
|
|
|
nfs4_open_delegation(current_fh, open, stp);
|
2012-02-16 22:57:17 +04:00
|
|
|
nodeleg:
|
2005-04-17 02:20:36 +04:00
|
|
|
status = nfs_ok;
|
2020-08-28 10:02:55 +03:00
|
|
|
trace_nfsd_open(&stp->st_stid.sc_stateid);
|
2005-04-17 02:20:36 +04:00
|
|
|
out:
|
2012-02-16 22:57:17 +04:00
|
|
|
/* 4.1 client trying to upgrade/downgrade delegation? */
|
|
|
|
if (open->op_delegate_type == NFS4_OPEN_DELEGATE_NONE && dp &&
|
2012-02-22 02:16:54 +04:00
|
|
|
open->op_deleg_want)
|
|
|
|
nfsd4_deleg_xgrade_none_ext(open, dp);
|
2012-02-16 22:57:17 +04:00
|
|
|
|
2005-06-24 09:03:10 +04:00
|
|
|
if (fp)
|
|
|
|
put_nfs4_file(fp);
|
2005-07-08 04:59:16 +04:00
|
|
|
if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
|
2015-07-13 12:32:59 +03:00
|
|
|
open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* To finish the open response, we just need to set the rflags.
|
|
|
|
*/
|
|
|
|
open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
|
2016-09-16 23:28:27 +03:00
|
|
|
if (nfsd4_has_session(&resp->cstate))
|
|
|
|
open->op_rflags |= NFS4_OPEN_RESULT_MAY_NOTIFY_LOCK;
|
|
|
|
else if (!(open->op_openowner->oo_flags & NFS4_OO_CONFIRMED))
|
2005-04-17 02:20:36 +04:00
|
|
|
open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
|
2016-09-16 23:28:27 +03:00
|
|
|
|
2014-07-30 05:34:18 +04:00
|
|
|
if (dp)
|
|
|
|
nfs4_put_stid(&dp->dl_stid);
|
2014-07-30 05:34:19 +04:00
|
|
|
if (stp)
|
|
|
|
nfs4_put_stid(&stp->st_stid);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:27 +04:00
|
|
|
void nfsd4_cleanup_open_state(struct nfsd4_compound_state *cstate,
|
2015-03-23 17:53:44 +03:00
|
|
|
struct nfsd4_open *open)
|
2011-10-13 23:12:59 +04:00
|
|
|
{
|
|
|
|
if (open->op_openowner) {
|
2014-07-30 05:34:32 +04:00
|
|
|
struct nfs4_stateowner *so = &open->op_openowner->oo_owner;
|
|
|
|
|
|
|
|
nfsd4_cstate_assign_replay(cstate, so);
|
|
|
|
nfs4_put_stateowner(so);
|
2011-10-13 23:12:59 +04:00
|
|
|
}
|
2011-10-14 00:00:16 +04:00
|
|
|
if (open->op_file)
|
2014-10-23 16:01:02 +04:00
|
|
|
kmem_cache_free(file_slab, open->op_file);
|
2011-10-17 23:57:47 +04:00
|
|
|
if (open->op_stp)
|
2014-07-30 05:34:06 +04:00
|
|
|
nfs4_put_stid(&open->op_stp->st_stid);
|
2015-04-27 15:50:14 +03:00
|
|
|
if (open->op_odstate)
|
|
|
|
kmem_cache_free(odstate_slab, open->op_odstate);
|
2011-10-13 23:12:59 +04:00
|
|
|
}
|
|
|
|
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32
|
2006-12-13 11:35:38 +03:00
|
|
|
nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2017-05-08 21:58:35 +03:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2017-05-08 21:58:35 +03:00
|
|
|
clientid_t *clid = &u->renew;
|
2005-04-17 02:20:36 +04:00
|
|
|
struct nfs4_client *clp;
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32 status;
|
2012-11-14 19:21:05 +04:00
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2020-04-05 18:42:29 +03:00
|
|
|
trace_nfsd_clid_renew(clid);
|
2021-01-22 01:57:43 +03:00
|
|
|
status = set_client(clid, cstate, nn);
|
2012-12-04 02:24:41 +04:00
|
|
|
if (status)
|
2021-01-22 01:57:39 +03:00
|
|
|
return status;
|
2014-06-30 19:48:44 +04:00
|
|
|
clp = cstate->clp;
|
2005-06-24 09:04:17 +04:00
|
|
|
if (!list_empty(&clp->cl_delegations)
|
2010-05-01 02:51:44 +04:00
|
|
|
&& clp->cl_cb_state != NFSD4_CB_UP)
|
2021-01-22 01:57:39 +03:00
|
|
|
return nfserr_cb_path_down;
|
|
|
|
return nfs_ok;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2014-09-13 00:40:21 +04:00
|
|
|
void
|
2012-11-14 19:22:12 +04:00
|
|
|
nfsd4_end_grace(struct nfsd_net *nn)
|
2005-06-24 09:04:01 +04:00
|
|
|
{
|
2012-04-10 19:08:48 +04:00
|
|
|
/* do nothing if grace period already ended */
|
2012-07-25 16:57:37 +04:00
|
|
|
if (nn->grace_ended)
|
2012-04-10 19:08:48 +04:00
|
|
|
return;
|
|
|
|
|
2020-04-05 18:42:29 +03:00
|
|
|
trace_nfsd_grace_complete(nn);
|
2012-07-25 16:57:37 +04:00
|
|
|
nn->grace_ended = true;
|
2014-09-17 01:37:32 +04:00
|
|
|
/*
|
|
|
|
* If the server goes down again right now, an NFSv4
|
|
|
|
* client will still be allowed to reclaim after it comes back up,
|
|
|
|
* even if it hasn't yet had a chance to reclaim state this time.
|
|
|
|
*
|
|
|
|
*/
|
2014-09-13 00:40:20 +04:00
|
|
|
nfsd4_record_grace_done(nn);
|
2014-09-17 01:37:32 +04:00
|
|
|
/*
|
|
|
|
* At this point, NFSv4 clients can still reclaim. But if the
|
|
|
|
* server crashes, any that have not yet reclaimed will be out
|
|
|
|
* of luck on the next boot.
|
|
|
|
*
|
|
|
|
* (NFSv4.1+ clients are considered to have reclaimed once they
|
|
|
|
* call RECLAIM_COMPLETE. NFSv4.0 clients are considered to
|
|
|
|
* have reclaimed after their first OPEN.)
|
|
|
|
*/
|
2012-07-25 16:56:58 +04:00
|
|
|
locks_end_grace(&nn->nfsd4_manager);
|
2014-09-17 01:37:32 +04:00
|
|
|
/*
|
|
|
|
* At this point, and once lockd and/or any other containers
|
|
|
|
* exit their grace period, further reclaims will fail and
|
|
|
|
* regular locking can resume.
|
|
|
|
*/
|
2005-06-24 09:04:01 +04:00
|
|
|
}
|
|
|
|
|
2018-06-08 19:28:47 +03:00
|
|
|
/*
|
|
|
|
* If we've waited a lease period but there are still clients trying to
|
|
|
|
* reclaim, wait a little longer to give them a chance to finish.
|
|
|
|
*/
|
|
|
|
static bool clients_still_reclaiming(struct nfsd_net *nn)
|
|
|
|
{
|
2019-11-04 18:31:52 +03:00
|
|
|
time64_t double_grace_period_end = nn->boot_time +
|
|
|
|
2 * nn->nfsd4_lease;
|
2018-06-08 19:28:47 +03:00
|
|
|
|
2019-03-27 01:06:28 +03:00
|
|
|
if (nn->track_reclaim_completes &&
|
|
|
|
atomic_read(&nn->nr_reclaim_complete) ==
|
|
|
|
nn->reclaim_str_hashtbl_size)
|
|
|
|
return false;
|
2018-06-08 19:28:47 +03:00
|
|
|
if (!nn->somebody_reclaimed)
|
|
|
|
return false;
|
|
|
|
nn->somebody_reclaimed = false;
|
|
|
|
/*
|
|
|
|
* If we've given them *two* lease times to reclaim, and they're
|
|
|
|
* still not done, give up:
|
|
|
|
*/
|
2019-11-04 18:31:52 +03:00
|
|
|
if (ktime_get_boottime_seconds() > double_grace_period_end)
|
2018-06-08 19:28:47 +03:00
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-03-02 18:46:23 +03:00
|
|
|
struct laundry_time {
|
|
|
|
time64_t cutoff;
|
|
|
|
time64_t new_timeo;
|
|
|
|
};
|
|
|
|
|
|
|
|
static bool state_expired(struct laundry_time *lt, time64_t last_refresh)
|
|
|
|
{
|
|
|
|
time64_t time_remaining;
|
|
|
|
|
|
|
|
if (last_refresh < lt->cutoff)
|
|
|
|
return true;
|
|
|
|
time_remaining = last_refresh - lt->cutoff;
|
|
|
|
lt->new_timeo = min(lt->new_timeo, time_remaining);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2021-05-21 22:09:37 +03:00
|
|
|
#ifdef CONFIG_NFSD_V4_2_INTER_SSC
|
|
|
|
void nfsd4_ssc_init_umount_work(struct nfsd_net *nn)
|
|
|
|
{
|
|
|
|
spin_lock_init(&nn->nfsd_ssc_lock);
|
|
|
|
INIT_LIST_HEAD(&nn->nfsd_ssc_mount_list);
|
|
|
|
init_waitqueue_head(&nn->nfsd_ssc_waitq);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nfsd4_ssc_init_umount_work);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is called when nfsd is being shutdown, after all inter_ssc
|
|
|
|
* cleanup were done, to destroy the ssc delayed unmount list.
|
|
|
|
*/
|
|
|
|
static void nfsd4_ssc_shutdown_umount(struct nfsd_net *nn)
|
|
|
|
{
|
2021-06-04 03:02:26 +03:00
|
|
|
struct nfsd4_ssc_umount_item *ni = NULL;
|
2021-05-21 22:09:37 +03:00
|
|
|
struct nfsd4_ssc_umount_item *tmp;
|
|
|
|
|
|
|
|
spin_lock(&nn->nfsd_ssc_lock);
|
|
|
|
list_for_each_entry_safe(ni, tmp, &nn->nfsd_ssc_mount_list, nsui_list) {
|
|
|
|
list_del(&ni->nsui_list);
|
|
|
|
spin_unlock(&nn->nfsd_ssc_lock);
|
|
|
|
mntput(ni->nsui_vfsmount);
|
|
|
|
kfree(ni);
|
|
|
|
spin_lock(&nn->nfsd_ssc_lock);
|
|
|
|
}
|
|
|
|
spin_unlock(&nn->nfsd_ssc_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nfsd4_ssc_expire_umount(struct nfsd_net *nn)
|
|
|
|
{
|
|
|
|
bool do_wakeup = false;
|
|
|
|
struct nfsd4_ssc_umount_item *ni = 0;
|
|
|
|
struct nfsd4_ssc_umount_item *tmp;
|
|
|
|
|
|
|
|
spin_lock(&nn->nfsd_ssc_lock);
|
|
|
|
list_for_each_entry_safe(ni, tmp, &nn->nfsd_ssc_mount_list, nsui_list) {
|
|
|
|
if (time_after(jiffies, ni->nsui_expire)) {
|
|
|
|
if (refcount_read(&ni->nsui_refcnt) > 1)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* mark being unmount */
|
|
|
|
ni->nsui_busy = true;
|
|
|
|
spin_unlock(&nn->nfsd_ssc_lock);
|
|
|
|
mntput(ni->nsui_vfsmount);
|
|
|
|
spin_lock(&nn->nfsd_ssc_lock);
|
|
|
|
|
|
|
|
/* waiters need to start from begin of list */
|
|
|
|
list_del(&ni->nsui_list);
|
|
|
|
kfree(ni);
|
|
|
|
|
|
|
|
/* wakeup ssc_connect waiters */
|
|
|
|
do_wakeup = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (do_wakeup)
|
|
|
|
wake_up_all(&nn->nfsd_ssc_waitq);
|
|
|
|
spin_unlock(&nn->nfsd_ssc_lock);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2019-11-04 18:31:52 +03:00
|
|
|
static time64_t
|
2012-11-14 19:22:17 +04:00
|
|
|
nfs4_laundromat(struct nfsd_net *nn)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
struct nfs4_client *clp;
|
2011-07-31 07:33:59 +04:00
|
|
|
struct nfs4_openowner *oo;
|
2005-04-17 02:20:36 +04:00
|
|
|
struct nfs4_delegation *dp;
|
2014-07-30 16:27:11 +04:00
|
|
|
struct nfs4_ol_stateid *stp;
|
2016-09-16 23:28:25 +03:00
|
|
|
struct nfsd4_blocked_lock *nbl;
|
2005-04-17 02:20:36 +04:00
|
|
|
struct list_head *pos, *next, reaplist;
|
2021-03-02 18:46:23 +03:00
|
|
|
struct laundry_time lt = {
|
|
|
|
.cutoff = ktime_get_boottime_seconds() - nn->nfsd4_lease,
|
|
|
|
.new_timeo = nn->nfsd4_lease
|
|
|
|
};
|
2019-10-04 23:34:26 +03:00
|
|
|
struct nfs4_cpntf_state *cps;
|
|
|
|
copy_stateid_t *cps_t;
|
|
|
|
int i;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2018-06-08 19:28:47 +03:00
|
|
|
if (clients_still_reclaiming(nn)) {
|
2021-03-02 18:46:23 +03:00
|
|
|
lt.new_timeo = 0;
|
2018-06-08 19:28:47 +03:00
|
|
|
goto out;
|
|
|
|
}
|
2012-11-14 19:22:12 +04:00
|
|
|
nfsd4_end_grace(nn);
|
2010-05-12 01:13:04 +04:00
|
|
|
INIT_LIST_HEAD(&reaplist);
|
2019-10-04 23:34:26 +03:00
|
|
|
|
|
|
|
spin_lock(&nn->s2s_cp_lock);
|
|
|
|
idr_for_each_entry(&nn->s2s_cp_stateids, cps_t, i) {
|
|
|
|
cps = container_of(cps_t, struct nfs4_cpntf_state, cp_stateid);
|
|
|
|
if (cps->cp_stateid.sc_type == NFS4_COPYNOTIFY_STID &&
|
2021-03-02 18:46:23 +03:00
|
|
|
state_expired(<, cps->cpntf_time))
|
2019-10-04 23:34:26 +03:00
|
|
|
_free_cpntf_state_locked(nn, cps);
|
|
|
|
}
|
|
|
|
spin_unlock(&nn->s2s_cp_lock);
|
|
|
|
|
2012-11-26 16:21:58 +04:00
|
|
|
spin_lock(&nn->client_lock);
|
2012-11-14 19:21:56 +04:00
|
|
|
list_for_each_safe(pos, next, &nn->client_lru) {
|
2005-04-17 02:20:36 +04:00
|
|
|
clp = list_entry(pos, struct nfs4_client, cl_lru);
|
2021-03-02 18:46:23 +03:00
|
|
|
if (!state_expired(<, clp->cl_time))
|
2005-04-17 02:20:36 +04:00
|
|
|
break;
|
2021-05-14 22:56:06 +03:00
|
|
|
if (mark_client_expired_locked(clp))
|
2010-05-12 01:13:54 +04:00
|
|
|
continue;
|
2014-07-30 16:27:03 +04:00
|
|
|
list_add(&clp->cl_lru, &reaplist);
|
2010-05-12 01:13:04 +04:00
|
|
|
}
|
2012-11-26 16:21:58 +04:00
|
|
|
spin_unlock(&nn->client_lock);
|
2010-05-12 01:13:04 +04:00
|
|
|
list_for_each_safe(pos, next, &reaplist) {
|
|
|
|
clp = list_entry(pos, struct nfs4_client, cl_lru);
|
2020-04-05 18:42:29 +03:00
|
|
|
trace_nfsd_clid_purged(&clp->cl_clientid);
|
2014-07-30 16:27:03 +04:00
|
|
|
list_del_init(&clp->cl_lru);
|
2005-04-17 02:20:36 +04:00
|
|
|
expire_client(clp);
|
|
|
|
}
|
2014-05-30 17:09:30 +04:00
|
|
|
spin_lock(&state_lock);
|
2013-03-21 23:19:33 +04:00
|
|
|
list_for_each_safe(pos, next, &nn->del_recall_lru) {
|
2005-04-17 02:20:36 +04:00
|
|
|
dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
|
2021-03-02 18:46:23 +03:00
|
|
|
if (!state_expired(<, dp->dl_time))
|
2005-04-17 02:20:36 +04:00
|
|
|
break;
|
2015-08-24 19:41:48 +03:00
|
|
|
WARN_ON(!unhash_delegation_locked(dp));
|
2014-07-25 15:34:20 +04:00
|
|
|
list_add(&dp->dl_recall_lru, &reaplist);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2014-05-30 17:09:30 +04:00
|
|
|
spin_unlock(&state_lock);
|
2014-07-25 15:34:21 +04:00
|
|
|
while (!list_empty(&reaplist)) {
|
|
|
|
dp = list_first_entry(&reaplist, struct nfs4_delegation,
|
|
|
|
dl_recall_lru);
|
|
|
|
list_del_init(&dp->dl_recall_lru);
|
2013-04-10 01:02:51 +04:00
|
|
|
revoke_delegation(dp);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2014-07-30 16:27:11 +04:00
|
|
|
|
|
|
|
spin_lock(&nn->client_lock);
|
|
|
|
while (!list_empty(&nn->close_lru)) {
|
|
|
|
oo = list_first_entry(&nn->close_lru, struct nfs4_openowner,
|
|
|
|
oo_close_lru);
|
2021-03-02 18:46:23 +03:00
|
|
|
if (!state_expired(<, oo->oo_time))
|
2005-04-17 02:20:36 +04:00
|
|
|
break;
|
2014-07-30 16:27:11 +04:00
|
|
|
list_del_init(&oo->oo_close_lru);
|
|
|
|
stp = oo->oo_last_closed_stid;
|
|
|
|
oo->oo_last_closed_stid = NULL;
|
|
|
|
spin_unlock(&nn->client_lock);
|
|
|
|
nfs4_put_stid(&stp->st_stid);
|
|
|
|
spin_lock(&nn->client_lock);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2014-07-30 16:27:11 +04:00
|
|
|
spin_unlock(&nn->client_lock);
|
|
|
|
|
2016-09-16 23:28:25 +03:00
|
|
|
/*
|
|
|
|
* It's possible for a client to try and acquire an already held lock
|
|
|
|
* that is being held for a long time, and then lose interest in it.
|
|
|
|
* So, we clean out any un-revisited request after a lease period
|
|
|
|
* under the assumption that the client is no longer interested.
|
|
|
|
*
|
|
|
|
* RFC5661, sec. 9.6 states that the client must not rely on getting
|
|
|
|
* notifications and must continue to poll for locks, even when the
|
|
|
|
* server supports them. Thus this shouldn't lead to clients blocking
|
|
|
|
* indefinitely once the lock does become free.
|
|
|
|
*/
|
|
|
|
BUG_ON(!list_empty(&reaplist));
|
2016-10-20 16:34:31 +03:00
|
|
|
spin_lock(&nn->blocked_locks_lock);
|
2016-09-16 23:28:25 +03:00
|
|
|
while (!list_empty(&nn->blocked_locks_lru)) {
|
|
|
|
nbl = list_first_entry(&nn->blocked_locks_lru,
|
|
|
|
struct nfsd4_blocked_lock, nbl_lru);
|
2021-03-02 18:46:23 +03:00
|
|
|
if (!state_expired(<, nbl->nbl_time))
|
2016-09-16 23:28:25 +03:00
|
|
|
break;
|
|
|
|
list_move(&nbl->nbl_lru, &reaplist);
|
|
|
|
list_del_init(&nbl->nbl_list);
|
|
|
|
}
|
2016-10-20 16:34:31 +03:00
|
|
|
spin_unlock(&nn->blocked_locks_lock);
|
2016-09-16 23:28:25 +03:00
|
|
|
|
|
|
|
while (!list_empty(&reaplist)) {
|
2017-11-09 18:57:16 +03:00
|
|
|
nbl = list_first_entry(&reaplist,
|
2016-09-16 23:28:25 +03:00
|
|
|
struct nfsd4_blocked_lock, nbl_lru);
|
|
|
|
list_del_init(&nbl->nbl_lru);
|
|
|
|
free_blocked_lock(nbl);
|
|
|
|
}
|
2021-05-21 22:09:37 +03:00
|
|
|
#ifdef CONFIG_NFSD_V4_2_INTER_SSC
|
|
|
|
/* service the server-to-server copy delayed unmount list */
|
|
|
|
nfsd4_ssc_expire_umount(nn);
|
|
|
|
#endif
|
2018-06-08 19:28:47 +03:00
|
|
|
out:
|
2021-03-02 18:46:23 +03:00
|
|
|
return max_t(time64_t, lt.new_timeo, NFSD_LAUNDROMAT_MINTIMEOUT);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2008-02-20 23:49:00 +03:00
|
|
|
static struct workqueue_struct *laundry_wq;
|
|
|
|
static void laundromat_main(struct work_struct *);
|
|
|
|
|
|
|
|
static void
|
2012-11-14 19:22:17 +04:00
|
|
|
laundromat_main(struct work_struct *laundry)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2019-11-04 18:31:52 +03:00
|
|
|
time64_t t;
|
2016-01-01 17:06:28 +03:00
|
|
|
struct delayed_work *dwork = to_delayed_work(laundry);
|
2012-11-14 19:22:17 +04:00
|
|
|
struct nfsd_net *nn = container_of(dwork, struct nfsd_net,
|
|
|
|
laundromat_work);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2012-11-14 19:22:17 +04:00
|
|
|
t = nfs4_laundromat(nn);
|
|
|
|
queue_delayed_work(laundry_wq, &nn->laundromat_work, t*HZ);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2015-07-30 13:57:46 +03:00
|
|
|
static inline __be32 nfs4_check_fh(struct svc_fh *fhp, struct nfs4_stid *stp)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2015-07-30 13:57:46 +03:00
|
|
|
if (!fh_match(&fhp->fh_handle, &stp->sc_file->fi_fhandle))
|
2011-09-17 04:12:38 +04:00
|
|
|
return nfserr_bad_stateid;
|
|
|
|
return nfs_ok;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static
|
2011-09-08 00:06:42 +04:00
|
|
|
__be32 nfs4_check_openmode(struct nfs4_ol_stateid *stp, int flags)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32 status = nfserr_openmode;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2010-07-29 23:16:59 +04:00
|
|
|
/* For lock stateid's, we test the parent open, not the lock: */
|
|
|
|
if (stp->st_openstp)
|
|
|
|
stp = stp->st_openstp;
|
2012-05-11 17:45:13 +04:00
|
|
|
if ((flags & WR_STATE) && !access_permit_write(stp))
|
2005-04-17 02:20:36 +04:00
|
|
|
goto out;
|
2012-05-11 17:45:13 +04:00
|
|
|
if ((flags & RD_STATE) && !access_permit_read(stp))
|
2005-04-17 02:20:36 +04:00
|
|
|
goto out;
|
|
|
|
status = nfs_ok;
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-10-20 10:28:59 +04:00
|
|
|
static inline __be32
|
2012-07-25 16:57:22 +04:00
|
|
|
check_special_stateids(struct net *net, svc_fh *current_fh, stateid_t *stateid, int flags)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2009-02-22 00:29:14 +03:00
|
|
|
if (ONE_STATEID(stateid) && (flags & RD_STATE))
|
2005-04-17 02:20:36 +04:00
|
|
|
return nfs_ok;
|
2015-08-06 19:47:02 +03:00
|
|
|
else if (opens_in_grace(net)) {
|
2011-03-31 05:57:33 +04:00
|
|
|
/* Answer in remaining cases depends on existence of
|
2005-04-17 02:20:36 +04:00
|
|
|
* conflicting state; so we must wait out the grace period. */
|
|
|
|
return nfserr_grace;
|
|
|
|
} else if (flags & WR_STATE)
|
|
|
|
return nfs4_share_conflict(current_fh,
|
|
|
|
NFS4_SHARE_DENY_WRITE);
|
|
|
|
else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
|
|
|
|
return nfs4_share_conflict(current_fh,
|
|
|
|
NFS4_SHARE_DENY_READ);
|
|
|
|
}
|
|
|
|
|
2012-04-26 01:58:50 +04:00
|
|
|
static __be32 check_stateid_generation(stateid_t *in, stateid_t *ref, bool has_session)
|
2008-01-27 03:08:12 +03:00
|
|
|
{
|
2009-04-03 09:28:45 +04:00
|
|
|
/*
|
|
|
|
* When sessions are used the stateid generation number is ignored
|
|
|
|
* when it is zero.
|
|
|
|
*/
|
2011-08-22 18:07:12 +04:00
|
|
|
if (has_session && in->si_generation == 0)
|
2011-08-23 19:03:29 +04:00
|
|
|
return nfs_ok;
|
|
|
|
|
|
|
|
if (in->si_generation == ref->si_generation)
|
|
|
|
return nfs_ok;
|
2009-04-03 09:28:45 +04:00
|
|
|
|
2008-01-27 03:08:12 +03:00
|
|
|
/* If the client sends us a stateid from the future, it's buggy: */
|
2016-05-05 13:53:47 +03:00
|
|
|
if (nfsd4_stateid_generation_after(in, ref))
|
2008-01-27 03:08:12 +03:00
|
|
|
return nfserr_bad_stateid;
|
|
|
|
/*
|
2011-08-23 19:03:29 +04:00
|
|
|
* However, we could see a stateid from the past, even from a
|
|
|
|
* non-buggy client. For example, if the client sends a lock
|
|
|
|
* while some IO is outstanding, the lock may bump si_generation
|
|
|
|
* while the IO is still in flight. The client could avoid that
|
|
|
|
* situation by waiting for responses on all the IO requests,
|
|
|
|
* but better performance may result in retrying IO that
|
|
|
|
* receives an old_stateid error if requests are rarely
|
|
|
|
* reordered in flight:
|
2008-01-27 03:08:12 +03:00
|
|
|
*/
|
2011-08-23 19:03:29 +04:00
|
|
|
return nfserr_old_stateid;
|
2008-01-27 03:08:12 +03:00
|
|
|
}
|
|
|
|
|
2017-11-03 15:00:16 +03:00
|
|
|
static __be32 nfsd4_stid_check_stateid_generation(stateid_t *in, struct nfs4_stid *s, bool has_session)
|
|
|
|
{
|
|
|
|
__be32 ret;
|
|
|
|
|
|
|
|
spin_lock(&s->sc_lock);
|
|
|
|
ret = nfsd4_verify_open_stid(s);
|
|
|
|
if (ret == nfs_ok)
|
|
|
|
ret = check_stateid_generation(in, &s->sc_stateid, has_session);
|
|
|
|
spin_unlock(&s->sc_lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-04-28 16:41:15 +03:00
|
|
|
static __be32 nfsd4_check_openowner_confirmed(struct nfs4_ol_stateid *ols)
|
|
|
|
{
|
|
|
|
if (ols->st_stateowner->so_is_open_owner &&
|
|
|
|
!(openowner(ols->st_stateowner)->oo_flags & NFS4_OO_CONFIRMED))
|
|
|
|
return nfserr_bad_stateid;
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2012-05-29 21:56:37 +04:00
|
|
|
static __be32 nfsd4_validate_stateid(struct nfs4_client *cl, stateid_t *stateid)
|
2011-07-13 18:50:48 +04:00
|
|
|
{
|
2011-09-09 19:26:58 +04:00
|
|
|
struct nfs4_stid *s;
|
2014-07-30 05:34:14 +04:00
|
|
|
__be32 status = nfserr_bad_stateid;
|
2011-07-13 18:50:48 +04:00
|
|
|
|
2017-11-09 21:41:10 +03:00
|
|
|
if (ZERO_STATEID(stateid) || ONE_STATEID(stateid) ||
|
|
|
|
CLOSE_STATEID(stateid))
|
2014-07-30 05:34:14 +04:00
|
|
|
return status;
|
2020-03-19 17:18:49 +03:00
|
|
|
if (!same_clid(&stateid->si_opaque.so_clid, &cl->cl_clientid))
|
2014-07-30 05:34:14 +04:00
|
|
|
return status;
|
|
|
|
spin_lock(&cl->cl_lock);
|
|
|
|
s = find_stateid_locked(cl, stateid);
|
2011-09-09 19:26:58 +04:00
|
|
|
if (!s)
|
2014-07-30 05:34:14 +04:00
|
|
|
goto out_unlock;
|
2017-11-03 15:00:16 +03:00
|
|
|
status = nfsd4_stid_check_stateid_generation(stateid, s, 1);
|
2011-07-13 18:50:48 +04:00
|
|
|
if (status)
|
2014-07-30 05:34:14 +04:00
|
|
|
goto out_unlock;
|
2013-04-10 01:42:28 +04:00
|
|
|
switch (s->sc_type) {
|
|
|
|
case NFS4_DELEG_STID:
|
2014-07-30 05:34:14 +04:00
|
|
|
status = nfs_ok;
|
|
|
|
break;
|
2013-04-10 01:02:51 +04:00
|
|
|
case NFS4_REVOKED_DELEG_STID:
|
2014-07-30 05:34:14 +04:00
|
|
|
status = nfserr_deleg_revoked;
|
|
|
|
break;
|
2013-04-10 01:42:28 +04:00
|
|
|
case NFS4_OPEN_STID:
|
|
|
|
case NFS4_LOCK_STID:
|
2015-04-28 16:41:15 +03:00
|
|
|
status = nfsd4_check_openowner_confirmed(openlockstateid(s));
|
2014-07-30 05:34:14 +04:00
|
|
|
break;
|
2013-04-10 01:42:28 +04:00
|
|
|
default:
|
|
|
|
printk("unknown stateid type %x\n", s->sc_type);
|
2020-08-24 01:36:59 +03:00
|
|
|
fallthrough;
|
2013-04-10 01:42:28 +04:00
|
|
|
case NFS4_CLOSED_STID:
|
2014-07-16 18:31:59 +04:00
|
|
|
case NFS4_CLOSED_DELEG_STID:
|
2014-07-30 05:34:14 +04:00
|
|
|
status = nfserr_bad_stateid;
|
2013-04-10 01:42:28 +04:00
|
|
|
}
|
2014-07-30 05:34:14 +04:00
|
|
|
out_unlock:
|
|
|
|
spin_unlock(&cl->cl_lock);
|
|
|
|
return status;
|
2011-07-13 18:50:48 +04:00
|
|
|
}
|
|
|
|
|
2014-08-14 10:44:57 +04:00
|
|
|
__be32
|
2014-06-30 19:48:43 +04:00
|
|
|
nfsd4_lookup_stateid(struct nfsd4_compound_state *cstate,
|
|
|
|
stateid_t *stateid, unsigned char typemask,
|
|
|
|
struct nfs4_stid **s, struct nfsd_net *nn)
|
2011-09-24 01:01:19 +04:00
|
|
|
{
|
2013-03-13 01:36:17 +04:00
|
|
|
__be32 status;
|
2017-11-03 21:06:31 +03:00
|
|
|
bool return_revoked = false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* only return revoked delegations if explicitly asked.
|
|
|
|
* otherwise we report revoked or bad_stateid status.
|
|
|
|
*/
|
|
|
|
if (typemask & NFS4_REVOKED_DELEG_STID)
|
|
|
|
return_revoked = true;
|
|
|
|
else if (typemask & NFS4_DELEG_STID)
|
|
|
|
typemask |= NFS4_REVOKED_DELEG_STID;
|
2011-09-24 01:01:19 +04:00
|
|
|
|
2017-11-09 21:41:10 +03:00
|
|
|
if (ZERO_STATEID(stateid) || ONE_STATEID(stateid) ||
|
|
|
|
CLOSE_STATEID(stateid))
|
2011-09-24 01:01:19 +04:00
|
|
|
return nfserr_bad_stateid;
|
2021-01-22 01:57:43 +03:00
|
|
|
status = set_client(&stateid->si_opaque.so_clid, cstate, nn);
|
2014-03-29 22:43:38 +04:00
|
|
|
if (status == nfserr_stale_clientid) {
|
2014-06-30 19:48:44 +04:00
|
|
|
if (cstate->session)
|
2014-03-29 22:43:38 +04:00
|
|
|
return nfserr_bad_stateid;
|
2011-09-24 01:01:19 +04:00
|
|
|
return nfserr_stale_stateid;
|
2014-03-29 22:43:38 +04:00
|
|
|
}
|
2013-03-13 01:36:17 +04:00
|
|
|
if (status)
|
|
|
|
return status;
|
2014-06-30 19:48:44 +04:00
|
|
|
*s = find_stateid_by_type(cstate->clp, stateid, typemask);
|
2011-09-24 01:01:19 +04:00
|
|
|
if (!*s)
|
|
|
|
return nfserr_bad_stateid;
|
2017-11-03 21:06:31 +03:00
|
|
|
if (((*s)->sc_type == NFS4_REVOKED_DELEG_STID) && !return_revoked) {
|
|
|
|
nfs4_put_stid(*s);
|
|
|
|
if (cstate->minorversion)
|
|
|
|
return nfserr_deleg_revoked;
|
|
|
|
return nfserr_bad_stateid;
|
|
|
|
}
|
2011-09-24 01:01:19 +04:00
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2019-08-18 21:18:53 +03:00
|
|
|
static struct nfsd_file *
|
2015-06-18 17:44:59 +03:00
|
|
|
nfs4_find_file(struct nfs4_stid *s, int flags)
|
|
|
|
{
|
2015-06-18 17:45:00 +03:00
|
|
|
if (!s)
|
|
|
|
return NULL;
|
|
|
|
|
2015-06-18 17:44:59 +03:00
|
|
|
switch (s->sc_type) {
|
|
|
|
case NFS4_DELEG_STID:
|
|
|
|
if (WARN_ON_ONCE(!s->sc_file->fi_deleg_file))
|
|
|
|
return NULL;
|
2019-08-18 21:18:53 +03:00
|
|
|
return nfsd_file_get(s->sc_file->fi_deleg_file);
|
2015-06-18 17:44:59 +03:00
|
|
|
case NFS4_OPEN_STID:
|
|
|
|
case NFS4_LOCK_STID:
|
|
|
|
if (flags & RD_STATE)
|
|
|
|
return find_readable_file(s->sc_file);
|
|
|
|
else
|
|
|
|
return find_writeable_file(s->sc_file);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
2018-11-06 04:04:06 +03:00
|
|
|
nfs4_check_olstateid(struct nfs4_ol_stateid *ols, int flags)
|
2015-06-18 17:44:59 +03:00
|
|
|
{
|
|
|
|
__be32 status;
|
|
|
|
|
|
|
|
status = nfsd4_check_openowner_confirmed(ols);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
return nfs4_check_openmode(ols, flags);
|
|
|
|
}
|
|
|
|
|
2015-06-18 17:45:00 +03:00
|
|
|
static __be32
|
|
|
|
nfs4_check_file(struct svc_rqst *rqstp, struct svc_fh *fhp, struct nfs4_stid *s,
|
2019-08-18 21:18:54 +03:00
|
|
|
struct nfsd_file **nfp, int flags)
|
2015-06-18 17:45:00 +03:00
|
|
|
{
|
|
|
|
int acc = (flags & RD_STATE) ? NFSD_MAY_READ : NFSD_MAY_WRITE;
|
2019-08-18 21:18:53 +03:00
|
|
|
struct nfsd_file *nf;
|
2015-06-18 17:45:00 +03:00
|
|
|
__be32 status;
|
|
|
|
|
2019-08-18 21:18:53 +03:00
|
|
|
nf = nfs4_find_file(s, flags);
|
|
|
|
if (nf) {
|
2015-06-18 17:45:00 +03:00
|
|
|
status = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
|
|
|
|
acc | NFSD_MAY_OWNER_OVERRIDE);
|
2019-08-18 21:18:54 +03:00
|
|
|
if (status) {
|
|
|
|
nfsd_file_put(nf);
|
2019-08-18 21:18:53 +03:00
|
|
|
goto out;
|
2019-08-18 21:18:54 +03:00
|
|
|
}
|
2015-06-18 17:45:00 +03:00
|
|
|
} else {
|
2019-08-18 21:18:53 +03:00
|
|
|
status = nfsd_file_acquire(rqstp, fhp, acc, &nf);
|
2015-06-18 17:45:00 +03:00
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
}
|
2019-08-18 21:18:54 +03:00
|
|
|
*nfp = nf;
|
2019-08-18 21:18:53 +03:00
|
|
|
out:
|
|
|
|
return status;
|
2015-06-18 17:45:00 +03:00
|
|
|
}
|
2019-10-04 23:34:26 +03:00
|
|
|
static void
|
|
|
|
_free_cpntf_state_locked(struct nfsd_net *nn, struct nfs4_cpntf_state *cps)
|
|
|
|
{
|
|
|
|
WARN_ON_ONCE(cps->cp_stateid.sc_type != NFS4_COPYNOTIFY_STID);
|
|
|
|
if (!refcount_dec_and_test(&cps->cp_stateid.sc_count))
|
|
|
|
return;
|
|
|
|
list_del(&cps->cp_list);
|
|
|
|
idr_remove(&nn->s2s_cp_stateids,
|
|
|
|
cps->cp_stateid.stid.si_opaque.so_id);
|
|
|
|
kfree(cps);
|
|
|
|
}
|
2019-09-06 22:17:21 +03:00
|
|
|
/*
|
|
|
|
* A READ from an inter server to server COPY will have a
|
|
|
|
* copy stateid. Look up the copy notify stateid from the
|
|
|
|
* idr structure and take a reference on it.
|
|
|
|
*/
|
2019-10-09 18:50:48 +03:00
|
|
|
__be32 manage_cpntf_state(struct nfsd_net *nn, stateid_t *st,
|
|
|
|
struct nfs4_client *clp,
|
|
|
|
struct nfs4_cpntf_state **cps)
|
2019-09-06 22:17:21 +03:00
|
|
|
{
|
|
|
|
copy_stateid_t *cps_t;
|
|
|
|
struct nfs4_cpntf_state *state = NULL;
|
|
|
|
|
|
|
|
if (st->si_opaque.so_clid.cl_id != nn->s2s_cp_cl_id)
|
|
|
|
return nfserr_bad_stateid;
|
|
|
|
spin_lock(&nn->s2s_cp_lock);
|
|
|
|
cps_t = idr_find(&nn->s2s_cp_stateids, st->si_opaque.so_id);
|
|
|
|
if (cps_t) {
|
|
|
|
state = container_of(cps_t, struct nfs4_cpntf_state,
|
|
|
|
cp_stateid);
|
2019-12-04 10:59:36 +03:00
|
|
|
if (state->cp_stateid.sc_type != NFS4_COPYNOTIFY_STID) {
|
|
|
|
state = NULL;
|
|
|
|
goto unlock;
|
|
|
|
}
|
2019-10-09 18:50:48 +03:00
|
|
|
if (!clp)
|
|
|
|
refcount_inc(&state->cp_stateid.sc_count);
|
|
|
|
else
|
|
|
|
_free_cpntf_state_locked(nn, state);
|
2019-09-06 22:17:21 +03:00
|
|
|
}
|
2019-12-04 10:59:36 +03:00
|
|
|
unlock:
|
2019-09-06 22:17:21 +03:00
|
|
|
spin_unlock(&nn->s2s_cp_lock);
|
|
|
|
if (!state)
|
|
|
|
return nfserr_bad_stateid;
|
2019-10-09 18:50:48 +03:00
|
|
|
if (!clp && state)
|
|
|
|
*cps = state;
|
2019-09-06 22:17:21 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32 find_cpntf_state(struct nfsd_net *nn, stateid_t *st,
|
|
|
|
struct nfs4_stid **stid)
|
|
|
|
{
|
|
|
|
__be32 status;
|
|
|
|
struct nfs4_cpntf_state *cps = NULL;
|
2021-01-22 01:57:42 +03:00
|
|
|
struct nfs4_client *found;
|
2019-09-06 22:17:21 +03:00
|
|
|
|
2019-10-09 18:50:48 +03:00
|
|
|
status = manage_cpntf_state(nn, st, NULL, &cps);
|
2019-09-06 22:17:21 +03:00
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
2019-11-04 18:31:52 +03:00
|
|
|
cps->cpntf_time = ktime_get_boottime_seconds();
|
2021-01-22 01:57:42 +03:00
|
|
|
|
|
|
|
status = nfserr_expired;
|
|
|
|
found = lookup_clientid(&cps->cp_p_clid, true, nn);
|
|
|
|
if (!found)
|
2019-09-06 22:17:21 +03:00
|
|
|
goto out;
|
2021-01-22 01:57:42 +03:00
|
|
|
|
|
|
|
*stid = find_stateid_by_type(found, &cps->cp_p_stateid,
|
|
|
|
NFS4_DELEG_STID|NFS4_OPEN_STID|NFS4_LOCK_STID);
|
|
|
|
if (*stid)
|
|
|
|
status = nfs_ok;
|
|
|
|
else
|
|
|
|
status = nfserr_bad_stateid;
|
|
|
|
|
|
|
|
put_client_renew(found);
|
2019-09-06 22:17:21 +03:00
|
|
|
out:
|
|
|
|
nfs4_put_cpntf_state(nn, cps);
|
|
|
|
return status;
|
|
|
|
}
|
2019-10-04 23:34:26 +03:00
|
|
|
|
|
|
|
void nfs4_put_cpntf_state(struct nfsd_net *nn, struct nfs4_cpntf_state *cps)
|
|
|
|
{
|
|
|
|
spin_lock(&nn->s2s_cp_lock);
|
|
|
|
_free_cpntf_state_locked(nn, cps);
|
|
|
|
spin_unlock(&nn->s2s_cp_lock);
|
|
|
|
}
|
2015-06-18 17:45:00 +03:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
2015-06-18 17:44:59 +03:00
|
|
|
* Checks for stateid operations
|
|
|
|
*/
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32
|
2015-06-18 17:45:00 +03:00
|
|
|
nfs4_preprocess_stateid_op(struct svc_rqst *rqstp,
|
2015-12-03 14:59:51 +03:00
|
|
|
struct nfsd4_compound_state *cstate, struct svc_fh *fhp,
|
2019-10-04 23:34:26 +03:00
|
|
|
stateid_t *stateid, int flags, struct nfsd_file **nfp,
|
|
|
|
struct nfs4_stid **cstid)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2015-06-18 17:45:00 +03:00
|
|
|
struct net *net = SVC_NET(rqstp);
|
2012-11-14 19:22:07 +04:00
|
|
|
struct nfsd_net *nn = net_generic(net, nfsd_net_id);
|
2015-06-18 17:45:00 +03:00
|
|
|
struct nfs4_stid *s = NULL;
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32 status;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2019-08-18 21:18:54 +03:00
|
|
|
if (nfp)
|
|
|
|
*nfp = NULL;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2015-06-18 17:45:00 +03:00
|
|
|
if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) {
|
|
|
|
status = check_special_stateids(net, fhp, stateid, flags);
|
|
|
|
goto done;
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2014-06-30 19:48:43 +04:00
|
|
|
status = nfsd4_lookup_stateid(cstate, stateid,
|
2014-06-30 19:48:36 +04:00
|
|
|
NFS4_DELEG_STID|NFS4_OPEN_STID|NFS4_LOCK_STID,
|
2014-06-30 19:48:43 +04:00
|
|
|
&s, nn);
|
2019-09-06 22:17:21 +03:00
|
|
|
if (status == nfserr_bad_stateid)
|
|
|
|
status = find_cpntf_state(nn, stateid, &s);
|
2011-09-24 01:01:19 +04:00
|
|
|
if (status)
|
2014-07-30 16:27:25 +04:00
|
|
|
return status;
|
2017-11-03 15:00:16 +03:00
|
|
|
status = nfsd4_stid_check_stateid_generation(stateid, s,
|
2015-06-18 17:44:59 +03:00
|
|
|
nfsd4_has_session(cstate));
|
2011-09-09 19:54:57 +04:00
|
|
|
if (status)
|
|
|
|
goto out;
|
2015-06-18 17:44:59 +03:00
|
|
|
|
2011-09-17 04:12:38 +04:00
|
|
|
switch (s->sc_type) {
|
|
|
|
case NFS4_DELEG_STID:
|
2015-06-18 17:44:59 +03:00
|
|
|
status = nfs4_check_delegmode(delegstateid(s), flags);
|
2011-09-17 04:12:38 +04:00
|
|
|
break;
|
|
|
|
case NFS4_OPEN_STID:
|
|
|
|
case NFS4_LOCK_STID:
|
2018-11-06 04:04:06 +03:00
|
|
|
status = nfs4_check_olstateid(openlockstateid(s), flags);
|
2011-09-17 04:12:38 +04:00
|
|
|
break;
|
|
|
|
default:
|
2014-04-18 22:44:07 +04:00
|
|
|
status = nfserr_bad_stateid;
|
2015-06-18 17:44:59 +03:00
|
|
|
break;
|
|
|
|
}
|
2015-07-30 13:57:46 +03:00
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = nfs4_check_fh(fhp, s);
|
2015-06-18 17:44:59 +03:00
|
|
|
|
2015-06-18 17:45:00 +03:00
|
|
|
done:
|
2019-08-18 21:18:54 +03:00
|
|
|
if (status == nfs_ok && nfp)
|
|
|
|
status = nfs4_check_file(rqstp, fhp, s, nfp, flags);
|
2005-04-17 02:20:36 +04:00
|
|
|
out:
|
2019-10-04 23:34:26 +03:00
|
|
|
if (s) {
|
|
|
|
if (!status && cstid)
|
|
|
|
*cstid = s;
|
|
|
|
else
|
|
|
|
nfs4_put_stid(s);
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2011-07-13 18:50:48 +04:00
|
|
|
/*
|
|
|
|
* Test if the stateid is valid
|
|
|
|
*/
|
|
|
|
__be32
|
|
|
|
nfsd4_test_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2017-05-08 21:58:35 +03:00
|
|
|
union nfsd4_op_u *u)
|
2011-07-13 18:50:48 +04:00
|
|
|
{
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_test_stateid *test_stateid = &u->test_stateid;
|
2012-01-27 19:22:49 +04:00
|
|
|
struct nfsd4_test_stateid_id *stateid;
|
2021-01-22 01:57:45 +03:00
|
|
|
struct nfs4_client *cl = cstate->clp;
|
2012-01-27 19:22:49 +04:00
|
|
|
|
|
|
|
list_for_each_entry(stateid, &test_stateid->ts_stateid_list, ts_id_list)
|
2012-05-29 21:56:37 +04:00
|
|
|
stateid->ts_id_status =
|
|
|
|
nfsd4_validate_stateid(cl, &stateid->ts_id_stateid);
|
2012-01-27 19:22:49 +04:00
|
|
|
|
2011-07-13 18:50:48 +04:00
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
nfsd: Fix race between FREE_STATEID and LOCK
When running LTP's nfslock01 test, the Linux client can send a LOCK
and a FREE_STATEID request at the same time. The outcome is:
Frame 324 R OPEN stateid [2,O]
Frame 115004 C LOCK lockowner_is_new stateid [2,O] offset 672000 len 64
Frame 115008 R LOCK stateid [1,L]
Frame 115012 C WRITE stateid [0,L] offset 672000 len 64
Frame 115016 R WRITE NFS4_OK
Frame 115019 C LOCKU stateid [1,L] offset 672000 len 64
Frame 115022 R LOCKU NFS4_OK
Frame 115025 C FREE_STATEID stateid [2,L]
Frame 115026 C LOCK lockowner_is_new stateid [2,O] offset 672128 len 64
Frame 115029 R FREE_STATEID NFS4_OK
Frame 115030 R LOCK stateid [3,L]
Frame 115034 C WRITE stateid [0,L] offset 672128 len 64
Frame 115038 R WRITE NFS4ERR_BAD_STATEID
In other words, the server returns stateid L in a successful LOCK
reply, but it has already released it. Subsequent uses of stateid L
fail.
To address this, protect the generation check in nfsd4_free_stateid
with the st_mutex. This should guarantee that only one of two
outcomes occurs: either LOCK returns a fresh valid stateid, or
FREE_STATEID returns NFS4ERR_LOCKS_HELD.
Reported-by: Alexey Kodanev <alexey.kodanev@oracle.com>
Fix-suggested-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Tested-by: Alexey Kodanev <alexey.kodanev@oracle.com>
Cc: stable@vger.kernel.org
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2016-08-11 17:37:30 +03:00
|
|
|
static __be32
|
|
|
|
nfsd4_free_lock_stateid(stateid_t *stateid, struct nfs4_stid *s)
|
|
|
|
{
|
|
|
|
struct nfs4_ol_stateid *stp = openlockstateid(s);
|
|
|
|
__be32 ret;
|
|
|
|
|
2017-11-03 15:00:13 +03:00
|
|
|
ret = nfsd4_lock_ol_stateid(stp);
|
|
|
|
if (ret)
|
|
|
|
goto out_put_stid;
|
nfsd: Fix race between FREE_STATEID and LOCK
When running LTP's nfslock01 test, the Linux client can send a LOCK
and a FREE_STATEID request at the same time. The outcome is:
Frame 324 R OPEN stateid [2,O]
Frame 115004 C LOCK lockowner_is_new stateid [2,O] offset 672000 len 64
Frame 115008 R LOCK stateid [1,L]
Frame 115012 C WRITE stateid [0,L] offset 672000 len 64
Frame 115016 R WRITE NFS4_OK
Frame 115019 C LOCKU stateid [1,L] offset 672000 len 64
Frame 115022 R LOCKU NFS4_OK
Frame 115025 C FREE_STATEID stateid [2,L]
Frame 115026 C LOCK lockowner_is_new stateid [2,O] offset 672128 len 64
Frame 115029 R FREE_STATEID NFS4_OK
Frame 115030 R LOCK stateid [3,L]
Frame 115034 C WRITE stateid [0,L] offset 672128 len 64
Frame 115038 R WRITE NFS4ERR_BAD_STATEID
In other words, the server returns stateid L in a successful LOCK
reply, but it has already released it. Subsequent uses of stateid L
fail.
To address this, protect the generation check in nfsd4_free_stateid
with the st_mutex. This should guarantee that only one of two
outcomes occurs: either LOCK returns a fresh valid stateid, or
FREE_STATEID returns NFS4ERR_LOCKS_HELD.
Reported-by: Alexey Kodanev <alexey.kodanev@oracle.com>
Fix-suggested-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Tested-by: Alexey Kodanev <alexey.kodanev@oracle.com>
Cc: stable@vger.kernel.org
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2016-08-11 17:37:30 +03:00
|
|
|
|
|
|
|
ret = check_stateid_generation(stateid, &s->sc_stateid, 1);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = nfserr_locks_held;
|
|
|
|
if (check_for_locks(stp->st_stid.sc_file,
|
|
|
|
lockowner(stp->st_stateowner)))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
release_lock_stateid(stp);
|
|
|
|
ret = nfs_ok;
|
|
|
|
|
|
|
|
out:
|
|
|
|
mutex_unlock(&stp->st_mutex);
|
2017-11-03 15:00:13 +03:00
|
|
|
out_put_stid:
|
nfsd: Fix race between FREE_STATEID and LOCK
When running LTP's nfslock01 test, the Linux client can send a LOCK
and a FREE_STATEID request at the same time. The outcome is:
Frame 324 R OPEN stateid [2,O]
Frame 115004 C LOCK lockowner_is_new stateid [2,O] offset 672000 len 64
Frame 115008 R LOCK stateid [1,L]
Frame 115012 C WRITE stateid [0,L] offset 672000 len 64
Frame 115016 R WRITE NFS4_OK
Frame 115019 C LOCKU stateid [1,L] offset 672000 len 64
Frame 115022 R LOCKU NFS4_OK
Frame 115025 C FREE_STATEID stateid [2,L]
Frame 115026 C LOCK lockowner_is_new stateid [2,O] offset 672128 len 64
Frame 115029 R FREE_STATEID NFS4_OK
Frame 115030 R LOCK stateid [3,L]
Frame 115034 C WRITE stateid [0,L] offset 672128 len 64
Frame 115038 R WRITE NFS4ERR_BAD_STATEID
In other words, the server returns stateid L in a successful LOCK
reply, but it has already released it. Subsequent uses of stateid L
fail.
To address this, protect the generation check in nfsd4_free_stateid
with the st_mutex. This should guarantee that only one of two
outcomes occurs: either LOCK returns a fresh valid stateid, or
FREE_STATEID returns NFS4ERR_LOCKS_HELD.
Reported-by: Alexey Kodanev <alexey.kodanev@oracle.com>
Fix-suggested-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Tested-by: Alexey Kodanev <alexey.kodanev@oracle.com>
Cc: stable@vger.kernel.org
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2016-08-11 17:37:30 +03:00
|
|
|
nfs4_put_stid(s);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-07-13 19:04:21 +04:00
|
|
|
__be32
|
|
|
|
nfsd4_free_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2017-05-08 21:58:35 +03:00
|
|
|
union nfsd4_op_u *u)
|
2011-07-13 19:04:21 +04:00
|
|
|
{
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_free_stateid *free_stateid = &u->free_stateid;
|
2011-07-13 19:04:21 +04:00
|
|
|
stateid_t *stateid = &free_stateid->fr_stateid;
|
2011-09-17 02:56:20 +04:00
|
|
|
struct nfs4_stid *s;
|
2013-04-10 01:02:51 +04:00
|
|
|
struct nfs4_delegation *dp;
|
2021-01-22 01:57:45 +03:00
|
|
|
struct nfs4_client *cl = cstate->clp;
|
2011-09-17 02:56:20 +04:00
|
|
|
__be32 ret = nfserr_bad_stateid;
|
2011-07-13 19:04:21 +04:00
|
|
|
|
2014-07-30 05:34:14 +04:00
|
|
|
spin_lock(&cl->cl_lock);
|
|
|
|
s = find_stateid_locked(cl, stateid);
|
2011-09-17 02:56:20 +04:00
|
|
|
if (!s)
|
2014-07-30 05:34:14 +04:00
|
|
|
goto out_unlock;
|
2017-11-03 15:00:16 +03:00
|
|
|
spin_lock(&s->sc_lock);
|
2011-09-17 02:56:20 +04:00
|
|
|
switch (s->sc_type) {
|
|
|
|
case NFS4_DELEG_STID:
|
2011-07-13 19:04:21 +04:00
|
|
|
ret = nfserr_locks_held;
|
2014-07-30 05:34:14 +04:00
|
|
|
break;
|
2011-09-17 02:56:20 +04:00
|
|
|
case NFS4_OPEN_STID:
|
|
|
|
ret = check_stateid_generation(stateid, &s->sc_stateid, 1);
|
|
|
|
if (ret)
|
2014-07-30 05:34:14 +04:00
|
|
|
break;
|
|
|
|
ret = nfserr_locks_held;
|
2011-09-17 04:12:38 +04:00
|
|
|
break;
|
2014-07-30 05:34:14 +04:00
|
|
|
case NFS4_LOCK_STID:
|
2017-11-03 15:00:16 +03:00
|
|
|
spin_unlock(&s->sc_lock);
|
2017-10-20 12:53:28 +03:00
|
|
|
refcount_inc(&s->sc_count);
|
2014-07-30 05:34:14 +04:00
|
|
|
spin_unlock(&cl->cl_lock);
|
nfsd: Fix race between FREE_STATEID and LOCK
When running LTP's nfslock01 test, the Linux client can send a LOCK
and a FREE_STATEID request at the same time. The outcome is:
Frame 324 R OPEN stateid [2,O]
Frame 115004 C LOCK lockowner_is_new stateid [2,O] offset 672000 len 64
Frame 115008 R LOCK stateid [1,L]
Frame 115012 C WRITE stateid [0,L] offset 672000 len 64
Frame 115016 R WRITE NFS4_OK
Frame 115019 C LOCKU stateid [1,L] offset 672000 len 64
Frame 115022 R LOCKU NFS4_OK
Frame 115025 C FREE_STATEID stateid [2,L]
Frame 115026 C LOCK lockowner_is_new stateid [2,O] offset 672128 len 64
Frame 115029 R FREE_STATEID NFS4_OK
Frame 115030 R LOCK stateid [3,L]
Frame 115034 C WRITE stateid [0,L] offset 672128 len 64
Frame 115038 R WRITE NFS4ERR_BAD_STATEID
In other words, the server returns stateid L in a successful LOCK
reply, but it has already released it. Subsequent uses of stateid L
fail.
To address this, protect the generation check in nfsd4_free_stateid
with the st_mutex. This should guarantee that only one of two
outcomes occurs: either LOCK returns a fresh valid stateid, or
FREE_STATEID returns NFS4ERR_LOCKS_HELD.
Reported-by: Alexey Kodanev <alexey.kodanev@oracle.com>
Fix-suggested-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: Chuck Lever <chuck.lever@oracle.com>
Tested-by: Alexey Kodanev <alexey.kodanev@oracle.com>
Cc: stable@vger.kernel.org
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
2016-08-11 17:37:30 +03:00
|
|
|
ret = nfsd4_free_lock_stateid(stateid, s);
|
2014-07-30 05:34:14 +04:00
|
|
|
goto out;
|
2013-04-10 01:02:51 +04:00
|
|
|
case NFS4_REVOKED_DELEG_STID:
|
2017-11-03 15:00:16 +03:00
|
|
|
spin_unlock(&s->sc_lock);
|
2013-04-10 01:02:51 +04:00
|
|
|
dp = delegstateid(s);
|
2014-07-25 15:34:21 +04:00
|
|
|
list_del_init(&dp->dl_recall_lru);
|
|
|
|
spin_unlock(&cl->cl_lock);
|
2014-07-30 05:34:06 +04:00
|
|
|
nfs4_put_stid(s);
|
2013-04-10 01:02:51 +04:00
|
|
|
ret = nfs_ok;
|
2014-07-30 05:34:14 +04:00
|
|
|
goto out;
|
|
|
|
/* Default falls through and returns nfserr_bad_stateid */
|
2011-07-13 19:04:21 +04:00
|
|
|
}
|
2017-11-03 15:00:16 +03:00
|
|
|
spin_unlock(&s->sc_lock);
|
2014-07-30 05:34:14 +04:00
|
|
|
out_unlock:
|
|
|
|
spin_unlock(&cl->cl_lock);
|
2011-07-13 19:04:21 +04:00
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-07-08 04:59:27 +04:00
|
|
|
static inline int
|
|
|
|
setlkflg (int type)
|
|
|
|
{
|
|
|
|
return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
|
|
|
|
RD_STATE : WR_STATE;
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-09-08 00:06:42 +04:00
|
|
|
static __be32 nfs4_seqid_op_checks(struct nfsd4_compound_state *cstate, stateid_t *stateid, u32 seqid, struct nfs4_ol_stateid *stp)
|
2011-09-06 23:19:46 +04:00
|
|
|
{
|
|
|
|
struct svc_fh *current_fh = &cstate->current_fh;
|
|
|
|
struct nfs4_stateowner *sop = stp->st_stateowner;
|
|
|
|
__be32 status;
|
|
|
|
|
|
|
|
status = nfsd4_check_seqid(cstate, sop, seqid);
|
|
|
|
if (status)
|
|
|
|
return status;
|
2017-11-03 15:00:15 +03:00
|
|
|
status = nfsd4_lock_ol_stateid(stp);
|
|
|
|
if (status != nfs_ok)
|
|
|
|
return status;
|
2011-09-17 04:12:38 +04:00
|
|
|
status = check_stateid_generation(stateid, &stp->st_stid.sc_stateid, nfsd4_has_session(cstate));
|
2015-09-17 14:47:08 +03:00
|
|
|
if (status == nfs_ok)
|
|
|
|
status = nfs4_check_fh(current_fh, &stp->st_stid);
|
|
|
|
if (status != nfs_ok)
|
2016-06-15 06:28:04 +03:00
|
|
|
mutex_unlock(&stp->st_mutex);
|
2015-09-17 14:47:08 +03:00
|
|
|
return status;
|
2011-09-06 23:19:46 +04:00
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* Checks for sequence id mutating operations.
|
|
|
|
*/
|
2006-10-20 10:28:59 +04:00
|
|
|
static __be32
|
2009-04-03 09:28:41 +04:00
|
|
|
nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
|
2011-09-06 23:50:21 +04:00
|
|
|
stateid_t *stateid, char typemask,
|
2012-11-14 19:22:07 +04:00
|
|
|
struct nfs4_ol_stateid **stpp,
|
|
|
|
struct nfsd_net *nn)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2008-01-27 03:08:12 +03:00
|
|
|
__be32 status;
|
2011-09-24 01:01:19 +04:00
|
|
|
struct nfs4_stid *s;
|
2014-06-30 19:48:34 +04:00
|
|
|
struct nfs4_ol_stateid *stp = NULL;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2020-04-05 18:42:29 +03:00
|
|
|
trace_nfsd_preprocess(seqid, stateid);
|
2005-07-08 04:59:26 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
*stpp = NULL;
|
2014-06-30 19:48:43 +04:00
|
|
|
status = nfsd4_lookup_stateid(cstate, stateid, typemask, &s, nn);
|
2011-09-06 23:19:46 +04:00
|
|
|
if (status)
|
|
|
|
return status;
|
2014-06-30 19:48:34 +04:00
|
|
|
stp = openlockstateid(s);
|
2014-07-30 05:34:27 +04:00
|
|
|
nfsd4_cstate_assign_replay(cstate, stp->st_stateowner);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2014-06-30 19:48:34 +04:00
|
|
|
status = nfs4_seqid_op_checks(cstate, stateid, seqid, stp);
|
2014-07-30 05:34:24 +04:00
|
|
|
if (!status)
|
2014-06-30 19:48:34 +04:00
|
|
|
*stpp = stp;
|
2014-07-30 05:34:24 +04:00
|
|
|
else
|
|
|
|
nfs4_put_stid(&stp->st_stid);
|
2014-06-30 19:48:34 +04:00
|
|
|
return status;
|
2011-09-06 23:19:46 +04:00
|
|
|
}
|
2007-11-27 01:06:39 +03:00
|
|
|
|
2012-11-14 19:22:07 +04:00
|
|
|
static __be32 nfs4_preprocess_confirmed_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
|
|
|
|
stateid_t *stateid, struct nfs4_ol_stateid **stpp, struct nfsd_net *nn)
|
2011-09-06 23:19:46 +04:00
|
|
|
{
|
|
|
|
__be32 status;
|
|
|
|
struct nfs4_openowner *oo;
|
2014-07-30 05:34:23 +04:00
|
|
|
struct nfs4_ol_stateid *stp;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-09-06 23:19:46 +04:00
|
|
|
status = nfs4_preprocess_seqid_op(cstate, seqid, stateid,
|
2014-07-30 05:34:23 +04:00
|
|
|
NFS4_OPEN_STID, &stp, nn);
|
2011-09-02 17:03:37 +04:00
|
|
|
if (status)
|
|
|
|
return status;
|
2014-07-30 05:34:23 +04:00
|
|
|
oo = openowner(stp->st_stateowner);
|
|
|
|
if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) {
|
2016-06-15 06:28:04 +03:00
|
|
|
mutex_unlock(&stp->st_mutex);
|
2014-07-30 05:34:23 +04:00
|
|
|
nfs4_put_stid(&stp->st_stid);
|
2005-07-08 04:59:26 +04:00
|
|
|
return nfserr_bad_stateid;
|
2014-07-30 05:34:23 +04:00
|
|
|
}
|
|
|
|
*stpp = stp;
|
2005-07-08 04:59:26 +04:00
|
|
|
return nfs_ok;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32
|
2006-12-13 11:35:27 +03:00
|
|
|
nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2017-05-08 21:58:35 +03:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_open_confirm *oc = &u->open_confirm;
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32 status;
|
2011-07-31 07:33:59 +04:00
|
|
|
struct nfs4_openowner *oo;
|
2011-09-08 00:06:42 +04:00
|
|
|
struct nfs4_ol_stateid *stp;
|
2012-11-14 19:22:07 +04:00
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-09-16 18:57:01 +04:00
|
|
|
dprintk("NFSD: nfsd4_open_confirm on file %pd\n",
|
|
|
|
cstate->current_fh.fh_dentry);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2006-12-13 11:35:27 +03:00
|
|
|
status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
|
2006-06-30 12:56:13 +04:00
|
|
|
if (status)
|
|
|
|
return status;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-08-24 20:45:03 +04:00
|
|
|
status = nfs4_preprocess_seqid_op(cstate,
|
2006-12-13 11:35:27 +03:00
|
|
|
oc->oc_seqid, &oc->oc_req_stateid,
|
2012-11-14 19:22:07 +04:00
|
|
|
NFS4_OPEN_STID, &stp, nn);
|
2011-08-24 20:45:03 +04:00
|
|
|
if (status)
|
2011-09-02 20:19:43 +04:00
|
|
|
goto out;
|
2011-07-31 07:33:59 +04:00
|
|
|
oo = openowner(stp->st_stateowner);
|
2011-09-02 20:19:43 +04:00
|
|
|
status = nfserr_bad_stateid;
|
2015-09-17 14:47:08 +03:00
|
|
|
if (oo->oo_flags & NFS4_OO_CONFIRMED) {
|
2016-06-15 06:28:04 +03:00
|
|
|
mutex_unlock(&stp->st_mutex);
|
2014-07-30 05:34:21 +04:00
|
|
|
goto put_stateid;
|
2015-09-17 14:47:08 +03:00
|
|
|
}
|
2011-09-12 20:24:13 +04:00
|
|
|
oo->oo_flags |= NFS4_OO_CONFIRMED;
|
2015-10-01 16:05:50 +03:00
|
|
|
nfs4_inc_and_copy_stateid(&oc->oc_resp_stateid, &stp->st_stid);
|
2016-06-15 06:28:04 +03:00
|
|
|
mutex_unlock(&stp->st_mutex);
|
2020-04-05 18:42:29 +03:00
|
|
|
trace_nfsd_open_confirm(oc->oc_seqid, &stp->st_stid.sc_stateid);
|
2012-03-22 00:42:43 +04:00
|
|
|
nfsd4_client_record_create(oo->oo_owner.so_client);
|
2011-09-02 20:19:43 +04:00
|
|
|
status = nfs_ok;
|
2014-07-30 05:34:21 +04:00
|
|
|
put_stateid:
|
|
|
|
nfs4_put_stid(&stp->st_stid);
|
2005-04-17 02:20:36 +04:00
|
|
|
out:
|
2013-04-02 00:37:12 +04:00
|
|
|
nfsd4_bump_seqid(cstate, status);
|
2005-04-17 02:20:36 +04:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2011-09-28 19:37:56 +04:00
|
|
|
static inline void nfs4_stateid_downgrade_bit(struct nfs4_ol_stateid *stp, u32 access)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2012-05-11 17:45:13 +04:00
|
|
|
if (!test_access(access, stp))
|
2011-09-28 19:37:56 +04:00
|
|
|
return;
|
2014-07-30 05:34:08 +04:00
|
|
|
nfs4_file_put_access(stp->st_stid.sc_file, access);
|
2012-05-11 17:45:13 +04:00
|
|
|
clear_access(access, stp);
|
2011-09-28 19:37:56 +04:00
|
|
|
}
|
2011-06-29 16:23:50 +04:00
|
|
|
|
2011-09-28 19:37:56 +04:00
|
|
|
static inline void nfs4_stateid_downgrade(struct nfs4_ol_stateid *stp, u32 to_access)
|
|
|
|
{
|
|
|
|
switch (to_access) {
|
|
|
|
case NFS4_SHARE_ACCESS_READ:
|
|
|
|
nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_WRITE);
|
|
|
|
nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
|
|
|
|
break;
|
|
|
|
case NFS4_SHARE_ACCESS_WRITE:
|
|
|
|
nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_READ);
|
|
|
|
nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
|
|
|
|
break;
|
|
|
|
case NFS4_SHARE_ACCESS_BOTH:
|
|
|
|
break;
|
|
|
|
default:
|
2012-11-25 23:48:10 +04:00
|
|
|
WARN_ON_ONCE(1);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32
|
2006-12-13 11:35:27 +03:00
|
|
|
nfsd4_open_downgrade(struct svc_rqst *rqstp,
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_open_downgrade *od = &u->open_downgrade;
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32 status;
|
2011-09-08 00:06:42 +04:00
|
|
|
struct nfs4_ol_stateid *stp;
|
2012-11-14 19:22:07 +04:00
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-09-16 18:57:01 +04:00
|
|
|
dprintk("NFSD: nfsd4_open_downgrade on file %pd\n",
|
|
|
|
cstate->current_fh.fh_dentry);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-10-11 01:34:31 +04:00
|
|
|
/* We don't yet support WANT bits: */
|
2012-02-16 22:57:09 +04:00
|
|
|
if (od->od_deleg_want)
|
|
|
|
dprintk("NFSD: %s: od_deleg_want=0x%x ignored\n", __func__,
|
|
|
|
od->od_deleg_want);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-09-06 23:19:46 +04:00
|
|
|
status = nfs4_preprocess_confirmed_seqid_op(cstate, od->od_seqid,
|
2012-11-14 19:22:07 +04:00
|
|
|
&od->od_stateid, &stp, nn);
|
2011-08-24 20:45:03 +04:00
|
|
|
if (status)
|
2005-04-17 02:20:36 +04:00
|
|
|
goto out;
|
|
|
|
status = nfserr_inval;
|
2012-05-11 17:45:13 +04:00
|
|
|
if (!test_access(od->od_share_access, stp)) {
|
2014-07-10 22:07:30 +04:00
|
|
|
dprintk("NFSD: access not a subset of current bitmap: 0x%hhx, input access=%08x\n",
|
2005-04-17 02:20:36 +04:00
|
|
|
stp->st_access_bmap, od->od_share_access);
|
2014-07-30 05:34:22 +04:00
|
|
|
goto put_stateid;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2012-05-11 17:45:14 +04:00
|
|
|
if (!test_deny(od->od_share_deny, stp)) {
|
2014-07-10 22:07:30 +04:00
|
|
|
dprintk("NFSD: deny not a subset of current bitmap: 0x%hhx, input deny=%08x\n",
|
2005-04-17 02:20:36 +04:00
|
|
|
stp->st_deny_bmap, od->od_share_deny);
|
2014-07-30 05:34:22 +04:00
|
|
|
goto put_stateid;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2011-09-28 19:37:56 +04:00
|
|
|
nfs4_stateid_downgrade(stp, od->od_share_access);
|
2012-05-11 17:45:14 +04:00
|
|
|
reset_union_bmap_deny(od->od_share_deny, stp);
|
2015-10-01 16:05:50 +03:00
|
|
|
nfs4_inc_and_copy_stateid(&od->od_stateid, &stp->st_stid);
|
2005-04-17 02:20:36 +04:00
|
|
|
status = nfs_ok;
|
2014-07-30 05:34:22 +04:00
|
|
|
put_stateid:
|
2016-06-15 06:28:04 +03:00
|
|
|
mutex_unlock(&stp->st_mutex);
|
2014-07-30 05:34:22 +04:00
|
|
|
nfs4_put_stid(&stp->st_stid);
|
2005-04-17 02:20:36 +04:00
|
|
|
out:
|
2013-04-02 00:37:12 +04:00
|
|
|
nfsd4_bump_seqid(cstate, status);
|
2005-04-17 02:20:36 +04:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2011-09-17 04:12:38 +04:00
|
|
|
static void nfsd4_close_open_stateid(struct nfs4_ol_stateid *s)
|
|
|
|
{
|
2014-06-30 19:48:37 +04:00
|
|
|
struct nfs4_client *clp = s->st_stid.sc_client;
|
2015-08-24 19:41:47 +03:00
|
|
|
bool unhashed;
|
2014-07-30 05:34:42 +04:00
|
|
|
LIST_HEAD(reaplist);
|
2014-06-30 19:48:37 +04:00
|
|
|
|
2014-07-30 05:34:41 +04:00
|
|
|
spin_lock(&clp->cl_lock);
|
2015-08-24 19:41:47 +03:00
|
|
|
unhashed = unhash_open_stateid(s, &reaplist);
|
2014-06-30 19:48:37 +04:00
|
|
|
|
2014-07-30 05:34:42 +04:00
|
|
|
if (clp->cl_minorversion) {
|
2015-08-24 19:41:47 +03:00
|
|
|
if (unhashed)
|
|
|
|
put_ol_stateid_locked(s, &reaplist);
|
2014-07-30 05:34:42 +04:00
|
|
|
spin_unlock(&clp->cl_lock);
|
|
|
|
free_ol_stateid_reaplist(&reaplist);
|
|
|
|
} else {
|
|
|
|
spin_unlock(&clp->cl_lock);
|
|
|
|
free_ol_stateid_reaplist(&reaplist);
|
2015-08-24 19:41:47 +03:00
|
|
|
if (unhashed)
|
|
|
|
move_to_close_lru(s, clp->net);
|
2014-07-30 05:34:42 +04:00
|
|
|
}
|
2011-09-17 01:42:48 +04:00
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* nfs4_unlock_state() called after encode
|
|
|
|
*/
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32
|
2006-12-13 11:35:27 +03:00
|
|
|
nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2017-05-08 21:58:35 +03:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_close *close = &u->close;
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32 status;
|
2011-09-08 00:06:42 +04:00
|
|
|
struct nfs4_ol_stateid *stp;
|
2012-11-14 19:22:07 +04:00
|
|
|
struct net *net = SVC_NET(rqstp);
|
|
|
|
struct nfsd_net *nn = net_generic(net, nfsd_net_id);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2013-09-16 18:57:01 +04:00
|
|
|
dprintk("NFSD: nfsd4_close on file %pd\n",
|
|
|
|
cstate->current_fh.fh_dentry);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-09-17 04:12:38 +04:00
|
|
|
status = nfs4_preprocess_seqid_op(cstate, close->cl_seqid,
|
|
|
|
&close->cl_stateid,
|
|
|
|
NFS4_OPEN_STID|NFS4_CLOSED_STID,
|
2012-11-14 19:22:07 +04:00
|
|
|
&stp, nn);
|
2013-04-02 00:37:12 +04:00
|
|
|
nfsd4_bump_seqid(cstate, status);
|
2011-08-24 20:45:03 +04:00
|
|
|
if (status)
|
2005-04-17 02:20:36 +04:00
|
|
|
goto out;
|
2017-11-03 15:00:10 +03:00
|
|
|
|
|
|
|
stp->st_stid.sc_type = NFS4_CLOSED_STID;
|
2018-02-15 23:16:18 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Technically we don't _really_ have to increment or copy it, since
|
|
|
|
* it should just be gone after this operation and we clobber the
|
|
|
|
* copied value below, but we continue to do so here just to ensure
|
|
|
|
* that racing ops see that there was a state change.
|
|
|
|
*/
|
2015-10-01 16:05:50 +03:00
|
|
|
nfs4_inc_and_copy_stateid(&close->cl_stateid, &stp->st_stid);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-09-17 04:12:38 +04:00
|
|
|
nfsd4_close_open_stateid(stp);
|
2017-11-03 15:00:10 +03:00
|
|
|
mutex_unlock(&stp->st_mutex);
|
2014-07-30 05:34:20 +04:00
|
|
|
|
2018-02-15 23:16:18 +03:00
|
|
|
/* v4.1+ suggests that we send a special stateid in here, since the
|
|
|
|
* clients should just ignore this anyway. Since this is not useful
|
|
|
|
* for v4.0 clients either, we set it to the special close_stateid
|
|
|
|
* universally.
|
|
|
|
*
|
|
|
|
* See RFC5661 section 18.2.4, and RFC7530 section 16.2.5
|
|
|
|
*/
|
|
|
|
memcpy(&close->cl_stateid, &close_stateid, sizeof(close->cl_stateid));
|
2017-11-03 15:00:12 +03:00
|
|
|
|
2014-07-30 05:34:20 +04:00
|
|
|
/* put reference from nfs4_preprocess_seqid_op */
|
|
|
|
nfs4_put_stid(&stp->st_stid);
|
2005-04-17 02:20:36 +04:00
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32
|
2006-12-13 11:35:27 +03:00
|
|
|
nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2017-05-08 21:58:35 +03:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_delegreturn *dr = &u->delegreturn;
|
2009-02-22 00:29:14 +03:00
|
|
|
struct nfs4_delegation *dp;
|
|
|
|
stateid_t *stateid = &dr->dr_stateid;
|
2011-09-24 01:01:19 +04:00
|
|
|
struct nfs4_stid *s;
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32 status;
|
2012-11-14 19:22:07 +04:00
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2006-12-13 11:35:27 +03:00
|
|
|
if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
|
2009-02-22 00:29:14 +03:00
|
|
|
return status;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2014-06-30 19:48:43 +04:00
|
|
|
status = nfsd4_lookup_stateid(cstate, stateid, NFS4_DELEG_STID, &s, nn);
|
2011-09-24 01:01:19 +04:00
|
|
|
if (status)
|
2009-02-22 00:29:14 +03:00
|
|
|
goto out;
|
2011-09-24 01:01:19 +04:00
|
|
|
dp = delegstateid(s);
|
2017-11-03 15:00:16 +03:00
|
|
|
status = nfsd4_stid_check_stateid_generation(stateid, &dp->dl_stid, nfsd4_has_session(cstate));
|
2009-02-22 00:29:14 +03:00
|
|
|
if (status)
|
2014-07-30 05:34:24 +04:00
|
|
|
goto put_stateid;
|
2009-02-22 00:29:14 +03:00
|
|
|
|
2013-04-10 01:02:51 +04:00
|
|
|
destroy_delegation(dp);
|
2014-07-30 05:34:24 +04:00
|
|
|
put_stateid:
|
|
|
|
nfs4_put_stid(&dp->dl_stid);
|
2005-04-17 02:20:36 +04:00
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2008-12-15 20:42:03 +03:00
|
|
|
/* last octet in a range */
|
|
|
|
static inline u64
|
|
|
|
last_byte_offset(u64 start, u64 len)
|
|
|
|
{
|
|
|
|
u64 end;
|
|
|
|
|
2012-11-25 23:48:10 +04:00
|
|
|
WARN_ON_ONCE(!len);
|
2008-12-15 20:42:03 +03:00
|
|
|
end = start + len;
|
|
|
|
return end > start ? end - 1: NFS4_MAX_UINT64;
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
|
|
|
|
* we can't properly handle lock requests that go beyond the (2^63 - 1)-th
|
|
|
|
* byte, because of sign extension problems. Since NFSv4 calls for 64-bit
|
|
|
|
* locking, this prevents us from being completely protocol-compliant. The
|
|
|
|
* real solution to this problem is to start using unsigned file offsets in
|
|
|
|
* the VFS, but this is a very deep change!
|
|
|
|
*/
|
|
|
|
static inline void
|
|
|
|
nfs4_transform_lock_offset(struct file_lock *lock)
|
|
|
|
{
|
|
|
|
if (lock->fl_start < 0)
|
|
|
|
lock->fl_start = OFFSET_MAX;
|
|
|
|
if (lock->fl_end < 0)
|
|
|
|
lock->fl_end = OFFSET_MAX;
|
|
|
|
}
|
|
|
|
|
2015-04-03 16:04:04 +03:00
|
|
|
static fl_owner_t
|
|
|
|
nfsd4_fl_get_owner(fl_owner_t owner)
|
2014-08-22 18:18:44 +04:00
|
|
|
{
|
2015-04-03 16:04:04 +03:00
|
|
|
struct nfs4_lockowner *lo = (struct nfs4_lockowner *)owner;
|
|
|
|
|
|
|
|
nfs4_get_stateowner(&lo->lo_owner);
|
|
|
|
return owner;
|
2014-08-22 18:18:44 +04:00
|
|
|
}
|
|
|
|
|
2015-04-03 16:04:04 +03:00
|
|
|
static void
|
|
|
|
nfsd4_fl_put_owner(fl_owner_t owner)
|
2014-08-22 18:18:44 +04:00
|
|
|
{
|
2015-04-03 16:04:04 +03:00
|
|
|
struct nfs4_lockowner *lo = (struct nfs4_lockowner *)owner;
|
2014-08-22 18:18:44 +04:00
|
|
|
|
2015-04-03 16:04:04 +03:00
|
|
|
if (lo)
|
2014-08-22 18:18:44 +04:00
|
|
|
nfs4_put_stateowner(&lo->lo_owner);
|
|
|
|
}
|
|
|
|
|
2016-09-16 23:28:24 +03:00
|
|
|
static void
|
|
|
|
nfsd4_lm_notify(struct file_lock *fl)
|
|
|
|
{
|
|
|
|
struct nfs4_lockowner *lo = (struct nfs4_lockowner *)fl->fl_owner;
|
|
|
|
struct net *net = lo->lo_owner.so_client->net;
|
|
|
|
struct nfsd_net *nn = net_generic(net, nfsd_net_id);
|
|
|
|
struct nfsd4_blocked_lock *nbl = container_of(fl,
|
|
|
|
struct nfsd4_blocked_lock, nbl_lock);
|
|
|
|
bool queue = false;
|
|
|
|
|
2016-09-16 23:28:25 +03:00
|
|
|
/* An empty list means that something else is going to be using it */
|
2016-10-20 16:34:31 +03:00
|
|
|
spin_lock(&nn->blocked_locks_lock);
|
2016-09-16 23:28:24 +03:00
|
|
|
if (!list_empty(&nbl->nbl_list)) {
|
|
|
|
list_del_init(&nbl->nbl_list);
|
2016-09-16 23:28:25 +03:00
|
|
|
list_del_init(&nbl->nbl_lru);
|
2016-09-16 23:28:24 +03:00
|
|
|
queue = true;
|
|
|
|
}
|
2016-10-20 16:34:31 +03:00
|
|
|
spin_unlock(&nn->blocked_locks_lock);
|
2016-09-16 23:28:24 +03:00
|
|
|
|
2021-05-14 22:57:08 +03:00
|
|
|
if (queue) {
|
|
|
|
trace_nfsd_cb_notify_lock(lo, nbl);
|
2016-09-16 23:28:24 +03:00
|
|
|
nfsd4_run_cb(&nbl->nbl_cb);
|
2021-05-14 22:57:08 +03:00
|
|
|
}
|
2016-09-16 23:28:24 +03:00
|
|
|
}
|
|
|
|
|
2009-09-22 04:01:12 +04:00
|
|
|
static const struct lock_manager_operations nfsd_posix_mng_ops = {
|
2016-09-16 23:28:24 +03:00
|
|
|
.lm_notify = nfsd4_lm_notify,
|
2014-08-22 18:18:44 +04:00
|
|
|
.lm_get_owner = nfsd4_fl_get_owner,
|
|
|
|
.lm_put_owner = nfsd4_fl_put_owner,
|
2006-04-11 09:55:22 +04:00
|
|
|
};
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
static inline void
|
|
|
|
nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
|
|
|
|
{
|
2011-07-31 07:33:59 +04:00
|
|
|
struct nfs4_lockowner *lo;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2006-04-11 09:55:22 +04:00
|
|
|
if (fl->fl_lmops == &nfsd_posix_mng_ops) {
|
2011-07-31 07:33:59 +04:00
|
|
|
lo = (struct nfs4_lockowner *) fl->fl_owner;
|
2019-06-19 21:30:33 +03:00
|
|
|
xdr_netobj_dup(&deny->ld_owner, &lo->lo_owner.so_owner,
|
|
|
|
GFP_KERNEL);
|
2011-08-31 06:15:47 +04:00
|
|
|
if (!deny->ld_owner.data)
|
|
|
|
/* We just don't care that much */
|
|
|
|
goto nevermind;
|
2011-07-31 07:33:59 +04:00
|
|
|
deny->ld_clientid = lo->lo_owner.so_client->cl_clientid;
|
2006-04-11 09:55:22 +04:00
|
|
|
} else {
|
2011-08-31 06:15:47 +04:00
|
|
|
nevermind:
|
|
|
|
deny->ld_owner.len = 0;
|
|
|
|
deny->ld_owner.data = NULL;
|
2006-04-11 09:55:22 +04:00
|
|
|
deny->ld_clientid.cl_boot = 0;
|
|
|
|
deny->ld_clientid.cl_id = 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
deny->ld_start = fl->fl_start;
|
2008-12-15 20:42:03 +03:00
|
|
|
deny->ld_length = NFS4_MAX_UINT64;
|
|
|
|
if (fl->fl_end != NFS4_MAX_UINT64)
|
2005-04-17 02:20:36 +04:00
|
|
|
deny->ld_length = fl->fl_end - fl->fl_start + 1;
|
|
|
|
deny->ld_type = NFS4_READ_LT;
|
|
|
|
if (fl->fl_type != F_RDLCK)
|
|
|
|
deny->ld_type = NFS4_WRITE_LT;
|
|
|
|
}
|
|
|
|
|
2011-07-31 07:33:59 +04:00
|
|
|
static struct nfs4_lockowner *
|
2015-07-13 12:35:37 +03:00
|
|
|
find_lockowner_str_locked(struct nfs4_client *clp, struct xdr_netobj *owner)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2014-07-30 05:34:36 +04:00
|
|
|
unsigned int strhashval = ownerstr_hashval(owner);
|
2014-06-30 19:48:40 +04:00
|
|
|
struct nfs4_stateowner *so;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2014-07-30 16:27:10 +04:00
|
|
|
lockdep_assert_held(&clp->cl_lock);
|
|
|
|
|
2014-07-30 05:34:36 +04:00
|
|
|
list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[strhashval],
|
|
|
|
so_strhash) {
|
2014-06-30 19:48:40 +04:00
|
|
|
if (so->so_is_open_owner)
|
|
|
|
continue;
|
2014-08-22 18:18:43 +04:00
|
|
|
if (same_owner_str(so, owner))
|
|
|
|
return lockowner(nfs4_get_stateowner(so));
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:35 +04:00
|
|
|
static struct nfs4_lockowner *
|
2015-07-13 12:35:37 +03:00
|
|
|
find_lockowner_str(struct nfs4_client *clp, struct xdr_netobj *owner)
|
2014-07-30 05:34:35 +04:00
|
|
|
{
|
|
|
|
struct nfs4_lockowner *lo;
|
|
|
|
|
2014-07-30 05:34:36 +04:00
|
|
|
spin_lock(&clp->cl_lock);
|
2015-07-13 12:35:37 +03:00
|
|
|
lo = find_lockowner_str_locked(clp, owner);
|
2014-07-30 05:34:36 +04:00
|
|
|
spin_unlock(&clp->cl_lock);
|
2014-07-30 05:34:35 +04:00
|
|
|
return lo;
|
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:29 +04:00
|
|
|
static void nfs4_unhash_lockowner(struct nfs4_stateowner *sop)
|
|
|
|
{
|
2014-07-30 05:34:35 +04:00
|
|
|
unhash_lockowner_locked(lockowner(sop));
|
2014-07-30 05:34:29 +04:00
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:26 +04:00
|
|
|
static void nfs4_free_lockowner(struct nfs4_stateowner *sop)
|
|
|
|
{
|
|
|
|
struct nfs4_lockowner *lo = lockowner(sop);
|
|
|
|
|
|
|
|
kmem_cache_free(lockowner_slab, lo);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct nfs4_stateowner_operations lockowner_ops = {
|
2014-07-30 05:34:29 +04:00
|
|
|
.so_unhash = nfs4_unhash_lockowner,
|
|
|
|
.so_free = nfs4_free_lockowner,
|
2014-07-30 05:34:26 +04:00
|
|
|
};
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* Alloc a lock owner structure.
|
|
|
|
* Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has
|
2011-03-31 05:57:33 +04:00
|
|
|
* occurred.
|
2005-04-17 02:20:36 +04:00
|
|
|
*
|
2011-11-08 02:23:30 +04:00
|
|
|
* strhashval = ownerstr_hashval
|
2005-04-17 02:20:36 +04:00
|
|
|
*/
|
2011-07-31 07:33:59 +04:00
|
|
|
static struct nfs4_lockowner *
|
2014-07-30 05:34:35 +04:00
|
|
|
alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp,
|
|
|
|
struct nfs4_ol_stateid *open_stp,
|
|
|
|
struct nfsd4_lock *lock)
|
|
|
|
{
|
|
|
|
struct nfs4_lockowner *lo, *ret;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-07-31 07:33:59 +04:00
|
|
|
lo = alloc_stateowner(lockowner_slab, &lock->lk_new_owner, clp);
|
|
|
|
if (!lo)
|
2005-04-17 02:20:36 +04:00
|
|
|
return NULL;
|
2016-09-16 23:28:24 +03:00
|
|
|
INIT_LIST_HEAD(&lo->lo_blocked);
|
2011-07-31 07:33:59 +04:00
|
|
|
INIT_LIST_HEAD(&lo->lo_owner.so_stateids);
|
|
|
|
lo->lo_owner.so_is_open_owner = 0;
|
2014-07-30 05:34:28 +04:00
|
|
|
lo->lo_owner.so_seqid = lock->lk_new_lock_seqid;
|
2014-07-30 05:34:26 +04:00
|
|
|
lo->lo_owner.so_ops = &lockowner_ops;
|
2014-07-30 05:34:36 +04:00
|
|
|
spin_lock(&clp->cl_lock);
|
2015-07-13 12:35:37 +03:00
|
|
|
ret = find_lockowner_str_locked(clp, &lock->lk_new_owner);
|
2014-07-30 05:34:35 +04:00
|
|
|
if (ret == NULL) {
|
|
|
|
list_add(&lo->lo_owner.so_strhash,
|
2014-07-30 05:34:36 +04:00
|
|
|
&clp->cl_ownerstr_hashtbl[strhashval]);
|
2014-07-30 05:34:35 +04:00
|
|
|
ret = lo;
|
|
|
|
} else
|
2015-07-16 07:05:07 +03:00
|
|
|
nfs4_free_stateowner(&lo->lo_owner);
|
|
|
|
|
2014-07-30 05:34:36 +04:00
|
|
|
spin_unlock(&clp->cl_lock);
|
2015-03-23 18:02:30 +03:00
|
|
|
return ret;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2017-11-03 15:00:14 +03:00
|
|
|
static struct nfs4_ol_stateid *
|
2020-03-02 02:21:38 +03:00
|
|
|
find_lock_stateid(const struct nfs4_lockowner *lo,
|
|
|
|
const struct nfs4_ol_stateid *ost)
|
2017-11-03 15:00:14 +03:00
|
|
|
{
|
|
|
|
struct nfs4_ol_stateid *lst;
|
|
|
|
|
2020-03-02 02:21:38 +03:00
|
|
|
lockdep_assert_held(&ost->st_stid.sc_client->cl_lock);
|
2017-11-03 15:00:14 +03:00
|
|
|
|
2020-03-02 02:21:38 +03:00
|
|
|
/* If ost is not hashed, ost->st_locks will not be valid */
|
|
|
|
if (!nfs4_ol_stateid_unhashed(ost))
|
|
|
|
list_for_each_entry(lst, &ost->st_locks, st_locks) {
|
|
|
|
if (lst->st_stateowner == &lo->lo_owner) {
|
|
|
|
refcount_inc(&lst->st_stid.sc_count);
|
|
|
|
return lst;
|
|
|
|
}
|
2017-11-03 15:00:14 +03:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2017-11-03 15:00:14 +03:00
|
|
|
static struct nfs4_ol_stateid *
|
2014-07-30 05:34:13 +04:00
|
|
|
init_lock_stateid(struct nfs4_ol_stateid *stp, struct nfs4_lockowner *lo,
|
|
|
|
struct nfs4_file *fp, struct inode *inode,
|
|
|
|
struct nfs4_ol_stateid *open_stp)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2011-09-15 23:02:41 +04:00
|
|
|
struct nfs4_client *clp = lo->lo_owner.so_client;
|
2017-11-03 15:00:14 +03:00
|
|
|
struct nfs4_ol_stateid *retstp;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2017-11-03 15:00:14 +03:00
|
|
|
mutex_init(&stp->st_mutex);
|
2017-11-09 01:29:51 +03:00
|
|
|
mutex_lock_nested(&stp->st_mutex, OPEN_STATEID_MUTEX);
|
2017-11-03 15:00:14 +03:00
|
|
|
retry:
|
|
|
|
spin_lock(&clp->cl_lock);
|
2020-03-02 02:21:38 +03:00
|
|
|
if (nfs4_ol_stateid_unhashed(open_stp))
|
|
|
|
goto out_close;
|
|
|
|
retstp = find_lock_stateid(lo, open_stp);
|
2017-11-03 15:00:14 +03:00
|
|
|
if (retstp)
|
2020-03-02 02:21:38 +03:00
|
|
|
goto out_found;
|
2017-10-20 12:53:28 +03:00
|
|
|
refcount_inc(&stp->st_stid.sc_count);
|
2013-02-03 21:23:01 +04:00
|
|
|
stp->st_stid.sc_type = NFS4_LOCK_STID;
|
2014-08-22 18:18:43 +04:00
|
|
|
stp->st_stateowner = nfs4_get_stateowner(&lo->lo_owner);
|
2005-06-24 09:03:10 +04:00
|
|
|
get_nfs4_file(fp);
|
2014-07-30 05:34:08 +04:00
|
|
|
stp->st_stid.sc_file = fp;
|
2011-03-03 02:01:35 +03:00
|
|
|
stp->st_access_bmap = 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
stp->st_deny_bmap = open_stp->st_deny_bmap;
|
2005-07-08 04:59:27 +04:00
|
|
|
stp->st_openstp = open_stp;
|
2020-03-02 02:21:38 +03:00
|
|
|
spin_lock(&fp->fi_lock);
|
2014-06-30 19:48:38 +04:00
|
|
|
list_add(&stp->st_locks, &open_stp->st_locks);
|
2014-07-30 05:34:12 +04:00
|
|
|
list_add(&stp->st_perstateowner, &lo->lo_owner.so_stateids);
|
2014-07-10 22:07:25 +04:00
|
|
|
list_add(&stp->st_perfile, &fp->fi_stateids);
|
|
|
|
spin_unlock(&fp->fi_lock);
|
2017-11-03 15:00:14 +03:00
|
|
|
spin_unlock(&clp->cl_lock);
|
|
|
|
return stp;
|
2020-03-02 02:21:38 +03:00
|
|
|
out_found:
|
|
|
|
spin_unlock(&clp->cl_lock);
|
|
|
|
if (nfsd4_lock_ol_stateid(retstp) != nfs_ok) {
|
|
|
|
nfs4_put_stid(&retstp->st_stid);
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
/* To keep mutex tracking happy */
|
|
|
|
mutex_unlock(&stp->st_mutex);
|
|
|
|
return retstp;
|
|
|
|
out_close:
|
|
|
|
spin_unlock(&clp->cl_lock);
|
|
|
|
mutex_unlock(&stp->st_mutex);
|
|
|
|
return NULL;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:13 +04:00
|
|
|
static struct nfs4_ol_stateid *
|
|
|
|
find_or_create_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fi,
|
|
|
|
struct inode *inode, struct nfs4_ol_stateid *ost,
|
|
|
|
bool *new)
|
|
|
|
{
|
|
|
|
struct nfs4_stid *ns = NULL;
|
|
|
|
struct nfs4_ol_stateid *lst;
|
|
|
|
struct nfs4_openowner *oo = openowner(ost->st_stateowner);
|
|
|
|
struct nfs4_client *clp = oo->oo_owner.so_client;
|
|
|
|
|
2017-11-03 15:00:14 +03:00
|
|
|
*new = false;
|
2014-07-30 05:34:13 +04:00
|
|
|
spin_lock(&clp->cl_lock);
|
2020-03-02 02:21:38 +03:00
|
|
|
lst = find_lock_stateid(lo, ost);
|
2014-07-30 05:34:13 +04:00
|
|
|
spin_unlock(&clp->cl_lock);
|
2017-11-03 15:00:14 +03:00
|
|
|
if (lst != NULL) {
|
|
|
|
if (nfsd4_lock_ol_stateid(lst) == nfs_ok)
|
|
|
|
goto out;
|
|
|
|
nfs4_put_stid(&lst->st_stid);
|
|
|
|
}
|
|
|
|
ns = nfs4_alloc_stid(clp, stateid_slab, nfs4_free_lock_stateid);
|
|
|
|
if (ns == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
lst = init_lock_stateid(openlockstateid(ns), lo, fi, inode, ost);
|
|
|
|
if (lst == openlockstateid(ns))
|
|
|
|
*new = true;
|
|
|
|
else
|
2014-07-30 05:34:13 +04:00
|
|
|
nfs4_put_stid(ns);
|
2017-11-03 15:00:14 +03:00
|
|
|
out:
|
2014-07-30 05:34:13 +04:00
|
|
|
return lst;
|
|
|
|
}
|
2014-06-30 19:48:39 +04:00
|
|
|
|
2005-06-24 09:04:03 +04:00
|
|
|
static int
|
2005-04-17 02:20:36 +04:00
|
|
|
check_lock_length(u64 offset, u64 length)
|
|
|
|
{
|
2015-07-13 12:34:19 +03:00
|
|
|
return ((length == 0) || ((length != NFS4_MAX_UINT64) &&
|
|
|
|
(length > ~offset)));
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2011-09-08 00:06:42 +04:00
|
|
|
static void get_lock_access(struct nfs4_ol_stateid *lock_stp, u32 access)
|
2011-03-03 02:01:35 +03:00
|
|
|
{
|
2014-07-30 05:34:08 +04:00
|
|
|
struct nfs4_file *fp = lock_stp->st_stid.sc_file;
|
2011-03-03 02:01:35 +03:00
|
|
|
|
2014-07-10 22:07:33 +04:00
|
|
|
lockdep_assert_held(&fp->fi_lock);
|
|
|
|
|
2012-05-11 17:45:13 +04:00
|
|
|
if (test_access(access, lock_stp))
|
2011-03-03 02:01:35 +03:00
|
|
|
return;
|
2014-07-10 22:07:28 +04:00
|
|
|
__nfs4_file_get_access(fp, access);
|
2012-05-11 17:45:13 +04:00
|
|
|
set_access(access, lock_stp);
|
2011-03-03 02:01:35 +03:00
|
|
|
}
|
|
|
|
|
2014-07-30 05:34:13 +04:00
|
|
|
static __be32
|
|
|
|
lookup_or_create_lock_state(struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfs4_ol_stateid *ost,
|
|
|
|
struct nfsd4_lock *lock,
|
2016-08-11 17:37:39 +03:00
|
|
|
struct nfs4_ol_stateid **plst, bool *new)
|
2011-10-20 14:57:46 +04:00
|
|
|
{
|
2014-07-30 05:34:28 +04:00
|
|
|
__be32 status;
|
2014-07-30 05:34:08 +04:00
|
|
|
struct nfs4_file *fi = ost->st_stid.sc_file;
|
2011-10-20 14:57:46 +04:00
|
|
|
struct nfs4_openowner *oo = openowner(ost->st_stateowner);
|
|
|
|
struct nfs4_client *cl = oo->oo_owner.so_client;
|
2015-03-18 01:25:59 +03:00
|
|
|
struct inode *inode = d_inode(cstate->current_fh.fh_dentry);
|
2011-10-20 14:57:46 +04:00
|
|
|
struct nfs4_lockowner *lo;
|
2016-08-11 17:37:39 +03:00
|
|
|
struct nfs4_ol_stateid *lst;
|
2011-10-20 14:57:46 +04:00
|
|
|
unsigned int strhashval;
|
|
|
|
|
2015-07-13 12:35:37 +03:00
|
|
|
lo = find_lockowner_str(cl, &lock->lk_new_owner);
|
2014-06-30 19:48:39 +04:00
|
|
|
if (!lo) {
|
2015-07-13 12:35:10 +03:00
|
|
|
strhashval = ownerstr_hashval(&lock->lk_new_owner);
|
2014-06-30 19:48:39 +04:00
|
|
|
lo = alloc_init_lock_stateowner(strhashval, cl, ost, lock);
|
|
|
|
if (lo == NULL)
|
|
|
|
return nfserr_jukebox;
|
|
|
|
} else {
|
|
|
|
/* with an existing lockowner, seqids must be the same */
|
2014-07-30 05:34:28 +04:00
|
|
|
status = nfserr_bad_seqid;
|
2014-06-30 19:48:39 +04:00
|
|
|
if (!cstate->minorversion &&
|
|
|
|
lock->lk_new_lock_seqid != lo->lo_owner.so_seqid)
|
2014-07-30 05:34:28 +04:00
|
|
|
goto out;
|
2011-10-20 14:57:46 +04:00
|
|
|
}
|
2014-06-30 19:48:39 +04:00
|
|
|
|
2016-08-11 17:37:39 +03:00
|
|
|
lst = find_or_create_lock_stateid(lo, fi, inode, ost, new);
|
|
|
|
if (lst == NULL) {
|
2014-07-30 05:34:28 +04:00
|
|
|
status = nfserr_jukebox;
|
|
|
|
goto out;
|
2011-10-20 14:57:46 +04:00
|
|
|
}
|
2016-08-11 17:37:39 +03:00
|
|
|
|
2014-07-30 05:34:28 +04:00
|
|
|
status = nfs_ok;
|
2016-08-11 17:37:39 +03:00
|
|
|
*plst = lst;
|
2014-07-30 05:34:28 +04:00
|
|
|
out:
|
|
|
|
nfs4_put_stateowner(&lo->lo_owner);
|
|
|
|
return status;
|
2011-10-20 14:57:46 +04:00
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* LOCK operation
|
|
|
|
*/
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32
|
2006-12-13 11:35:27 +03:00
|
|
|
nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2017-05-08 21:58:35 +03:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_lock *lock = &u->lock;
|
2011-07-31 07:33:59 +04:00
|
|
|
struct nfs4_openowner *open_sop = NULL;
|
|
|
|
struct nfs4_lockowner *lock_sop = NULL;
|
2014-07-30 05:34:15 +04:00
|
|
|
struct nfs4_ol_stateid *lock_stp = NULL;
|
2014-07-30 05:34:22 +04:00
|
|
|
struct nfs4_ol_stateid *open_stp = NULL;
|
2014-07-10 22:07:33 +04:00
|
|
|
struct nfs4_file *fp;
|
2019-08-18 21:18:53 +03:00
|
|
|
struct nfsd_file *nf = NULL;
|
2016-09-16 23:28:24 +03:00
|
|
|
struct nfsd4_blocked_lock *nbl = NULL;
|
2012-08-21 16:03:32 +04:00
|
|
|
struct file_lock *file_lock = NULL;
|
|
|
|
struct file_lock *conflock = NULL;
|
2021-08-21 00:02:04 +03:00
|
|
|
struct super_block *sb;
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32 status = 0;
|
2011-08-22 21:13:31 +04:00
|
|
|
int lkflg;
|
2006-10-20 10:29:01 +04:00
|
|
|
int err;
|
2014-07-30 05:34:28 +04:00
|
|
|
bool new = false;
|
2016-09-16 23:28:24 +03:00
|
|
|
unsigned char fl_type;
|
|
|
|
unsigned int fl_flags = FL_POSIX;
|
2012-11-14 19:22:07 +04:00
|
|
|
struct net *net = SVC_NET(rqstp);
|
|
|
|
struct nfsd_net *nn = net_generic(net, nfsd_net_id);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
|
|
|
|
(long long) lock->lk_offset,
|
|
|
|
(long long) lock->lk_length);
|
|
|
|
|
|
|
|
if (check_lock_length(lock->lk_offset, lock->lk_length))
|
|
|
|
return nfserr_inval;
|
|
|
|
|
2006-12-13 11:35:27 +03:00
|
|
|
if ((status = fh_verify(rqstp, &cstate->current_fh,
|
2008-06-16 15:20:29 +04:00
|
|
|
S_IFREG, NFSD_MAY_LOCK))) {
|
2006-01-19 04:43:17 +03:00
|
|
|
dprintk("NFSD: nfsd4_lock: permission denied!\n");
|
|
|
|
return status;
|
|
|
|
}
|
2021-08-21 00:02:04 +03:00
|
|
|
sb = cstate->current_fh.fh_dentry->d_sb;
|
2006-01-19 04:43:17 +03:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
if (lock->lk_is_new) {
|
2011-11-05 01:08:10 +04:00
|
|
|
if (nfsd4_has_session(cstate))
|
|
|
|
/* See rfc 5661 18.10.3: given clientid is ignored: */
|
2015-07-13 12:35:10 +03:00
|
|
|
memcpy(&lock->lk_new_clientid,
|
2021-01-22 01:57:45 +03:00
|
|
|
&cstate->clp->cl_clientid,
|
2011-11-05 01:08:10 +04:00
|
|
|
sizeof(clientid_t));
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* validate and update open stateid and open seqid */
|
2011-09-06 23:19:46 +04:00
|
|
|
status = nfs4_preprocess_confirmed_seqid_op(cstate,
|
2005-04-17 02:20:36 +04:00
|
|
|
lock->lk_new_open_seqid,
|
|
|
|
&lock->lk_new_open_stateid,
|
2012-11-14 19:22:07 +04:00
|
|
|
&open_stp, nn);
|
2005-07-08 04:59:16 +04:00
|
|
|
if (status)
|
2005-04-17 02:20:36 +04:00
|
|
|
goto out;
|
2016-06-15 06:28:04 +03:00
|
|
|
mutex_unlock(&open_stp->st_mutex);
|
2011-07-31 07:33:59 +04:00
|
|
|
open_sop = openowner(open_stp->st_stateowner);
|
2011-08-22 21:13:31 +04:00
|
|
|
status = nfserr_bad_stateid;
|
2011-11-05 01:08:10 +04:00
|
|
|
if (!same_clid(&open_sop->oo_owner.so_client->cl_clientid,
|
2015-07-13 12:35:10 +03:00
|
|
|
&lock->lk_new_clientid))
|
2011-08-22 21:13:31 +04:00
|
|
|
goto out;
|
2011-10-20 14:57:46 +04:00
|
|
|
status = lookup_or_create_lock_state(cstate, open_stp, lock,
|
2014-07-30 05:34:28 +04:00
|
|
|
&lock_stp, &new);
|
2014-07-30 05:34:15 +04:00
|
|
|
} else {
|
2009-04-03 09:28:41 +04:00
|
|
|
status = nfs4_preprocess_seqid_op(cstate,
|
2011-07-31 07:33:59 +04:00
|
|
|
lock->lk_old_lock_seqid,
|
|
|
|
&lock->lk_old_lock_stateid,
|
2012-11-14 19:22:07 +04:00
|
|
|
NFS4_LOCK_STID, &lock_stp, nn);
|
2014-07-30 05:34:15 +04:00
|
|
|
}
|
2012-06-07 00:01:37 +04:00
|
|
|
if (status)
|
|
|
|
goto out;
|
2011-10-20 14:57:46 +04:00
|
|
|
lock_sop = lockowner(lock_stp->st_stateowner);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-08-22 21:13:31 +04:00
|
|
|
lkflg = setlkflg(lock->lk_type);
|
|
|
|
status = nfs4_check_openmode(lock_stp, lkflg);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
|
2005-07-08 04:59:15 +04:00
|
|
|
status = nfserr_grace;
|
2012-11-14 19:22:07 +04:00
|
|
|
if (locks_in_grace(net) && !lock->lk_reclaim)
|
2005-07-08 04:59:15 +04:00
|
|
|
goto out;
|
|
|
|
status = nfserr_no_grace;
|
2012-11-14 19:22:07 +04:00
|
|
|
if (!locks_in_grace(net) && lock->lk_reclaim)
|
2005-07-08 04:59:15 +04:00
|
|
|
goto out;
|
|
|
|
|
2021-08-21 00:02:06 +03:00
|
|
|
if (lock->lk_reclaim)
|
|
|
|
fl_flags |= FL_RECLAIM;
|
|
|
|
|
2014-07-30 05:34:08 +04:00
|
|
|
fp = lock_stp->st_stid.sc_file;
|
2005-04-17 02:20:36 +04:00
|
|
|
switch (lock->lk_type) {
|
|
|
|
case NFS4_READW_LT:
|
2021-08-21 00:02:04 +03:00
|
|
|
if (nfsd4_has_session(cstate) &&
|
|
|
|
!(sb->s_export_op->flags & EXPORT_OP_SYNC_LOCKS))
|
2016-09-16 23:28:24 +03:00
|
|
|
fl_flags |= FL_SLEEP;
|
2020-08-24 01:36:59 +03:00
|
|
|
fallthrough;
|
2016-09-16 23:28:24 +03:00
|
|
|
case NFS4_READ_LT:
|
2014-07-10 22:07:33 +04:00
|
|
|
spin_lock(&fp->fi_lock);
|
2019-08-18 21:18:53 +03:00
|
|
|
nf = find_readable_file_locked(fp);
|
|
|
|
if (nf)
|
2011-03-03 02:01:35 +03:00
|
|
|
get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ);
|
2014-07-10 22:07:33 +04:00
|
|
|
spin_unlock(&fp->fi_lock);
|
2016-09-16 23:28:24 +03:00
|
|
|
fl_type = F_RDLCK;
|
2011-03-03 07:48:33 +03:00
|
|
|
break;
|
2005-04-17 02:20:36 +04:00
|
|
|
case NFS4_WRITEW_LT:
|
2021-08-21 00:02:04 +03:00
|
|
|
if (nfsd4_has_session(cstate) &&
|
|
|
|
!(sb->s_export_op->flags & EXPORT_OP_SYNC_LOCKS))
|
2016-09-16 23:28:24 +03:00
|
|
|
fl_flags |= FL_SLEEP;
|
2020-08-24 01:36:59 +03:00
|
|
|
fallthrough;
|
2016-09-16 23:28:24 +03:00
|
|
|
case NFS4_WRITE_LT:
|
2014-07-10 22:07:33 +04:00
|
|
|
spin_lock(&fp->fi_lock);
|
2019-08-18 21:18:53 +03:00
|
|
|
nf = find_writeable_file_locked(fp);
|
|
|
|
if (nf)
|
2011-03-03 02:01:35 +03:00
|
|
|
get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE);
|
2014-07-10 22:07:33 +04:00
|
|
|
spin_unlock(&fp->fi_lock);
|
2016-09-16 23:28:24 +03:00
|
|
|
fl_type = F_WRLCK;
|
2011-03-03 07:48:33 +03:00
|
|
|
break;
|
2005-04-17 02:20:36 +04:00
|
|
|
default:
|
|
|
|
status = nfserr_inval;
|
|
|
|
goto out;
|
|
|
|
}
|
2016-09-16 23:28:24 +03:00
|
|
|
|
2019-08-18 21:18:53 +03:00
|
|
|
if (!nf) {
|
2010-07-08 19:02:09 +04:00
|
|
|
status = nfserr_openmode;
|
|
|
|
goto out;
|
|
|
|
}
|
2014-08-22 18:18:44 +04:00
|
|
|
|
2016-09-16 23:28:24 +03:00
|
|
|
nbl = find_or_allocate_block(lock_sop, &fp->fi_fhandle, nn);
|
|
|
|
if (!nbl) {
|
|
|
|
dprintk("NFSD: %s: unable to allocate block!\n", __func__);
|
|
|
|
status = nfserr_jukebox;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
file_lock = &nbl->nbl_lock;
|
|
|
|
file_lock->fl_type = fl_type;
|
2014-08-22 18:18:44 +04:00
|
|
|
file_lock->fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(&lock_sop->lo_owner));
|
2012-08-21 16:03:32 +04:00
|
|
|
file_lock->fl_pid = current->tgid;
|
2019-08-18 21:18:53 +03:00
|
|
|
file_lock->fl_file = nf->nf_file;
|
2016-09-16 23:28:24 +03:00
|
|
|
file_lock->fl_flags = fl_flags;
|
2012-08-21 16:03:32 +04:00
|
|
|
file_lock->fl_lmops = &nfsd_posix_mng_ops;
|
|
|
|
file_lock->fl_start = lock->lk_offset;
|
|
|
|
file_lock->fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
|
|
|
|
nfs4_transform_lock_offset(file_lock);
|
|
|
|
|
|
|
|
conflock = locks_alloc_lock();
|
|
|
|
if (!conflock) {
|
|
|
|
dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
|
|
|
|
status = nfserr_jukebox;
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2016-09-16 23:28:24 +03:00
|
|
|
if (fl_flags & FL_SLEEP) {
|
2019-11-04 18:31:52 +03:00
|
|
|
nbl->nbl_time = ktime_get_boottime_seconds();
|
2016-10-20 16:34:31 +03:00
|
|
|
spin_lock(&nn->blocked_locks_lock);
|
2016-09-16 23:28:24 +03:00
|
|
|
list_add_tail(&nbl->nbl_list, &lock_sop->lo_blocked);
|
2016-09-16 23:28:25 +03:00
|
|
|
list_add_tail(&nbl->nbl_lru, &nn->blocked_locks_lru);
|
2016-10-20 16:34:31 +03:00
|
|
|
spin_unlock(&nn->blocked_locks_lock);
|
2016-09-16 23:28:24 +03:00
|
|
|
}
|
|
|
|
|
2019-08-18 21:18:53 +03:00
|
|
|
err = vfs_lock_file(nf->nf_file, F_SETLK, file_lock, conflock);
|
2016-09-16 23:28:24 +03:00
|
|
|
switch (err) {
|
2005-04-17 02:20:36 +04:00
|
|
|
case 0: /* success! */
|
2015-10-01 16:05:50 +03:00
|
|
|
nfs4_inc_and_copy_stateid(&lock->lk_resp_stateid, &lock_stp->st_stid);
|
2006-10-20 10:29:01 +04:00
|
|
|
status = 0;
|
2018-06-08 19:28:47 +03:00
|
|
|
if (lock->lk_reclaim)
|
|
|
|
nn->somebody_reclaimed = true;
|
2006-03-26 13:37:26 +04:00
|
|
|
break;
|
2016-09-16 23:28:24 +03:00
|
|
|
case FILE_LOCK_DEFERRED:
|
|
|
|
nbl = NULL;
|
2020-08-24 01:36:59 +03:00
|
|
|
fallthrough;
|
2016-09-16 23:28:24 +03:00
|
|
|
case -EAGAIN: /* conflock holds conflicting lock */
|
2006-03-26 13:37:26 +04:00
|
|
|
status = nfserr_denied;
|
|
|
|
dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
|
2012-08-21 16:03:32 +04:00
|
|
|
nfs4_set_lock_denied(conflock, &lock->lk_denied);
|
2006-03-26 13:37:26 +04:00
|
|
|
break;
|
2016-09-16 23:28:24 +03:00
|
|
|
case -EDEADLK:
|
2005-04-17 02:20:36 +04:00
|
|
|
status = nfserr_deadlock;
|
2006-03-26 13:37:26 +04:00
|
|
|
break;
|
2011-08-11 03:07:33 +04:00
|
|
|
default:
|
2006-11-29 00:26:41 +03:00
|
|
|
dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
|
2011-08-11 03:07:33 +04:00
|
|
|
status = nfserrno(err);
|
2006-03-26 13:37:26 +04:00
|
|
|
break;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
out:
|
2016-09-16 23:28:24 +03:00
|
|
|
if (nbl) {
|
|
|
|
/* dequeue it if we queued it before */
|
|
|
|
if (fl_flags & FL_SLEEP) {
|
2016-10-20 16:34:31 +03:00
|
|
|
spin_lock(&nn->blocked_locks_lock);
|
2016-09-16 23:28:24 +03:00
|
|
|
list_del_init(&nbl->nbl_list);
|
2016-09-16 23:28:25 +03:00
|
|
|
list_del_init(&nbl->nbl_lru);
|
2016-10-20 16:34:31 +03:00
|
|
|
spin_unlock(&nn->blocked_locks_lock);
|
2016-09-16 23:28:24 +03:00
|
|
|
}
|
|
|
|
free_blocked_lock(nbl);
|
|
|
|
}
|
2019-08-18 21:18:53 +03:00
|
|
|
if (nf)
|
|
|
|
nfsd_file_put(nf);
|
2014-07-30 05:34:28 +04:00
|
|
|
if (lock_stp) {
|
|
|
|
/* Bump seqid manually if the 4.0 replay owner is openowner */
|
|
|
|
if (cstate->replay_owner &&
|
|
|
|
cstate->replay_owner != &lock_sop->lo_owner &&
|
|
|
|
seqid_mutating_err(ntohl(status)))
|
|
|
|
lock_sop->lo_owner.so_seqid++;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If this is a new, never-before-used stateid, and we are
|
|
|
|
* returning an error, then just go ahead and release it.
|
|
|
|
*/
|
2018-01-18 00:25:59 +03:00
|
|
|
if (status && new)
|
2014-07-30 05:34:28 +04:00
|
|
|
release_lock_stateid(lock_stp);
|
2017-11-03 15:00:14 +03:00
|
|
|
|
|
|
|
mutex_unlock(&lock_stp->st_mutex);
|
2014-07-30 05:34:28 +04:00
|
|
|
|
2014-07-30 05:34:15 +04:00
|
|
|
nfs4_put_stid(&lock_stp->st_stid);
|
2014-07-30 05:34:28 +04:00
|
|
|
}
|
2014-07-30 05:34:22 +04:00
|
|
|
if (open_stp)
|
|
|
|
nfs4_put_stid(&open_stp->st_stid);
|
2013-04-02 00:37:12 +04:00
|
|
|
nfsd4_bump_seqid(cstate, status);
|
2012-08-21 16:03:32 +04:00
|
|
|
if (conflock)
|
|
|
|
locks_free_lock(conflock);
|
2005-04-17 02:20:36 +04:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2008-12-20 22:58:38 +03:00
|
|
|
/*
|
|
|
|
* The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
|
|
|
|
* so we do a temporary open here just to get an open file to pass to
|
2021-08-25 05:36:03 +03:00
|
|
|
* vfs_test_lock.
|
2008-12-20 22:58:38 +03:00
|
|
|
*/
|
2012-04-13 08:00:04 +04:00
|
|
|
static __be32 nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
|
2008-12-20 22:58:38 +03:00
|
|
|
{
|
2019-08-18 21:18:55 +03:00
|
|
|
struct nfsd_file *nf;
|
2021-04-16 21:00:14 +03:00
|
|
|
__be32 err;
|
|
|
|
|
|
|
|
err = nfsd_file_acquire(rqstp, fhp, NFSD_MAY_READ, &nf);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
fh_lock(fhp); /* to block new leases till after test_lock: */
|
|
|
|
err = nfserrno(nfsd_open_break_lease(fhp->fh_dentry->d_inode,
|
|
|
|
NFSD_MAY_READ));
|
|
|
|
if (err)
|
|
|
|
goto out;
|
2021-08-25 05:36:03 +03:00
|
|
|
lock->fl_file = nf->nf_file;
|
2021-04-16 21:00:14 +03:00
|
|
|
err = nfserrno(vfs_test_lock(nf->nf_file, lock));
|
2021-08-25 05:36:03 +03:00
|
|
|
lock->fl_file = NULL;
|
2021-04-16 21:00:14 +03:00
|
|
|
out:
|
|
|
|
fh_unlock(fhp);
|
|
|
|
nfsd_file_put(nf);
|
2008-12-20 22:58:38 +03:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* LOCKT operation
|
|
|
|
*/
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32
|
2006-12-13 11:35:27 +03:00
|
|
|
nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2017-05-08 21:58:35 +03:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_lockt *lockt = &u->lockt;
|
2012-08-21 16:03:32 +04:00
|
|
|
struct file_lock *file_lock = NULL;
|
2014-07-30 05:34:28 +04:00
|
|
|
struct nfs4_lockowner *lo = NULL;
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32 status;
|
2012-11-14 19:21:05 +04:00
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2012-07-25 16:57:22 +04:00
|
|
|
if (locks_in_grace(SVC_NET(rqstp)))
|
2005-04-17 02:20:36 +04:00
|
|
|
return nfserr_grace;
|
|
|
|
|
|
|
|
if (check_lock_length(lockt->lt_offset, lockt->lt_length))
|
|
|
|
return nfserr_inval;
|
|
|
|
|
2012-12-04 02:24:41 +04:00
|
|
|
if (!nfsd4_has_session(cstate)) {
|
2021-01-22 01:57:43 +03:00
|
|
|
status = set_client(&lockt->lt_clientid, cstate, nn);
|
2012-12-04 02:24:41 +04:00
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-08-16 02:39:32 +04:00
|
|
|
if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
|
2005-04-17 02:20:36 +04:00
|
|
|
goto out;
|
|
|
|
|
2012-08-21 16:03:32 +04:00
|
|
|
file_lock = locks_alloc_lock();
|
|
|
|
if (!file_lock) {
|
|
|
|
dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
|
|
|
|
status = nfserr_jukebox;
|
|
|
|
goto out;
|
|
|
|
}
|
2014-08-15 04:02:55 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
switch (lockt->lt_type) {
|
|
|
|
case NFS4_READ_LT:
|
|
|
|
case NFS4_READW_LT:
|
2012-08-21 16:03:32 +04:00
|
|
|
file_lock->fl_type = F_RDLCK;
|
2018-11-03 19:12:53 +03:00
|
|
|
break;
|
2005-04-17 02:20:36 +04:00
|
|
|
case NFS4_WRITE_LT:
|
|
|
|
case NFS4_WRITEW_LT:
|
2012-08-21 16:03:32 +04:00
|
|
|
file_lock->fl_type = F_WRLCK;
|
2018-11-03 19:12:53 +03:00
|
|
|
break;
|
2005-04-17 02:20:36 +04:00
|
|
|
default:
|
2007-07-28 00:10:37 +04:00
|
|
|
dprintk("NFSD: nfs4_lockt: bad lock type!\n");
|
2005-04-17 02:20:36 +04:00
|
|
|
status = nfserr_inval;
|
2018-11-03 19:12:53 +03:00
|
|
|
goto out;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2015-07-13 12:35:37 +03:00
|
|
|
lo = find_lockowner_str(cstate->clp, &lockt->lt_owner);
|
2011-07-31 07:33:59 +04:00
|
|
|
if (lo)
|
2012-08-21 16:03:32 +04:00
|
|
|
file_lock->fl_owner = (fl_owner_t)lo;
|
|
|
|
file_lock->fl_pid = current->tgid;
|
|
|
|
file_lock->fl_flags = FL_POSIX;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2012-08-21 16:03:32 +04:00
|
|
|
file_lock->fl_start = lockt->lt_offset;
|
|
|
|
file_lock->fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2012-08-21 16:03:32 +04:00
|
|
|
nfs4_transform_lock_offset(file_lock);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2012-08-21 16:03:32 +04:00
|
|
|
status = nfsd_test_lock(rqstp, &cstate->current_fh, file_lock);
|
2012-04-13 08:00:04 +04:00
|
|
|
if (status)
|
2006-11-29 00:26:41 +03:00
|
|
|
goto out;
|
2012-04-13 08:00:04 +04:00
|
|
|
|
2012-08-21 16:03:32 +04:00
|
|
|
if (file_lock->fl_type != F_UNLCK) {
|
2005-04-17 02:20:36 +04:00
|
|
|
status = nfserr_denied;
|
2012-08-21 16:03:32 +04:00
|
|
|
nfs4_set_lock_denied(file_lock, &lockt->lt_denied);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
out:
|
2014-07-30 05:34:28 +04:00
|
|
|
if (lo)
|
|
|
|
nfs4_put_stateowner(&lo->lo_owner);
|
2012-08-21 16:03:32 +04:00
|
|
|
if (file_lock)
|
|
|
|
locks_free_lock(file_lock);
|
2005-04-17 02:20:36 +04:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32
|
2006-12-13 11:35:27 +03:00
|
|
|
nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2017-05-08 21:58:35 +03:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_locku *locku = &u->locku;
|
2011-09-08 00:06:42 +04:00
|
|
|
struct nfs4_ol_stateid *stp;
|
2019-08-18 21:18:53 +03:00
|
|
|
struct nfsd_file *nf = NULL;
|
2012-08-21 16:03:32 +04:00
|
|
|
struct file_lock *file_lock = NULL;
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32 status;
|
2006-10-20 10:29:01 +04:00
|
|
|
int err;
|
2012-11-14 19:22:07 +04:00
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
|
|
|
|
(long long) locku->lu_offset,
|
|
|
|
(long long) locku->lu_length);
|
|
|
|
|
|
|
|
if (check_lock_length(locku->lu_offset, locku->lu_length))
|
|
|
|
return nfserr_inval;
|
|
|
|
|
2011-08-24 20:45:03 +04:00
|
|
|
status = nfs4_preprocess_seqid_op(cstate, locku->lu_seqid,
|
2012-11-14 19:22:07 +04:00
|
|
|
&locku->lu_stateid, NFS4_LOCK_STID,
|
|
|
|
&stp, nn);
|
2011-08-24 20:45:03 +04:00
|
|
|
if (status)
|
2005-04-17 02:20:36 +04:00
|
|
|
goto out;
|
2019-08-18 21:18:53 +03:00
|
|
|
nf = find_any_file(stp->st_stid.sc_file);
|
|
|
|
if (!nf) {
|
2010-07-08 19:02:09 +04:00
|
|
|
status = nfserr_lock_range;
|
2014-07-30 05:34:16 +04:00
|
|
|
goto put_stateid;
|
2010-07-08 19:02:09 +04:00
|
|
|
}
|
2012-08-21 16:03:32 +04:00
|
|
|
file_lock = locks_alloc_lock();
|
|
|
|
if (!file_lock) {
|
|
|
|
dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
|
|
|
|
status = nfserr_jukebox;
|
2019-08-18 21:18:53 +03:00
|
|
|
goto put_file;
|
2012-08-21 16:03:32 +04:00
|
|
|
}
|
2014-08-15 04:02:55 +04:00
|
|
|
|
2012-08-21 16:03:32 +04:00
|
|
|
file_lock->fl_type = F_UNLCK;
|
2014-08-22 18:18:44 +04:00
|
|
|
file_lock->fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(stp->st_stateowner));
|
2012-08-21 16:03:32 +04:00
|
|
|
file_lock->fl_pid = current->tgid;
|
2019-08-18 21:18:53 +03:00
|
|
|
file_lock->fl_file = nf->nf_file;
|
2012-08-21 16:03:32 +04:00
|
|
|
file_lock->fl_flags = FL_POSIX;
|
|
|
|
file_lock->fl_lmops = &nfsd_posix_mng_ops;
|
|
|
|
file_lock->fl_start = locku->lu_offset;
|
|
|
|
|
|
|
|
file_lock->fl_end = last_byte_offset(locku->lu_offset,
|
|
|
|
locku->lu_length);
|
|
|
|
nfs4_transform_lock_offset(file_lock);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2019-08-18 21:18:53 +03:00
|
|
|
err = vfs_lock_file(nf->nf_file, F_SETLK, file_lock, NULL);
|
2006-10-20 10:29:01 +04:00
|
|
|
if (err) {
|
2006-11-29 00:26:41 +03:00
|
|
|
dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
|
2005-04-17 02:20:36 +04:00
|
|
|
goto out_nfserr;
|
|
|
|
}
|
2015-10-01 16:05:50 +03:00
|
|
|
nfs4_inc_and_copy_stateid(&locku->lu_stateid, &stp->st_stid);
|
2019-08-18 21:18:53 +03:00
|
|
|
put_file:
|
|
|
|
nfsd_file_put(nf);
|
2014-07-30 05:34:16 +04:00
|
|
|
put_stateid:
|
2016-06-15 06:28:04 +03:00
|
|
|
mutex_unlock(&stp->st_mutex);
|
2014-07-30 05:34:16 +04:00
|
|
|
nfs4_put_stid(&stp->st_stid);
|
2005-04-17 02:20:36 +04:00
|
|
|
out:
|
2013-04-02 00:37:12 +04:00
|
|
|
nfsd4_bump_seqid(cstate, status);
|
2012-08-21 16:03:32 +04:00
|
|
|
if (file_lock)
|
|
|
|
locks_free_lock(file_lock);
|
2005-04-17 02:20:36 +04:00
|
|
|
return status;
|
|
|
|
|
|
|
|
out_nfserr:
|
2006-10-20 10:29:01 +04:00
|
|
|
status = nfserrno(err);
|
2019-08-18 21:18:53 +03:00
|
|
|
goto put_file;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* returns
|
2014-07-24 00:17:41 +04:00
|
|
|
* true: locks held by lockowner
|
|
|
|
* false: no locks held by lockowner
|
2005-04-17 02:20:36 +04:00
|
|
|
*/
|
2014-07-24 00:17:41 +04:00
|
|
|
static bool
|
|
|
|
check_for_locks(struct nfs4_file *fp, struct nfs4_lockowner *lowner)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2015-01-16 23:05:55 +03:00
|
|
|
struct file_lock *fl;
|
2014-07-24 00:17:41 +04:00
|
|
|
int status = false;
|
2019-08-18 21:18:53 +03:00
|
|
|
struct nfsd_file *nf = find_any_file(fp);
|
2014-07-24 00:17:41 +04:00
|
|
|
struct inode *inode;
|
2015-01-16 23:05:55 +03:00
|
|
|
struct file_lock_context *flctx;
|
2014-07-24 00:17:41 +04:00
|
|
|
|
2019-08-18 21:18:53 +03:00
|
|
|
if (!nf) {
|
2014-07-24 00:17:41 +04:00
|
|
|
/* Any valid lock stateid should have some sort of access */
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2019-08-18 21:18:53 +03:00
|
|
|
inode = locks_inode(nf->nf_file);
|
2015-01-16 23:05:55 +03:00
|
|
|
flctx = inode->i_flctx;
|
|
|
|
|
|
|
|
if (flctx && !list_empty_careful(&flctx->flc_posix)) {
|
2015-01-16 23:05:57 +03:00
|
|
|
spin_lock(&flctx->flc_lock);
|
2015-01-16 23:05:55 +03:00
|
|
|
list_for_each_entry(fl, &flctx->flc_posix, fl_list) {
|
|
|
|
if (fl->fl_owner == (fl_owner_t)lowner) {
|
|
|
|
status = true;
|
|
|
|
break;
|
|
|
|
}
|
2006-01-19 04:43:22 +03:00
|
|
|
}
|
2015-01-16 23:05:57 +03:00
|
|
|
spin_unlock(&flctx->flc_lock);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2019-08-18 21:18:53 +03:00
|
|
|
nfsd_file_put(nf);
|
2005-04-17 02:20:36 +04:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32
|
2006-12-13 11:35:38 +03:00
|
|
|
nfsd4_release_lockowner(struct svc_rqst *rqstp,
|
|
|
|
struct nfsd4_compound_state *cstate,
|
2017-05-08 21:58:35 +03:00
|
|
|
union nfsd4_op_u *u)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2017-05-08 21:58:35 +03:00
|
|
|
struct nfsd4_release_lockowner *rlockowner = &u->release_lockowner;
|
2005-04-17 02:20:36 +04:00
|
|
|
clientid_t *clid = &rlockowner->rl_clientid;
|
2014-07-30 05:34:37 +04:00
|
|
|
struct nfs4_stateowner *sop;
|
|
|
|
struct nfs4_lockowner *lo = NULL;
|
2011-09-08 00:06:42 +04:00
|
|
|
struct nfs4_ol_stateid *stp;
|
2005-04-17 02:20:36 +04:00
|
|
|
struct xdr_netobj *owner = &rlockowner->rl_owner;
|
2014-07-30 05:34:36 +04:00
|
|
|
unsigned int hashval = ownerstr_hashval(owner);
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32 status;
|
2012-11-14 19:21:05 +04:00
|
|
|
struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
|
2014-07-30 05:34:35 +04:00
|
|
|
struct nfs4_client *clp;
|
2016-07-13 23:40:14 +03:00
|
|
|
LIST_HEAD (reaplist);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
|
|
|
|
clid->cl_boot, clid->cl_id);
|
|
|
|
|
2021-01-22 01:57:43 +03:00
|
|
|
status = set_client(clid, cstate, nn);
|
2012-12-04 02:24:41 +04:00
|
|
|
if (status)
|
2014-07-30 16:27:27 +04:00
|
|
|
return status;
|
2012-12-04 02:24:41 +04:00
|
|
|
|
2014-07-30 05:34:36 +04:00
|
|
|
clp = cstate->clp;
|
2014-06-30 19:48:41 +04:00
|
|
|
/* Find the matching lock stateowner */
|
2014-07-30 05:34:36 +04:00
|
|
|
spin_lock(&clp->cl_lock);
|
2014-07-30 05:34:37 +04:00
|
|
|
list_for_each_entry(sop, &clp->cl_ownerstr_hashtbl[hashval],
|
2014-07-30 05:34:36 +04:00
|
|
|
so_strhash) {
|
2014-06-30 19:48:41 +04:00
|
|
|
|
2014-07-30 05:34:37 +04:00
|
|
|
if (sop->so_is_open_owner || !same_owner_str(sop, owner))
|
|
|
|
continue;
|
2014-06-30 19:48:41 +04:00
|
|
|
|
2014-07-30 05:34:37 +04:00
|
|
|
/* see if there are still any locks associated with it */
|
|
|
|
lo = lockowner(sop);
|
|
|
|
list_for_each_entry(stp, &sop->so_stateids, st_perstateowner) {
|
|
|
|
if (check_for_locks(stp->st_stid.sc_file, lo)) {
|
|
|
|
status = nfserr_locks_held;
|
|
|
|
spin_unlock(&clp->cl_lock);
|
2014-07-30 16:27:27 +04:00
|
|
|
return status;
|
2014-07-30 05:34:37 +04:00
|
|
|
}
|
2014-07-30 05:34:31 +04:00
|
|
|
}
|
2014-07-30 05:34:37 +04:00
|
|
|
|
2014-08-22 18:18:43 +04:00
|
|
|
nfs4_get_stateowner(sop);
|
2014-07-30 05:34:37 +04:00
|
|
|
break;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2016-07-13 23:40:14 +03:00
|
|
|
if (!lo) {
|
|
|
|
spin_unlock(&clp->cl_lock);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
unhash_lockowner_locked(lo);
|
|
|
|
while (!list_empty(&lo->lo_owner.so_stateids)) {
|
|
|
|
stp = list_first_entry(&lo->lo_owner.so_stateids,
|
|
|
|
struct nfs4_ol_stateid,
|
|
|
|
st_perstateowner);
|
|
|
|
WARN_ON(!unhash_lock_stateid(stp));
|
|
|
|
put_ol_stateid_locked(stp, &reaplist);
|
|
|
|
}
|
2014-07-30 05:34:35 +04:00
|
|
|
spin_unlock(&clp->cl_lock);
|
2016-07-13 23:40:14 +03:00
|
|
|
free_ol_stateid_reaplist(&reaplist);
|
2018-03-16 18:32:02 +03:00
|
|
|
remove_blocked_locks(lo);
|
2016-07-13 23:40:14 +03:00
|
|
|
nfs4_put_stateowner(&lo->lo_owner);
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct nfs4_client_reclaim *
|
2005-06-24 09:03:52 +04:00
|
|
|
alloc_reclaim(void)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2005-06-24 09:03:52 +04:00
|
|
|
return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2012-11-13 00:00:55 +04:00
|
|
|
bool
|
2019-03-27 01:06:26 +03:00
|
|
|
nfs4_has_reclaimed_state(struct xdr_netobj name, struct nfsd_net *nn)
|
2005-06-24 09:04:30 +04:00
|
|
|
{
|
2012-11-13 00:00:55 +04:00
|
|
|
struct nfs4_client_reclaim *crp;
|
2005-06-24 09:04:30 +04:00
|
|
|
|
2012-11-14 19:21:16 +04:00
|
|
|
crp = nfsd4_find_reclaim_client(name, nn);
|
2012-11-13 00:00:55 +04:00
|
|
|
return (crp && crp->cr_clp);
|
2005-06-24 09:04:30 +04:00
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* failure => all reset bets are off, nfserr_no_grace...
|
2019-03-27 01:06:26 +03:00
|
|
|
*
|
|
|
|
* The caller is responsible for freeing name.data if NULL is returned (it
|
|
|
|
* will be freed in nfs4_remove_reclaim_record in the normal case).
|
2005-04-17 02:20:36 +04:00
|
|
|
*/
|
2012-11-13 00:00:54 +04:00
|
|
|
struct nfs4_client_reclaim *
|
2019-09-09 23:10:31 +03:00
|
|
|
nfs4_client_to_reclaim(struct xdr_netobj name, struct xdr_netobj princhash,
|
|
|
|
struct nfsd_net *nn)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
unsigned int strhashval;
|
2012-11-13 00:00:54 +04:00
|
|
|
struct nfs4_client_reclaim *crp;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2005-06-24 09:03:52 +04:00
|
|
|
crp = alloc_reclaim();
|
2012-11-13 00:00:54 +04:00
|
|
|
if (crp) {
|
|
|
|
strhashval = clientstr_hashval(name);
|
|
|
|
INIT_LIST_HEAD(&crp->cr_strhash);
|
2012-11-14 19:21:16 +04:00
|
|
|
list_add(&crp->cr_strhash, &nn->reclaim_str_hashtbl[strhashval]);
|
2019-03-27 01:06:26 +03:00
|
|
|
crp->cr_name.data = name.data;
|
|
|
|
crp->cr_name.len = name.len;
|
2019-09-09 23:10:31 +03:00
|
|
|
crp->cr_princhash.data = princhash.data;
|
|
|
|
crp->cr_princhash.len = princhash.len;
|
2012-11-13 00:00:55 +04:00
|
|
|
crp->cr_clp = NULL;
|
2012-11-14 19:21:16 +04:00
|
|
|
nn->reclaim_str_hashtbl_size++;
|
2012-11-13 00:00:54 +04:00
|
|
|
}
|
|
|
|
return crp;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2012-11-13 00:00:53 +04:00
|
|
|
void
|
2012-11-14 19:21:16 +04:00
|
|
|
nfs4_remove_reclaim_record(struct nfs4_client_reclaim *crp, struct nfsd_net *nn)
|
2012-11-13 00:00:53 +04:00
|
|
|
{
|
|
|
|
list_del(&crp->cr_strhash);
|
2019-03-27 01:06:26 +03:00
|
|
|
kfree(crp->cr_name.data);
|
2019-09-09 23:10:31 +03:00
|
|
|
kfree(crp->cr_princhash.data);
|
2012-11-13 00:00:53 +04:00
|
|
|
kfree(crp);
|
2012-11-14 19:21:16 +04:00
|
|
|
nn->reclaim_str_hashtbl_size--;
|
2012-11-13 00:00:53 +04:00
|
|
|
}
|
|
|
|
|
2012-03-22 00:42:43 +04:00
|
|
|
void
|
2012-11-14 19:21:16 +04:00
|
|
|
nfs4_release_reclaim(struct nfsd_net *nn)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
struct nfs4_client_reclaim *crp = NULL;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < CLIENT_HASH_SIZE; i++) {
|
2012-11-14 19:21:16 +04:00
|
|
|
while (!list_empty(&nn->reclaim_str_hashtbl[i])) {
|
|
|
|
crp = list_entry(nn->reclaim_str_hashtbl[i].next,
|
2005-04-17 02:20:36 +04:00
|
|
|
struct nfs4_client_reclaim, cr_strhash);
|
2012-11-14 19:21:16 +04:00
|
|
|
nfs4_remove_reclaim_record(crp, nn);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
}
|
2012-11-25 23:48:10 +04:00
|
|
|
WARN_ON_ONCE(nn->reclaim_str_hashtbl_size);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* called from OPEN, CLAIM_PREVIOUS with a new clientid. */
|
2012-03-22 00:42:43 +04:00
|
|
|
struct nfs4_client_reclaim *
|
2019-03-27 01:06:26 +03:00
|
|
|
nfsd4_find_reclaim_client(struct xdr_netobj name, struct nfsd_net *nn)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
unsigned int strhashval;
|
|
|
|
struct nfs4_client_reclaim *crp = NULL;
|
|
|
|
|
2019-03-27 01:06:26 +03:00
|
|
|
strhashval = clientstr_hashval(name);
|
2012-11-14 19:21:16 +04:00
|
|
|
list_for_each_entry(crp, &nn->reclaim_str_hashtbl[strhashval], cr_strhash) {
|
2019-03-27 01:06:26 +03:00
|
|
|
if (compare_blob(&crp->cr_name, &name) == 0) {
|
2005-04-17 02:20:36 +04:00
|
|
|
return crp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-10-20 10:28:59 +04:00
|
|
|
__be32
|
2021-01-22 01:57:44 +03:00
|
|
|
nfs4_check_open_reclaim(struct nfs4_client *clp)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2021-01-22 01:57:44 +03:00
|
|
|
if (test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE, &clp->cl_flags))
|
2014-09-13 00:40:22 +04:00
|
|
|
return nfserr_no_grace;
|
|
|
|
|
2021-01-22 01:57:44 +03:00
|
|
|
if (nfsd4_client_record_check(clp))
|
2014-06-30 19:48:47 +04:00
|
|
|
return nfserr_reclaim_bad;
|
|
|
|
|
|
|
|
return nfs_ok;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2007-07-17 15:04:39 +04:00
|
|
|
/*
|
|
|
|
* Since the lifetime of a delegation isn't limited to that of an open, a
|
|
|
|
* client may quite reasonably hang on to a delegation as long as it has
|
|
|
|
* the inode cached. This becomes an obvious problem the first time a
|
|
|
|
* client's inode cache approaches the size of the server's total memory.
|
|
|
|
*
|
|
|
|
* For now we avoid this problem by imposing a hard limit on the number
|
|
|
|
* of delegations, which varies according to the server's memory size.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
set_max_delegations(void)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Allow at most 4 delegations per megabyte of RAM. Quick
|
|
|
|
* estimates suggest that in the worst case (where every delegation
|
|
|
|
* is for a different inode), a delegation could take about 1.5K,
|
|
|
|
* giving a worst case usage of about 6% of memory.
|
|
|
|
*/
|
|
|
|
max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
|
|
|
|
}
|
|
|
|
|
2012-11-26 16:22:13 +04:00
|
|
|
static int nfs4_state_create_net(struct net *net)
|
2012-11-14 19:21:21 +04:00
|
|
|
{
|
|
|
|
struct nfsd_net *nn = net_generic(net, nfsd_net_id);
|
|
|
|
int i;
|
|
|
|
|
treewide: kmalloc() -> kmalloc_array()
The kmalloc() function has a 2-factor argument form, kmalloc_array(). This
patch replaces cases of:
kmalloc(a * b, gfp)
with:
kmalloc_array(a * b, gfp)
as well as handling cases of:
kmalloc(a * b * c, gfp)
with:
kmalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kmalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kmalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The tools/ directory was manually excluded, since it has its own
implementation of kmalloc().
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kmalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kmalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kmalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kmalloc
+ kmalloc_array
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kmalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kmalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kmalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kmalloc(sizeof(THING) * C2, ...)
|
kmalloc(sizeof(TYPE) * C2, ...)
|
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(C1 * C2, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * E2
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 23:55:00 +03:00
|
|
|
nn->conf_id_hashtbl = kmalloc_array(CLIENT_HASH_SIZE,
|
|
|
|
sizeof(struct list_head),
|
|
|
|
GFP_KERNEL);
|
2012-11-14 19:21:21 +04:00
|
|
|
if (!nn->conf_id_hashtbl)
|
2012-11-14 19:21:26 +04:00
|
|
|
goto err;
|
treewide: kmalloc() -> kmalloc_array()
The kmalloc() function has a 2-factor argument form, kmalloc_array(). This
patch replaces cases of:
kmalloc(a * b, gfp)
with:
kmalloc_array(a * b, gfp)
as well as handling cases of:
kmalloc(a * b * c, gfp)
with:
kmalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kmalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kmalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The tools/ directory was manually excluded, since it has its own
implementation of kmalloc().
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kmalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kmalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kmalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kmalloc
+ kmalloc_array
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kmalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kmalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kmalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kmalloc(sizeof(THING) * C2, ...)
|
kmalloc(sizeof(TYPE) * C2, ...)
|
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(C1 * C2, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * E2
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 23:55:00 +03:00
|
|
|
nn->unconf_id_hashtbl = kmalloc_array(CLIENT_HASH_SIZE,
|
|
|
|
sizeof(struct list_head),
|
|
|
|
GFP_KERNEL);
|
2012-11-14 19:21:31 +04:00
|
|
|
if (!nn->unconf_id_hashtbl)
|
|
|
|
goto err_unconf_id;
|
treewide: kmalloc() -> kmalloc_array()
The kmalloc() function has a 2-factor argument form, kmalloc_array(). This
patch replaces cases of:
kmalloc(a * b, gfp)
with:
kmalloc_array(a * b, gfp)
as well as handling cases of:
kmalloc(a * b * c, gfp)
with:
kmalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kmalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kmalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The tools/ directory was manually excluded, since it has its own
implementation of kmalloc().
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kmalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kmalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kmalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kmalloc
+ kmalloc_array
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kmalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kmalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kmalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kmalloc(sizeof(THING) * C2, ...)
|
kmalloc(sizeof(TYPE) * C2, ...)
|
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(C1 * C2, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * E2
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 23:55:00 +03:00
|
|
|
nn->sessionid_hashtbl = kmalloc_array(SESSION_HASH_SIZE,
|
|
|
|
sizeof(struct list_head),
|
|
|
|
GFP_KERNEL);
|
2012-11-14 19:21:51 +04:00
|
|
|
if (!nn->sessionid_hashtbl)
|
|
|
|
goto err_sessionid;
|
2012-11-14 19:21:21 +04:00
|
|
|
|
2012-11-14 19:21:26 +04:00
|
|
|
for (i = 0; i < CLIENT_HASH_SIZE; i++) {
|
2012-11-14 19:21:21 +04:00
|
|
|
INIT_LIST_HEAD(&nn->conf_id_hashtbl[i]);
|
2012-11-14 19:21:31 +04:00
|
|
|
INIT_LIST_HEAD(&nn->unconf_id_hashtbl[i]);
|
2012-11-14 19:21:26 +04:00
|
|
|
}
|
2012-11-14 19:21:51 +04:00
|
|
|
for (i = 0; i < SESSION_HASH_SIZE; i++)
|
|
|
|
INIT_LIST_HEAD(&nn->sessionid_hashtbl[i]);
|
2012-11-14 19:21:26 +04:00
|
|
|
nn->conf_name_tree = RB_ROOT;
|
2012-11-14 19:21:36 +04:00
|
|
|
nn->unconf_name_tree = RB_ROOT;
|
2019-10-31 17:53:13 +03:00
|
|
|
nn->boot_time = ktime_get_real_seconds();
|
2017-11-13 07:25:40 +03:00
|
|
|
nn->grace_ended = false;
|
|
|
|
nn->nfsd4_manager.block_opens = true;
|
|
|
|
INIT_LIST_HEAD(&nn->nfsd4_manager.list);
|
2012-11-14 19:21:56 +04:00
|
|
|
INIT_LIST_HEAD(&nn->client_lru);
|
2012-11-14 19:22:01 +04:00
|
|
|
INIT_LIST_HEAD(&nn->close_lru);
|
2013-03-21 23:19:33 +04:00
|
|
|
INIT_LIST_HEAD(&nn->del_recall_lru);
|
2012-11-26 16:21:58 +04:00
|
|
|
spin_lock_init(&nn->client_lock);
|
2018-07-21 01:19:20 +03:00
|
|
|
spin_lock_init(&nn->s2s_cp_lock);
|
|
|
|
idr_init(&nn->s2s_cp_stateids);
|
2012-11-14 19:21:21 +04:00
|
|
|
|
2016-10-20 16:34:31 +03:00
|
|
|
spin_lock_init(&nn->blocked_locks_lock);
|
|
|
|
INIT_LIST_HEAD(&nn->blocked_locks_lru);
|
|
|
|
|
2012-11-14 19:22:17 +04:00
|
|
|
INIT_DELAYED_WORK(&nn->laundromat_work, laundromat_main);
|
2012-11-26 16:22:13 +04:00
|
|
|
get_net(net);
|
2012-11-14 19:22:17 +04:00
|
|
|
|
2012-11-14 19:21:21 +04:00
|
|
|
return 0;
|
2012-11-14 19:21:26 +04:00
|
|
|
|
2012-11-14 19:21:51 +04:00
|
|
|
err_sessionid:
|
2012-11-14 19:21:41 +04:00
|
|
|
kfree(nn->unconf_id_hashtbl);
|
2012-11-14 19:21:31 +04:00
|
|
|
err_unconf_id:
|
|
|
|
kfree(nn->conf_id_hashtbl);
|
2012-11-14 19:21:26 +04:00
|
|
|
err:
|
|
|
|
return -ENOMEM;
|
2012-11-14 19:21:21 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-11-26 16:22:08 +04:00
|
|
|
nfs4_state_destroy_net(struct net *net)
|
2012-11-14 19:21:21 +04:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct nfs4_client *clp = NULL;
|
|
|
|
struct nfsd_net *nn = net_generic(net, nfsd_net_id);
|
|
|
|
|
|
|
|
for (i = 0; i < CLIENT_HASH_SIZE; i++) {
|
|
|
|
while (!list_empty(&nn->conf_id_hashtbl[i])) {
|
|
|
|
clp = list_entry(nn->conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
|
|
|
|
destroy_client(clp);
|
|
|
|
}
|
|
|
|
}
|
2012-11-14 19:21:36 +04:00
|
|
|
|
2018-03-16 18:32:02 +03:00
|
|
|
WARN_ON(!list_empty(&nn->blocked_locks_lru));
|
|
|
|
|
2014-03-26 18:09:30 +04:00
|
|
|
for (i = 0; i < CLIENT_HASH_SIZE; i++) {
|
|
|
|
while (!list_empty(&nn->unconf_id_hashtbl[i])) {
|
|
|
|
clp = list_entry(nn->unconf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
|
|
|
|
destroy_client(clp);
|
|
|
|
}
|
2012-11-14 19:21:36 +04:00
|
|
|
}
|
|
|
|
|
2012-11-14 19:21:51 +04:00
|
|
|
kfree(nn->sessionid_hashtbl);
|
2012-11-14 19:21:31 +04:00
|
|
|
kfree(nn->unconf_id_hashtbl);
|
2012-11-14 19:21:21 +04:00
|
|
|
kfree(nn->conf_id_hashtbl);
|
2012-11-26 16:22:08 +04:00
|
|
|
put_net(net);
|
2012-11-14 19:21:21 +04:00
|
|
|
}
|
|
|
|
|
2012-11-26 16:22:18 +04:00
|
|
|
int
|
2012-11-26 16:22:13 +04:00
|
|
|
nfs4_state_start_net(struct net *net)
|
2005-06-24 09:03:30 +04:00
|
|
|
{
|
2012-07-25 16:56:58 +04:00
|
|
|
struct nfsd_net *nn = net_generic(net, nfsd_net_id);
|
2010-03-03 22:52:55 +03:00
|
|
|
int ret;
|
|
|
|
|
2020-06-23 23:00:33 +03:00
|
|
|
ret = nfs4_state_create_net(net);
|
2021-03-14 00:08:47 +03:00
|
|
|
if (ret)
|
2020-06-23 23:00:33 +03:00
|
|
|
return ret;
|
2014-09-13 00:40:21 +04:00
|
|
|
locks_start_grace(net, &nn->nfsd4_manager);
|
|
|
|
nfsd4_client_tracking_init(net);
|
2019-03-27 01:06:28 +03:00
|
|
|
if (nn->track_reclaim_completes && nn->reclaim_str_hashtbl_size == 0)
|
|
|
|
goto skip_grace;
|
2019-11-04 18:31:52 +03:00
|
|
|
printk(KERN_INFO "NFSD: starting %lld-second grace period (net %x)\n",
|
2017-11-06 16:46:04 +03:00
|
|
|
nn->nfsd4_grace, net->ns.inum);
|
2020-04-05 18:42:29 +03:00
|
|
|
trace_nfsd_grace_start(nn);
|
2012-11-27 15:11:49 +04:00
|
|
|
queue_delayed_work(laundry_wq, &nn->laundromat_work, nn->nfsd4_grace * HZ);
|
2012-11-26 16:22:13 +04:00
|
|
|
return 0;
|
2019-03-27 01:06:28 +03:00
|
|
|
|
|
|
|
skip_grace:
|
|
|
|
printk(KERN_INFO "NFSD: no clients to reclaim, skipping NFSv4 grace period (net %x)\n",
|
|
|
|
net->ns.inum);
|
|
|
|
queue_delayed_work(laundry_wq, &nn->laundromat_work, nn->nfsd4_lease * HZ);
|
|
|
|
nfsd4_end_grace(nn);
|
|
|
|
return 0;
|
2012-11-26 16:22:13 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* initialization to perform when the nfsd service is started: */
|
|
|
|
|
|
|
|
int
|
|
|
|
nfs4_state_start(void)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2015-08-20 14:17:01 +03:00
|
|
|
laundry_wq = alloc_workqueue("%s", WQ_UNBOUND, 0, "nfsd4");
|
2012-03-05 20:42:36 +04:00
|
|
|
if (laundry_wq == NULL) {
|
|
|
|
ret = -ENOMEM;
|
2018-08-16 19:06:09 +03:00
|
|
|
goto out;
|
2012-03-05 20:42:36 +04:00
|
|
|
}
|
2010-03-03 22:52:55 +03:00
|
|
|
ret = nfsd4_create_callback_queue();
|
|
|
|
if (ret)
|
|
|
|
goto out_free_laundry;
|
2012-11-14 19:22:17 +04:00
|
|
|
|
2007-07-17 15:04:39 +04:00
|
|
|
set_max_delegations();
|
2010-03-03 22:52:55 +03:00
|
|
|
return 0;
|
2012-11-26 16:22:13 +04:00
|
|
|
|
2010-03-03 22:52:55 +03:00
|
|
|
out_free_laundry:
|
|
|
|
destroy_workqueue(laundry_wq);
|
2018-08-16 19:06:09 +03:00
|
|
|
out:
|
2010-03-03 22:52:55 +03:00
|
|
|
return ret;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2012-11-26 16:22:18 +04:00
|
|
|
void
|
2012-11-26 16:22:08 +04:00
|
|
|
nfs4_state_shutdown_net(struct net *net)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
struct nfs4_delegation *dp = NULL;
|
|
|
|
struct list_head *pos, *next, reaplist;
|
2012-11-26 16:22:08 +04:00
|
|
|
struct nfsd_net *nn = net_generic(net, nfsd_net_id);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2012-11-26 16:22:08 +04:00
|
|
|
cancel_delayed_work_sync(&nn->laundromat_work);
|
|
|
|
locks_end_grace(&nn->nfsd4_manager);
|
2012-11-13 00:00:56 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
INIT_LIST_HEAD(&reaplist);
|
2014-05-30 17:09:30 +04:00
|
|
|
spin_lock(&state_lock);
|
2013-03-21 23:19:33 +04:00
|
|
|
list_for_each_safe(pos, next, &nn->del_recall_lru) {
|
2005-04-17 02:20:36 +04:00
|
|
|
dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
|
2015-08-24 19:41:48 +03:00
|
|
|
WARN_ON(!unhash_delegation_locked(dp));
|
2014-07-25 15:34:20 +04:00
|
|
|
list_add(&dp->dl_recall_lru, &reaplist);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2014-05-30 17:09:30 +04:00
|
|
|
spin_unlock(&state_lock);
|
2005-04-17 02:20:36 +04:00
|
|
|
list_for_each_safe(pos, next, &reaplist) {
|
|
|
|
dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
|
2014-07-25 15:34:20 +04:00
|
|
|
list_del_init(&dp->dl_recall_lru);
|
2018-02-21 23:11:03 +03:00
|
|
|
destroy_unhashed_deleg(dp);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2012-11-14 19:22:07 +04:00
|
|
|
nfsd4_client_tracking_exit(net);
|
2012-11-26 16:22:08 +04:00
|
|
|
nfs4_state_destroy_net(net);
|
2021-05-21 22:09:37 +03:00
|
|
|
#ifdef CONFIG_NFSD_V4_2_INTER_SSC
|
|
|
|
nfsd4_ssc_shutdown_umount(nn);
|
|
|
|
#endif
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nfs4_state_shutdown(void)
|
|
|
|
{
|
2006-04-11 09:55:37 +04:00
|
|
|
destroy_workqueue(laundry_wq);
|
2010-06-05 00:42:08 +04:00
|
|
|
nfsd4_destroy_callback_queue();
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2012-02-14 01:55:24 +04:00
|
|
|
|
|
|
|
static void
|
|
|
|
get_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
|
|
|
|
{
|
2018-09-13 20:58:24 +03:00
|
|
|
if (HAS_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG) &&
|
|
|
|
CURRENT_STATEID(stateid))
|
2012-02-14 01:55:32 +04:00
|
|
|
memcpy(stateid, &cstate->current_stateid, sizeof(stateid_t));
|
2012-02-14 01:55:24 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
put_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
|
|
|
|
{
|
2012-02-14 01:55:32 +04:00
|
|
|
if (cstate->minorversion) {
|
|
|
|
memcpy(&cstate->current_stateid, stateid, sizeof(stateid_t));
|
2018-09-13 20:58:24 +03:00
|
|
|
SET_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG);
|
2012-02-14 01:55:32 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
clear_current_stateid(struct nfsd4_compound_state *cstate)
|
|
|
|
{
|
2018-09-13 20:58:24 +03:00
|
|
|
CLEAR_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG);
|
2012-02-14 01:55:24 +04:00
|
|
|
}
|
|
|
|
|
2012-02-14 01:55:25 +04:00
|
|
|
/*
|
|
|
|
* functions to set current state id
|
|
|
|
*/
|
2012-02-14 01:55:31 +04:00
|
|
|
void
|
2017-05-08 21:03:15 +03:00
|
|
|
nfsd4_set_opendowngradestateid(struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
2012-02-14 01:55:31 +04:00
|
|
|
{
|
2017-05-08 21:03:15 +03:00
|
|
|
put_stateid(cstate, &u->open_downgrade.od_stateid);
|
2012-02-14 01:55:31 +04:00
|
|
|
}
|
|
|
|
|
2012-02-14 01:55:24 +04:00
|
|
|
void
|
2017-05-08 21:03:15 +03:00
|
|
|
nfsd4_set_openstateid(struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
2012-02-14 01:55:24 +04:00
|
|
|
{
|
2017-05-08 21:03:15 +03:00
|
|
|
put_stateid(cstate, &u->open.op_stateid);
|
2012-02-14 01:55:24 +04:00
|
|
|
}
|
|
|
|
|
2012-02-14 01:55:25 +04:00
|
|
|
void
|
2017-05-08 21:03:15 +03:00
|
|
|
nfsd4_set_closestateid(struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
2012-02-14 01:55:25 +04:00
|
|
|
{
|
2017-05-08 21:03:15 +03:00
|
|
|
put_stateid(cstate, &u->close.cl_stateid);
|
2012-02-14 01:55:25 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2017-05-08 21:03:15 +03:00
|
|
|
nfsd4_set_lockstateid(struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
2012-02-14 01:55:25 +04:00
|
|
|
{
|
2017-05-08 21:03:15 +03:00
|
|
|
put_stateid(cstate, &u->lock.lk_resp_stateid);
|
2012-02-14 01:55:25 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* functions to consume current state id
|
|
|
|
*/
|
2012-02-14 01:55:30 +04:00
|
|
|
|
2012-02-14 01:55:31 +04:00
|
|
|
void
|
2017-05-08 21:37:33 +03:00
|
|
|
nfsd4_get_opendowngradestateid(struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
2012-02-14 01:55:31 +04:00
|
|
|
{
|
2017-05-08 21:37:33 +03:00
|
|
|
get_stateid(cstate, &u->open_downgrade.od_stateid);
|
2012-02-14 01:55:31 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2017-05-08 21:37:33 +03:00
|
|
|
nfsd4_get_delegreturnstateid(struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
2012-02-14 01:55:31 +04:00
|
|
|
{
|
2017-05-08 21:37:33 +03:00
|
|
|
get_stateid(cstate, &u->delegreturn.dr_stateid);
|
2012-02-14 01:55:31 +04:00
|
|
|
}
|
|
|
|
|
2012-02-14 01:55:30 +04:00
|
|
|
void
|
2017-05-08 21:37:33 +03:00
|
|
|
nfsd4_get_freestateid(struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
2012-02-14 01:55:30 +04:00
|
|
|
{
|
2017-05-08 21:37:33 +03:00
|
|
|
get_stateid(cstate, &u->free_stateid.fr_stateid);
|
2012-02-14 01:55:30 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2017-05-08 21:37:33 +03:00
|
|
|
nfsd4_get_setattrstateid(struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
2012-02-14 01:55:30 +04:00
|
|
|
{
|
2017-05-08 21:37:33 +03:00
|
|
|
get_stateid(cstate, &u->setattr.sa_stateid);
|
2012-02-14 01:55:30 +04:00
|
|
|
}
|
|
|
|
|
2012-02-14 01:55:24 +04:00
|
|
|
void
|
2017-05-08 21:37:33 +03:00
|
|
|
nfsd4_get_closestateid(struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
2012-02-14 01:55:24 +04:00
|
|
|
{
|
2017-05-08 21:37:33 +03:00
|
|
|
get_stateid(cstate, &u->close.cl_stateid);
|
2012-02-14 01:55:24 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2017-05-08 21:37:33 +03:00
|
|
|
nfsd4_get_lockustateid(struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
2012-02-14 01:55:24 +04:00
|
|
|
{
|
2017-05-08 21:37:33 +03:00
|
|
|
get_stateid(cstate, &u->locku.lu_stateid);
|
2012-02-14 01:55:24 +04:00
|
|
|
}
|
2012-02-14 01:55:26 +04:00
|
|
|
|
|
|
|
void
|
2017-05-08 21:37:33 +03:00
|
|
|
nfsd4_get_readstateid(struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
2012-02-14 01:55:26 +04:00
|
|
|
{
|
2017-05-08 21:37:33 +03:00
|
|
|
get_stateid(cstate, &u->read.rd_stateid);
|
2012-02-14 01:55:26 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2017-05-08 21:37:33 +03:00
|
|
|
nfsd4_get_writestateid(struct nfsd4_compound_state *cstate,
|
|
|
|
union nfsd4_op_u *u)
|
2012-02-14 01:55:26 +04:00
|
|
|
{
|
2017-05-08 21:37:33 +03:00
|
|
|
get_stateid(cstate, &u->write.wr_stateid);
|
2012-02-14 01:55:26 +04:00
|
|
|
}
|