2005-04-17 00:20:36 +02: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-15 23:37:31 +01:00
|
|
|
#include <linux/file.h>
|
2010-09-18 15:09:31 +02: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 09:04:11 +01:00
|
|
|
#include <linux/slab.h>
|
2005-06-24 07:04:32 +02:00
|
|
|
#include <linux/namei.h>
|
2007-07-17 13:04:39 +02:00
|
|
|
#include <linux/swap.h>
|
2011-07-13 16:50:48 +02:00
|
|
|
#include <linux/pagemap.h>
|
2008-12-23 22:17:15 +01:00
|
|
|
#include <linux/sunrpc/svcauth_gss.h>
|
2009-08-14 18:57:56 +02:00
|
|
|
#include <linux/sunrpc/clnt.h>
|
2009-12-03 19:30:56 +01:00
|
|
|
#include "xdr4.h"
|
2009-11-05 00:12:35 +01:00
|
|
|
#include "vfs.h"
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#define NFSDDBG_FACILITY NFSDDBG_PROC
|
|
|
|
|
|
|
|
/* Globals */
|
2010-03-01 05:20:19 +01:00
|
|
|
time_t nfsd4_lease = 90; /* default lease time */
|
2010-03-02 17:04:06 +01:00
|
|
|
time_t nfsd4_grace = 90;
|
2005-06-24 07:04:03 +02:00
|
|
|
static time_t boot_time;
|
2005-04-17 00:20:36 +02:00
|
|
|
static u32 current_ownerid = 1;
|
|
|
|
static u32 current_fileid = 1;
|
|
|
|
static u32 current_delegid = 1;
|
2005-06-24 07:04:03 +02:00
|
|
|
static stateid_t zerostateid; /* bits all 0 */
|
|
|
|
static stateid_t onestateid; /* bits all 1 */
|
2009-04-03 07:28:28 +02:00
|
|
|
static u64 current_sessionid = 1;
|
2005-06-24 07:04:03 +02:00
|
|
|
|
|
|
|
#define ZERO_STATEID(stateid) (!memcmp((stateid), &zerostateid, sizeof(stateid_t)))
|
|
|
|
#define ONE_STATEID(stateid) (!memcmp((stateid), &onestateid, sizeof(stateid_t)))
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* forward declarations */
|
2005-06-24 07:04:03 +02:00
|
|
|
static struct nfs4_stateid * find_stateid(stateid_t *stid, int flags);
|
2011-07-13 17:04:21 +02:00
|
|
|
static struct nfs4_stateid * search_for_stateid(stateid_t *stid);
|
|
|
|
static struct nfs4_delegation * search_for_delegation(stateid_t *stid);
|
2005-04-17 00:20:36 +02:00
|
|
|
static struct nfs4_delegation * find_delegation_stateid(struct inode *ino, stateid_t *stid);
|
2005-06-24 07:04:32 +02:00
|
|
|
static char user_recovery_dirname[PATH_MAX] = "/var/lib/nfs/v4recovery";
|
|
|
|
static void nfs4_set_recdir(char *recdir);
|
2011-07-13 17:04:21 +02:00
|
|
|
static int check_for_locks(struct nfs4_file *filp, struct nfs4_stateowner *lowner);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-02-22 23:51:34 +01:00
|
|
|
/* Locking: */
|
|
|
|
|
|
|
|
/* Currently used for almost all code touching nfsv4 state: */
|
2006-03-26 11:37:12 +02:00
|
|
|
static DEFINE_MUTEX(client_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-02-22 23:51:34 +01:00
|
|
|
/*
|
|
|
|
* 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:
|
|
|
|
*/
|
|
|
|
static DEFINE_SPINLOCK(recall_lock);
|
|
|
|
|
2006-12-07 05:33:20 +01:00
|
|
|
static struct kmem_cache *stateowner_slab = NULL;
|
|
|
|
static struct kmem_cache *file_slab = NULL;
|
|
|
|
static struct kmem_cache *stateid_slab = NULL;
|
|
|
|
static struct kmem_cache *deleg_slab = NULL;
|
2005-06-24 07:03:01 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
void
|
|
|
|
nfs4_lock_state(void)
|
|
|
|
{
|
2006-03-26 11:37:12 +02:00
|
|
|
mutex_lock(&client_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nfs4_unlock_state(void)
|
|
|
|
{
|
2006-03-26 11:37:12 +02:00
|
|
|
mutex_unlock(&client_mutex);
|
2005-04-17 00:20:36 +02: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;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct list_head del_recall_lru;
|
|
|
|
|
2005-06-24 07:03:10 +02:00
|
|
|
static inline void
|
|
|
|
put_nfs4_file(struct nfs4_file *fi)
|
|
|
|
{
|
2009-02-22 23:51:34 +01:00
|
|
|
if (atomic_dec_and_lock(&fi->fi_ref, &recall_lock)) {
|
|
|
|
list_del(&fi->fi_hash);
|
|
|
|
spin_unlock(&recall_lock);
|
|
|
|
iput(fi->fi_inode);
|
|
|
|
kmem_cache_free(file_slab, fi);
|
|
|
|
}
|
2005-06-24 07:03:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
get_nfs4_file(struct nfs4_file *fi)
|
|
|
|
{
|
2009-02-22 23:51:34 +01:00
|
|
|
atomic_inc(&fi->fi_ref);
|
2005-06-24 07:03:10 +02:00
|
|
|
}
|
|
|
|
|
2006-04-11 07:55:41 +02:00
|
|
|
static int num_delegations;
|
2007-07-17 13:04:39 +02:00
|
|
|
unsigned int max_delegations;
|
2006-04-11 07:55:41 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Open owner state (share locks)
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* hash tables for nfs4_stateowner */
|
|
|
|
#define OWNER_HASH_BITS 8
|
|
|
|
#define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS)
|
|
|
|
#define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1)
|
|
|
|
|
|
|
|
#define ownerid_hashval(id) \
|
|
|
|
((id) & OWNER_HASH_MASK)
|
|
|
|
#define ownerstr_hashval(clientid, ownername) \
|
|
|
|
(((clientid) + opaque_hashval((ownername.data), (ownername.len))) & OWNER_HASH_MASK)
|
|
|
|
|
|
|
|
static struct list_head ownerid_hashtbl[OWNER_HASH_SIZE];
|
|
|
|
static struct list_head ownerstr_hashtbl[OWNER_HASH_SIZE];
|
|
|
|
|
|
|
|
/* hash table for nfs4_file */
|
|
|
|
#define FILE_HASH_BITS 8
|
|
|
|
#define FILE_HASH_SIZE (1 << FILE_HASH_BITS)
|
2011-01-14 10:35:59 +01:00
|
|
|
|
2006-04-11 07:55:41 +02:00
|
|
|
/* hash table for (open)nfs4_stateid */
|
|
|
|
#define STATEID_HASH_BITS 10
|
|
|
|
#define STATEID_HASH_SIZE (1 << STATEID_HASH_BITS)
|
|
|
|
#define STATEID_HASH_MASK (STATEID_HASH_SIZE - 1)
|
|
|
|
|
|
|
|
#define file_hashval(x) \
|
|
|
|
hash_ptr(x, FILE_HASH_BITS)
|
|
|
|
#define stateid_hashval(owner_id, file_id) \
|
|
|
|
(((owner_id) + (file_id)) & STATEID_HASH_MASK)
|
|
|
|
|
|
|
|
static struct list_head file_hashtbl[FILE_HASH_SIZE];
|
|
|
|
static struct list_head stateid_hashtbl[STATEID_HASH_SIZE];
|
|
|
|
|
2010-08-07 15:21:41 +02:00
|
|
|
static void __nfs4_file_get_access(struct nfs4_file *fp, int oflag)
|
2010-07-08 17:02:09 +02:00
|
|
|
{
|
|
|
|
BUG_ON(!(fp->fi_fds[oflag] || fp->fi_fds[O_RDWR]));
|
|
|
|
atomic_inc(&fp->fi_access[oflag]);
|
|
|
|
}
|
|
|
|
|
2010-08-07 15:21:41 +02:00
|
|
|
static void nfs4_file_get_access(struct nfs4_file *fp, int oflag)
|
|
|
|
{
|
|
|
|
if (oflag == O_RDWR) {
|
|
|
|
__nfs4_file_get_access(fp, O_RDONLY);
|
|
|
|
__nfs4_file_get_access(fp, O_WRONLY);
|
|
|
|
} else
|
|
|
|
__nfs4_file_get_access(fp, oflag);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nfs4_file_put_fd(struct nfs4_file *fp, int oflag)
|
2010-07-08 17:02:09 +02:00
|
|
|
{
|
|
|
|
if (fp->fi_fds[oflag]) {
|
|
|
|
fput(fp->fi_fds[oflag]);
|
|
|
|
fp->fi_fds[oflag] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-07 15:21:41 +02:00
|
|
|
static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
|
2010-07-08 17:02:09 +02:00
|
|
|
{
|
|
|
|
if (atomic_dec_and_test(&fp->fi_access[oflag])) {
|
|
|
|
nfs4_file_put_fd(fp, O_RDWR);
|
|
|
|
nfs4_file_put_fd(fp, oflag);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-07 15:21:41 +02:00
|
|
|
static void nfs4_file_put_access(struct nfs4_file *fp, int oflag)
|
|
|
|
{
|
|
|
|
if (oflag == O_RDWR) {
|
|
|
|
__nfs4_file_put_access(fp, O_RDONLY);
|
|
|
|
__nfs4_file_put_access(fp, O_WRONLY);
|
|
|
|
} else
|
|
|
|
__nfs4_file_put_access(fp, oflag);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static struct nfs4_delegation *
|
|
|
|
alloc_init_deleg(struct nfs4_client *clp, struct nfs4_stateid *stp, struct svc_fh *current_fh, u32 type)
|
|
|
|
{
|
|
|
|
struct nfs4_delegation *dp;
|
|
|
|
struct nfs4_file *fp = stp->st_file;
|
|
|
|
|
|
|
|
dprintk("NFSD alloc_init_deleg\n");
|
2010-07-28 16:08:57 +02:00
|
|
|
/*
|
|
|
|
* Major work on the lease subsystem (for example, to support
|
|
|
|
* calbacks on stat) will be required before we can support
|
|
|
|
* write delegations properly.
|
|
|
|
*/
|
|
|
|
if (type != NFS4_OPEN_DELEGATE_READ)
|
|
|
|
return NULL;
|
2007-07-17 13:04:40 +02:00
|
|
|
if (fp->fi_had_conflict)
|
|
|
|
return NULL;
|
2007-07-17 13:04:39 +02:00
|
|
|
if (num_delegations > max_delegations)
|
2006-04-11 07:55:41 +02:00
|
|
|
return NULL;
|
2005-06-24 07:03:04 +02:00
|
|
|
dp = kmem_cache_alloc(deleg_slab, GFP_KERNEL);
|
|
|
|
if (dp == NULL)
|
2005-04-17 00:20:36 +02:00
|
|
|
return dp;
|
2006-04-11 07:55:41 +02:00
|
|
|
num_delegations++;
|
2005-06-24 07:04:17 +02:00
|
|
|
INIT_LIST_HEAD(&dp->dl_perfile);
|
|
|
|
INIT_LIST_HEAD(&dp->dl_perclnt);
|
2005-04-17 00:20:36 +02:00
|
|
|
INIT_LIST_HEAD(&dp->dl_recall_lru);
|
|
|
|
dp->dl_client = clp;
|
2005-06-24 07:03:10 +02:00
|
|
|
get_nfs4_file(fp);
|
2005-04-17 00:20:36 +02:00
|
|
|
dp->dl_file = fp;
|
|
|
|
dp->dl_type = type;
|
2010-04-22 22:21:39 +02:00
|
|
|
dp->dl_stateid.si_boot = boot_time;
|
2005-04-17 00:20:36 +02:00
|
|
|
dp->dl_stateid.si_stateownerid = current_delegid++;
|
|
|
|
dp->dl_stateid.si_fileid = 0;
|
|
|
|
dp->dl_stateid.si_generation = 0;
|
2009-02-02 23:30:51 +01:00
|
|
|
fh_copy_shallow(&dp->dl_fh, ¤t_fh->fh_handle);
|
2005-04-17 00:20:36 +02:00
|
|
|
dp->dl_time = 0;
|
|
|
|
atomic_set(&dp->dl_count, 1);
|
2010-03-03 20:52:55 +01:00
|
|
|
INIT_WORK(&dp->dl_recall.cb_work, nfsd4_do_callback_rpc);
|
2005-04-17 00:20:36 +02:00
|
|
|
return dp;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nfs4_put_delegation(struct nfs4_delegation *dp)
|
|
|
|
{
|
|
|
|
if (atomic_dec_and_test(&dp->dl_count)) {
|
|
|
|
dprintk("NFSD: freeing dp %p\n",dp);
|
2005-06-24 07:03:10 +02:00
|
|
|
put_nfs4_file(dp->dl_file);
|
2005-06-24 07:03:04 +02:00
|
|
|
kmem_cache_free(deleg_slab, dp);
|
2006-04-11 07:55:41 +02:00
|
|
|
num_delegations--;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-01 01:20:39 +01:00
|
|
|
static void nfs4_put_deleg_lease(struct nfs4_file *fp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2011-02-01 01:20:39 +01:00
|
|
|
if (atomic_dec_and_test(&fp->fi_delegees)) {
|
|
|
|
vfs_setlease(fp->fi_deleg_file, F_UNLCK, &fp->fi_lease);
|
|
|
|
fp->fi_lease = NULL;
|
2011-04-16 00:08:26 +02:00
|
|
|
fput(fp->fi_deleg_file);
|
2011-02-01 01:20:39 +01:00
|
|
|
fp->fi_deleg_file = NULL;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Called under the state lock. */
|
|
|
|
static void
|
|
|
|
unhash_delegation(struct nfs4_delegation *dp)
|
|
|
|
{
|
2005-06-24 07:04:17 +02:00
|
|
|
list_del_init(&dp->dl_perclnt);
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_lock(&recall_lock);
|
2011-02-07 22:53:46 +01:00
|
|
|
list_del_init(&dp->dl_perfile);
|
2005-04-17 00:20:36 +02:00
|
|
|
list_del_init(&dp->dl_recall_lru);
|
|
|
|
spin_unlock(&recall_lock);
|
2011-02-01 01:20:39 +01:00
|
|
|
nfs4_put_deleg_lease(dp->dl_file);
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_put_delegation(dp);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SETCLIENTID state
|
|
|
|
*/
|
|
|
|
|
2010-05-11 23:13:04 +02:00
|
|
|
/* client_lock protects the client lru list and session hash table */
|
2010-05-11 23:12:26 +02:00
|
|
|
static DEFINE_SPINLOCK(client_lock);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Hash tables for nfs4_clientid state */
|
|
|
|
#define CLIENT_HASH_BITS 4
|
|
|
|
#define CLIENT_HASH_SIZE (1 << CLIENT_HASH_BITS)
|
|
|
|
#define CLIENT_HASH_MASK (CLIENT_HASH_SIZE - 1)
|
|
|
|
|
|
|
|
#define clientid_hashval(id) \
|
|
|
|
((id) & CLIENT_HASH_MASK)
|
2005-06-24 07:03:52 +02:00
|
|
|
#define clientstr_hashval(name) \
|
|
|
|
(opaque_hashval((name), 8) & CLIENT_HASH_MASK)
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* reclaim_str_hashtbl[] holds known client info from previous reset/reboot
|
|
|
|
* used in reboot/reset lease grace period processing
|
|
|
|
*
|
|
|
|
* conf_id_hashtbl[], and conf_str_hashtbl[] hold confirmed
|
|
|
|
* setclientid_confirmed info.
|
|
|
|
*
|
|
|
|
* unconf_str_hastbl[] and unconf_id_hashtbl[] hold unconfirmed
|
|
|
|
* setclientid info.
|
|
|
|
*
|
|
|
|
* client_lru holds client queue ordered by nfs4_client.cl_time
|
|
|
|
* for lease renewal.
|
|
|
|
*
|
|
|
|
* close_lru holds (open) stateowner queue ordered by nfs4_stateowner.so_time
|
|
|
|
* for last close replay.
|
|
|
|
*/
|
|
|
|
static struct list_head reclaim_str_hashtbl[CLIENT_HASH_SIZE];
|
|
|
|
static int reclaim_str_hashtbl_size = 0;
|
|
|
|
static struct list_head conf_id_hashtbl[CLIENT_HASH_SIZE];
|
|
|
|
static struct list_head conf_str_hashtbl[CLIENT_HASH_SIZE];
|
|
|
|
static struct list_head unconf_str_hashtbl[CLIENT_HASH_SIZE];
|
|
|
|
static struct list_head unconf_id_hashtbl[CLIENT_HASH_SIZE];
|
|
|
|
static struct list_head client_lru;
|
|
|
|
static struct list_head close_lru;
|
|
|
|
|
2010-07-08 17:02:09 +02: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 void
|
|
|
|
set_access(unsigned int *access, unsigned long bmap) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
*access = 0;
|
|
|
|
for (i = 1; i < 4; i++) {
|
|
|
|
if (test_bit(i, &bmap))
|
|
|
|
*access |= i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
set_deny(unsigned int *deny, unsigned long bmap) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
*deny = 0;
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
if (test_bit(i, &bmap))
|
|
|
|
*deny |= i ;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
test_share(struct nfs4_stateid *stp, struct nfsd4_open *open) {
|
|
|
|
unsigned int access, deny;
|
|
|
|
|
|
|
|
set_access(&access, stp->st_access_bmap);
|
|
|
|
set_deny(&deny, stp->st_deny_bmap);
|
|
|
|
if ((access & open->op_share_deny) || (deny & open->op_share_access))
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nfs4_access_to_omode(u32 access)
|
|
|
|
{
|
2010-09-02 21:23:16 +02:00
|
|
|
switch (access & NFS4_SHARE_ACCESS_BOTH) {
|
2010-07-08 17:02:09 +02:00
|
|
|
case NFS4_SHARE_ACCESS_READ:
|
|
|
|
return O_RDONLY;
|
|
|
|
case NFS4_SHARE_ACCESS_WRITE:
|
|
|
|
return O_WRONLY;
|
|
|
|
case NFS4_SHARE_ACCESS_BOTH:
|
|
|
|
return O_RDWR;
|
|
|
|
}
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
2011-03-03 05:48:33 +01:00
|
|
|
static void unhash_generic_stateid(struct nfs4_stateid *stp)
|
|
|
|
{
|
|
|
|
list_del(&stp->st_hash);
|
|
|
|
list_del(&stp->st_perfile);
|
|
|
|
list_del(&stp->st_perstateowner);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_generic_stateid(struct nfs4_stateid *stp)
|
|
|
|
{
|
2011-06-27 22:57:12 +02:00
|
|
|
int i;
|
2011-03-03 00:01:35 +01:00
|
|
|
|
2011-03-28 09:15:09 +02:00
|
|
|
if (stp->st_access_bmap) {
|
2011-06-27 22:57:12 +02:00
|
|
|
for (i = 1; i < 4; i++) {
|
|
|
|
if (test_bit(i, &stp->st_access_bmap))
|
|
|
|
nfs4_file_put_access(stp->st_file,
|
|
|
|
nfs4_access_to_omode(i));
|
|
|
|
}
|
2011-03-28 09:15:09 +02:00
|
|
|
}
|
2011-04-18 17:48:55 +02:00
|
|
|
put_nfs4_file(stp->st_file);
|
2011-03-03 05:48:33 +01:00
|
|
|
kmem_cache_free(stateid_slab, stp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void release_lock_stateid(struct nfs4_stateid *stp)
|
|
|
|
{
|
|
|
|
struct file *file;
|
|
|
|
|
|
|
|
unhash_generic_stateid(stp);
|
|
|
|
file = find_any_file(stp->st_file);
|
|
|
|
if (file)
|
|
|
|
locks_remove_posix(file, (fl_owner_t)stp->st_stateowner);
|
|
|
|
free_generic_stateid(stp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void unhash_lockowner(struct nfs4_stateowner *sop)
|
|
|
|
{
|
|
|
|
struct nfs4_stateid *stp;
|
|
|
|
|
|
|
|
list_del(&sop->so_idhash);
|
|
|
|
list_del(&sop->so_strhash);
|
|
|
|
list_del(&sop->so_perstateid);
|
|
|
|
while (!list_empty(&sop->so_stateids)) {
|
|
|
|
stp = list_first_entry(&sop->so_stateids,
|
|
|
|
struct nfs4_stateid, st_perstateowner);
|
|
|
|
release_lock_stateid(stp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void release_lockowner(struct nfs4_stateowner *sop)
|
|
|
|
{
|
|
|
|
unhash_lockowner(sop);
|
|
|
|
nfs4_put_stateowner(sop);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
release_stateid_lockowners(struct nfs4_stateid *open_stp)
|
|
|
|
{
|
|
|
|
struct nfs4_stateowner *lock_sop;
|
|
|
|
|
|
|
|
while (!list_empty(&open_stp->st_lockowners)) {
|
|
|
|
lock_sop = list_entry(open_stp->st_lockowners.next,
|
|
|
|
struct nfs4_stateowner, so_perstateid);
|
|
|
|
/* list_del(&open_stp->st_lockowners); */
|
|
|
|
BUG_ON(lock_sop->so_is_open_owner);
|
|
|
|
release_lockowner(lock_sop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-11 20:27:17 +01:00
|
|
|
static void release_open_stateid(struct nfs4_stateid *stp)
|
|
|
|
{
|
|
|
|
unhash_generic_stateid(stp);
|
|
|
|
release_stateid_lockowners(stp);
|
|
|
|
free_generic_stateid(stp);
|
|
|
|
}
|
|
|
|
|
2009-01-11 21:24:04 +01:00
|
|
|
static void unhash_openowner(struct nfs4_stateowner *sop)
|
2009-01-11 20:37:31 +01:00
|
|
|
{
|
|
|
|
struct nfs4_stateid *stp;
|
|
|
|
|
|
|
|
list_del(&sop->so_idhash);
|
|
|
|
list_del(&sop->so_strhash);
|
2009-01-11 21:24:04 +01:00
|
|
|
list_del(&sop->so_perclient);
|
|
|
|
list_del(&sop->so_perstateid); /* XXX: necessary? */
|
2009-01-11 20:37:31 +01:00
|
|
|
while (!list_empty(&sop->so_stateids)) {
|
2009-01-11 21:24:04 +01:00
|
|
|
stp = list_first_entry(&sop->so_stateids,
|
|
|
|
struct nfs4_stateid, st_perstateowner);
|
|
|
|
release_open_stateid(stp);
|
2009-01-11 20:37:31 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-11 21:24:04 +01:00
|
|
|
static void release_openowner(struct nfs4_stateowner *sop)
|
2009-01-11 20:37:31 +01:00
|
|
|
{
|
2009-01-11 21:24:04 +01:00
|
|
|
unhash_openowner(sop);
|
2009-01-11 20:37:31 +01:00
|
|
|
list_del(&sop->so_close_lru);
|
|
|
|
nfs4_put_stateowner(sop);
|
|
|
|
}
|
|
|
|
|
2009-04-03 07:27:52 +02:00
|
|
|
#define SESSION_HASH_SIZE 512
|
|
|
|
static struct list_head sessionid_hashtbl[SESSION_HASH_SIZE];
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
hash_sessionid(struct nfs4_sessionid *sessionid)
|
|
|
|
{
|
|
|
|
struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
|
|
|
|
|
|
|
|
return sid->sequence % SESSION_HASH_SIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
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]);
|
|
|
|
}
|
|
|
|
|
2009-04-03 07:28:28 +02: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 14:45:01 +02: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 14:45:04 +02:00
|
|
|
static void
|
|
|
|
free_session_slots(struct nfsd4_session *ses)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ses->se_fchannel.maxreqs; i++)
|
|
|
|
kfree(ses->se_slots[i]);
|
|
|
|
}
|
|
|
|
|
2009-08-28 14:45:01 +02:00
|
|
|
/*
|
2009-10-25 02:52:16 +02:00
|
|
|
* We don't actually need to cache the rpc and session headers, so we
|
|
|
|
* can allocate a little less for each slot:
|
|
|
|
*/
|
|
|
|
static inline int slot_bytes(struct nfsd4_channel_attrs *ca)
|
|
|
|
{
|
|
|
|
return ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
|
|
|
|
}
|
|
|
|
|
2010-09-27 23:12:05 +02:00
|
|
|
static int nfsd4_sanitize_slot_size(u32 size)
|
2009-04-03 07:28:28 +02:00
|
|
|
{
|
2010-09-27 23:12:05 +02:00
|
|
|
size -= NFSD_MIN_HDR_SEQ_SZ; /* We don't cache the rpc header */
|
|
|
|
size = min_t(u32, size, NFSD_SLOT_CACHE_SIZE);
|
2009-04-03 07:28:28 +02:00
|
|
|
|
2010-09-27 23:12:05 +02:00
|
|
|
return size;
|
|
|
|
}
|
2009-04-03 07:28:28 +02:00
|
|
|
|
2010-09-27 23:12:05 +02:00
|
|
|
/*
|
|
|
|
* XXX: If we run out of reserved DRC memory we could (up to a point)
|
2009-08-28 14:45:01 +02:00
|
|
|
* re-negotiate active sessions and reduce their slot usage to make
|
|
|
|
* rooom for new connections. For now we just fail the create session.
|
2009-04-03 07:28:28 +02:00
|
|
|
*/
|
2010-09-27 23:12:05 +02:00
|
|
|
static int nfsd4_get_drc_mem(int slotsize, u32 num)
|
2009-04-03 07:28:28 +02:00
|
|
|
{
|
2010-09-27 23:12:05 +02:00
|
|
|
int avail;
|
2009-04-03 07:28:28 +02:00
|
|
|
|
2010-09-27 23:12:05 +02:00
|
|
|
num = min_t(u32, num, NFSD_MAX_SLOTS_PER_SESSION);
|
2009-06-16 03:19:38 +02:00
|
|
|
|
2010-09-27 23:12:05 +02:00
|
|
|
spin_lock(&nfsd_drc_lock);
|
|
|
|
avail = min_t(int, NFSD_MAX_MEM_PER_SESSION,
|
|
|
|
nfsd_drc_max_mem - nfsd_drc_mem_used);
|
|
|
|
num = min_t(int, num, avail / slotsize);
|
|
|
|
nfsd_drc_mem_used += num * slotsize;
|
|
|
|
spin_unlock(&nfsd_drc_lock);
|
2009-04-03 07:28:28 +02:00
|
|
|
|
2010-09-27 23:12:05 +02:00
|
|
|
return num;
|
|
|
|
}
|
2009-04-03 07:28:28 +02:00
|
|
|
|
2010-09-27 23:12:05 +02:00
|
|
|
static void nfsd4_put_drc_mem(int slotsize, int num)
|
|
|
|
{
|
2009-06-24 21:37:45 +02:00
|
|
|
spin_lock(&nfsd_drc_lock);
|
2010-09-27 23:12:05 +02:00
|
|
|
nfsd_drc_mem_used -= slotsize * num;
|
2009-06-24 21:37:45 +02:00
|
|
|
spin_unlock(&nfsd_drc_lock);
|
2010-09-27 23:12:05 +02:00
|
|
|
}
|
2009-04-03 07:28:28 +02:00
|
|
|
|
2010-09-27 23:12:05 +02:00
|
|
|
static struct nfsd4_session *alloc_session(int slotsize, int numslots)
|
|
|
|
{
|
|
|
|
struct nfsd4_session *new;
|
|
|
|
int mem, i;
|
2009-08-28 14:45:01 +02:00
|
|
|
|
2010-09-27 23:12:05 +02: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 07:28:28 +02:00
|
|
|
|
2010-09-27 23:12:05 +02:00
|
|
|
new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
|
|
|
|
if (!new)
|
|
|
|
return NULL;
|
2009-08-28 14:45:04 +02:00
|
|
|
/* allocate each struct nfsd4_slot and data cache in one piece */
|
2010-09-27 23:12:05 +02:00
|
|
|
for (i = 0; i < numslots; i++) {
|
|
|
|
mem = sizeof(struct nfsd4_slot) + slotsize;
|
|
|
|
new->se_slots[i] = kzalloc(mem, GFP_KERNEL);
|
|
|
|
if (!new->se_slots[i])
|
2009-08-28 14:45:04 +02:00
|
|
|
goto out_free;
|
|
|
|
}
|
2010-09-27 23:12:05 +02:00
|
|
|
return new;
|
|
|
|
out_free:
|
|
|
|
while (i--)
|
|
|
|
kfree(new->se_slots[i]);
|
|
|
|
kfree(new);
|
|
|
|
return NULL;
|
2009-04-03 07:28:28 +02:00
|
|
|
}
|
|
|
|
|
2010-09-27 23:12:05 +02:00
|
|
|
static void init_forechannel_attrs(struct nfsd4_channel_attrs *new, struct nfsd4_channel_attrs *req, int numslots, int slotsize)
|
2009-04-03 07:28:28 +02:00
|
|
|
{
|
2010-09-27 23:12:05 +02:00
|
|
|
u32 maxrpc = nfsd_serv->sv_max_mesg;
|
2009-04-03 07:28:28 +02:00
|
|
|
|
2010-09-27 23:12:05 +02:00
|
|
|
new->maxreqs = numslots;
|
2011-03-10 10:43:37 +01:00
|
|
|
new->maxresp_cached = min_t(u32, req->maxresp_cached,
|
|
|
|
slotsize + NFSD_MIN_HDR_SEQ_SZ);
|
2010-09-27 23:12:05 +02:00
|
|
|
new->maxreq_sz = min_t(u32, req->maxreq_sz, maxrpc);
|
|
|
|
new->maxresp_sz = min_t(u32, req->maxresp_sz, maxrpc);
|
|
|
|
new->maxops = min_t(u32, req->maxops, NFSD_MAX_OPS_PER_COMPOUND);
|
|
|
|
}
|
2009-04-03 07:28:28 +02:00
|
|
|
|
2010-06-07 00:37:16 +02:00
|
|
|
static void free_conn(struct nfsd4_conn *c)
|
|
|
|
{
|
|
|
|
svc_xprt_put(c->cn_xprt);
|
|
|
|
kfree(c);
|
|
|
|
}
|
2009-04-03 07:28:28 +02:00
|
|
|
|
2010-06-07 00:37:16 +02: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 07:28:28 +02:00
|
|
|
|
2010-06-07 00:37:16 +02:00
|
|
|
spin_lock(&clp->cl_lock);
|
|
|
|
if (!list_empty(&c->cn_persession)) {
|
|
|
|
list_del(&c->cn_persession);
|
|
|
|
free_conn(c);
|
|
|
|
}
|
|
|
|
spin_unlock(&clp->cl_lock);
|
2010-11-18 14:34:12 +01:00
|
|
|
nfsd4_probe_callback(clp);
|
2010-06-07 00:37:16 +02:00
|
|
|
}
|
2009-04-03 07:28:28 +02:00
|
|
|
|
2010-06-15 23:34:11 +02:00
|
|
|
static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
|
2010-06-07 00:12:14 +02:00
|
|
|
{
|
|
|
|
struct nfsd4_conn *conn;
|
2009-04-03 07:28:28 +02:00
|
|
|
|
2010-06-07 00:12:14 +02:00
|
|
|
conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
|
|
|
|
if (!conn)
|
2010-09-29 21:29:32 +02:00
|
|
|
return NULL;
|
2010-06-07 00:12:14 +02:00
|
|
|
svc_xprt_get(rqstp->rq_xprt);
|
|
|
|
conn->cn_xprt = rqstp->rq_xprt;
|
2010-06-15 23:34:11 +02:00
|
|
|
conn->cn_flags = flags;
|
2010-09-29 21:29:32 +02:00
|
|
|
INIT_LIST_HEAD(&conn->cn_xpt_user.list);
|
|
|
|
return conn;
|
|
|
|
}
|
2009-08-28 14:45:01 +02:00
|
|
|
|
2010-09-29 22:11:06 +02: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 07:28:28 +02:00
|
|
|
}
|
|
|
|
|
2010-09-29 21:29:32 +02:00
|
|
|
static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
|
2009-08-28 14:45:04 +02:00
|
|
|
{
|
2010-09-29 21:29:32 +02:00
|
|
|
struct nfs4_client *clp = ses->se_client;
|
2009-08-28 14:45:04 +02:00
|
|
|
|
2010-06-07 00:12:14 +02:00
|
|
|
spin_lock(&clp->cl_lock);
|
2010-09-29 22:11:06 +02:00
|
|
|
__nfsd4_hash_conn(conn, ses);
|
2010-06-07 00:12:14 +02:00
|
|
|
spin_unlock(&clp->cl_lock);
|
2009-08-28 14:45:04 +02:00
|
|
|
}
|
|
|
|
|
2010-10-26 16:07:17 +02:00
|
|
|
static int nfsd4_register_conn(struct nfsd4_conn *conn)
|
2009-10-25 02:52:16 +02:00
|
|
|
{
|
2010-06-07 00:37:16 +02:00
|
|
|
conn->cn_xpt_user.callback = nfsd4_conn_lost;
|
2010-10-26 16:07:17 +02:00
|
|
|
return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
|
2009-10-25 02:52:16 +02:00
|
|
|
}
|
|
|
|
|
2010-10-05 05:12:59 +02:00
|
|
|
static __be32 nfsd4_new_conn(struct svc_rqst *rqstp, struct nfsd4_session *ses, u32 dir)
|
2009-04-03 07:28:28 +02:00
|
|
|
{
|
2010-09-29 21:29:32 +02:00
|
|
|
struct nfsd4_conn *conn;
|
2010-10-26 16:07:17 +02:00
|
|
|
int ret;
|
2009-04-03 07:28:28 +02:00
|
|
|
|
2010-10-05 05:12:59 +02:00
|
|
|
conn = alloc_conn(rqstp, dir);
|
2010-09-29 21:29:32 +02:00
|
|
|
if (!conn)
|
|
|
|
return nfserr_jukebox;
|
|
|
|
nfsd4_hash_conn(conn, ses);
|
2010-10-26 16:07:17 +02:00
|
|
|
ret = nfsd4_register_conn(conn);
|
|
|
|
if (ret)
|
|
|
|
/* oops; xprt is already down: */
|
|
|
|
nfsd4_conn_lost(&conn->cn_xpt_user);
|
2010-06-07 00:12:14 +02:00
|
|
|
return nfs_ok;
|
|
|
|
}
|
2009-04-03 07:28:28 +02:00
|
|
|
|
2010-10-05 05:12:59 +02:00
|
|
|
static __be32 nfsd4_new_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_session *ses)
|
|
|
|
{
|
|
|
|
u32 dir = NFS4_CDFC4_FORE;
|
|
|
|
|
|
|
|
if (ses->se_flags & SESSION4_BACK_CHAN)
|
|
|
|
dir |= NFS4_CDFC4_BACK;
|
|
|
|
|
|
|
|
return nfsd4_new_conn(rqstp, ses, dir);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* must be called under client_lock */
|
2010-06-07 00:37:16 +02:00
|
|
|
static void nfsd4_del_conns(struct nfsd4_session *s)
|
2010-06-07 00:12:14 +02:00
|
|
|
{
|
2010-06-07 00:37:16 +02:00
|
|
|
struct nfs4_client *clp = s->se_client;
|
|
|
|
struct nfsd4_conn *c;
|
2009-04-03 07:28:28 +02:00
|
|
|
|
2010-06-07 00:37:16 +02: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 14:45:04 +02:00
|
|
|
|
2010-06-07 00:37:16 +02:00
|
|
|
unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
|
|
|
|
free_conn(c);
|
2009-04-03 07:28:28 +02:00
|
|
|
|
2010-06-07 00:37:16 +02:00
|
|
|
spin_lock(&clp->cl_lock);
|
|
|
|
}
|
|
|
|
spin_unlock(&clp->cl_lock);
|
2010-06-07 00:12:14 +02:00
|
|
|
}
|
2009-04-03 07:28:28 +02:00
|
|
|
|
2010-06-07 00:12:14 +02:00
|
|
|
void free_session(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct nfsd4_session *ses;
|
|
|
|
int mem;
|
|
|
|
|
|
|
|
ses = container_of(kref, struct nfsd4_session, se_ref);
|
2010-06-07 00:37:16 +02:00
|
|
|
nfsd4_del_conns(ses);
|
2010-06-07 00:12:14 +02:00
|
|
|
spin_lock(&nfsd_drc_lock);
|
|
|
|
mem = ses->se_fchannel.maxreqs * slot_bytes(&ses->se_fchannel);
|
|
|
|
nfsd_drc_mem_used -= mem;
|
|
|
|
spin_unlock(&nfsd_drc_lock);
|
|
|
|
free_session_slots(ses);
|
|
|
|
kfree(ses);
|
|
|
|
}
|
|
|
|
|
2010-06-15 01:01:57 +02:00
|
|
|
static struct nfsd4_session *alloc_init_session(struct svc_rqst *rqstp, struct nfs4_client *clp, struct nfsd4_create_session *cses)
|
2010-09-27 23:12:05 +02:00
|
|
|
{
|
|
|
|
struct nfsd4_session *new;
|
|
|
|
struct nfsd4_channel_attrs *fchan = &cses->fore_channel;
|
|
|
|
int numslots, slotsize;
|
2010-06-07 00:12:14 +02:00
|
|
|
int status;
|
2010-09-27 23:12:05 +02:00
|
|
|
int idx;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
slotsize = nfsd4_sanitize_slot_size(fchan->maxresp_cached);
|
|
|
|
numslots = nfsd4_get_drc_mem(slotsize, fchan->maxreqs);
|
2010-11-11 11:03:50 +01:00
|
|
|
if (numslots < 1)
|
|
|
|
return NULL;
|
2010-09-27 23:12:05 +02:00
|
|
|
|
|
|
|
new = alloc_session(slotsize, numslots);
|
|
|
|
if (!new) {
|
|
|
|
nfsd4_put_drc_mem(slotsize, fchan->maxreqs);
|
2010-06-15 01:01:57 +02:00
|
|
|
return NULL;
|
2009-08-28 14:45:04 +02:00
|
|
|
}
|
2010-09-27 23:12:05 +02:00
|
|
|
init_forechannel_attrs(&new->se_fchannel, fchan, numslots, slotsize);
|
2009-08-28 14:45:04 +02:00
|
|
|
|
2009-04-03 07:28:28 +02:00
|
|
|
new->se_client = clp;
|
|
|
|
gen_sessionid(new);
|
|
|
|
|
2010-06-07 00:12:14 +02:00
|
|
|
INIT_LIST_HEAD(&new->se_conns);
|
|
|
|
|
2010-06-15 01:01:57 +02:00
|
|
|
new->se_cb_seq_nr = 1;
|
2009-04-03 07:28:28 +02:00
|
|
|
new->se_flags = cses->flags;
|
2010-10-19 23:31:50 +02:00
|
|
|
new->se_cb_prog = cses->callback_prog;
|
2009-04-03 07:28:28 +02:00
|
|
|
kref_init(&new->se_ref);
|
2010-09-27 23:12:05 +02:00
|
|
|
idx = hash_sessionid(&new->se_sessionid);
|
2010-05-11 23:12:26 +02:00
|
|
|
spin_lock(&client_lock);
|
2009-04-03 07:28:28 +02:00
|
|
|
list_add(&new->se_hash, &sessionid_hashtbl[idx]);
|
2010-06-15 20:22:37 +02:00
|
|
|
spin_lock(&clp->cl_lock);
|
2009-04-03 07:28:28 +02:00
|
|
|
list_add(&new->se_perclnt, &clp->cl_sessions);
|
2010-06-15 20:22:37 +02:00
|
|
|
spin_unlock(&clp->cl_lock);
|
2010-05-11 23:12:26 +02:00
|
|
|
spin_unlock(&client_lock);
|
2009-04-03 07:28:28 +02:00
|
|
|
|
2010-10-05 05:12:59 +02:00
|
|
|
status = nfsd4_new_conn_from_crses(rqstp, new);
|
2010-06-15 01:01:57 +02:00
|
|
|
/* whoops: benny points out, status is ignored! (err, or bogus) */
|
2010-06-07 00:12:14 +02:00
|
|
|
if (status) {
|
|
|
|
free_session(&new->se_ref);
|
2010-06-15 01:01:57 +02:00
|
|
|
return NULL;
|
2010-06-07 00:12:14 +02:00
|
|
|
}
|
2010-06-15 23:25:45 +02:00
|
|
|
if (cses->flags & SESSION4_BACK_CHAN) {
|
2010-06-15 04:26:31 +02:00
|
|
|
struct sockaddr *sa = svc_addr(rqstp);
|
2010-06-15 23:25:45 +02: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 04:26:31 +02:00
|
|
|
rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
|
|
|
|
clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
|
|
|
|
}
|
2010-06-15 23:25:45 +02:00
|
|
|
nfsd4_probe_callback(clp);
|
2010-06-15 01:01:57 +02:00
|
|
|
return new;
|
2009-04-03 07:28:28 +02:00
|
|
|
}
|
|
|
|
|
2010-05-11 23:12:26 +02:00
|
|
|
/* caller must hold client_lock */
|
2009-04-03 07:27:52 +02:00
|
|
|
static struct nfsd4_session *
|
|
|
|
find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid)
|
|
|
|
{
|
|
|
|
struct nfsd4_session *elem;
|
|
|
|
int idx;
|
|
|
|
|
|
|
|
dump_sessionid(__func__, sessionid);
|
|
|
|
idx = hash_sessionid(sessionid);
|
|
|
|
/* Search in the appropriate list */
|
|
|
|
list_for_each_entry(elem, &sessionid_hashtbl[idx], se_hash) {
|
|
|
|
if (!memcmp(elem->se_sessionid.data, sessionid->data,
|
|
|
|
NFS4_MAX_SESSIONID_LEN)) {
|
|
|
|
return elem;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
dprintk("%s: session not found\n", __func__);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-05-11 23:12:26 +02:00
|
|
|
/* caller must hold client_lock */
|
2009-04-03 07:27:43 +02:00
|
|
|
static void
|
2009-04-03 07:27:52 +02:00
|
|
|
unhash_session(struct nfsd4_session *ses)
|
2009-04-03 07:27:43 +02:00
|
|
|
{
|
|
|
|
list_del(&ses->se_hash);
|
2010-06-15 20:22:37 +02:00
|
|
|
spin_lock(&ses->se_client->cl_lock);
|
2009-04-03 07:27:43 +02:00
|
|
|
list_del(&ses->se_perclnt);
|
2010-06-15 20:22:37 +02:00
|
|
|
spin_unlock(&ses->se_client->cl_lock);
|
2009-04-03 07:27:52 +02:00
|
|
|
}
|
|
|
|
|
2010-05-11 23:13:04 +02:00
|
|
|
/* must be called under the client_lock */
|
2005-04-17 00:20:36 +02:00
|
|
|
static inline void
|
2010-05-11 23:13:04 +02:00
|
|
|
renew_client_locked(struct nfs4_client *clp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2010-05-11 23:13:41 +02:00
|
|
|
if (is_client_expired(clp)) {
|
|
|
|
dprintk("%s: client (clientid %08x/%08x) already expired\n",
|
|
|
|
__func__,
|
|
|
|
clp->cl_clientid.cl_boot,
|
|
|
|
clp->cl_clientid.cl_id);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Move client to the end to the LRU list.
|
|
|
|
*/
|
|
|
|
dprintk("renewing client (clientid %08x/%08x)\n",
|
|
|
|
clp->cl_clientid.cl_boot,
|
|
|
|
clp->cl_clientid.cl_id);
|
|
|
|
list_move_tail(&clp->cl_lru, &client_lru);
|
|
|
|
clp->cl_time = get_seconds();
|
|
|
|
}
|
|
|
|
|
2010-05-11 23:13:04 +02:00
|
|
|
static inline void
|
|
|
|
renew_client(struct nfs4_client *clp)
|
|
|
|
{
|
|
|
|
spin_lock(&client_lock);
|
|
|
|
renew_client_locked(clp);
|
|
|
|
spin_unlock(&client_lock);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
|
|
|
|
static int
|
|
|
|
STALE_CLIENTID(clientid_t *clid)
|
|
|
|
{
|
|
|
|
if (clid->cl_boot == boot_time)
|
|
|
|
return 0;
|
2009-04-03 07:28:50 +02:00
|
|
|
dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
|
|
|
|
clid->cl_boot, clid->cl_id, boot_time);
|
2005-04-17 00:20:36 +02: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 04:07:08 +01:00
|
|
|
static struct nfs4_client *alloc_client(struct xdr_netobj name)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct nfs4_client *clp;
|
|
|
|
|
2007-11-22 04:07:08 +01:00
|
|
|
clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
|
|
|
|
if (clp == NULL)
|
|
|
|
return NULL;
|
|
|
|
clp->cl_name.data = kmalloc(name.len, GFP_KERNEL);
|
|
|
|
if (clp->cl_name.data == NULL) {
|
|
|
|
kfree(clp);
|
|
|
|
return NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2007-11-22 04:07:08 +01:00
|
|
|
memcpy(clp->cl_name.data, name.data, name.len);
|
|
|
|
clp->cl_name.len = name.len;
|
2005-04-17 00:20:36 +02:00
|
|
|
return clp;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
free_client(struct nfs4_client *clp)
|
|
|
|
{
|
2010-10-13 01:55:25 +02: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);
|
|
|
|
nfsd4_put_session(ses);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
if (clp->cl_cred.cr_group_info)
|
|
|
|
put_group_info(clp->cl_cred.cr_group_info);
|
2008-12-23 22:17:15 +01:00
|
|
|
kfree(clp->cl_principal);
|
2005-04-17 00:20:36 +02:00
|
|
|
kfree(clp->cl_name.data);
|
|
|
|
kfree(clp);
|
|
|
|
}
|
|
|
|
|
2010-05-11 23:13:54 +02:00
|
|
|
void
|
|
|
|
release_session_client(struct nfsd4_session *session)
|
|
|
|
{
|
|
|
|
struct nfs4_client *clp = session->se_client;
|
|
|
|
|
|
|
|
if (!atomic_dec_and_lock(&clp->cl_refcount, &client_lock))
|
|
|
|
return;
|
|
|
|
if (is_client_expired(clp)) {
|
|
|
|
free_client(clp);
|
|
|
|
session->se_client = NULL;
|
|
|
|
} else
|
|
|
|
renew_client_locked(clp);
|
|
|
|
spin_unlock(&client_lock);
|
|
|
|
}
|
|
|
|
|
2010-05-11 23:13:16 +02:00
|
|
|
/* must be called under the client_lock */
|
|
|
|
static inline void
|
|
|
|
unhash_client_locked(struct nfs4_client *clp)
|
|
|
|
{
|
2010-10-13 01:55:25 +02:00
|
|
|
struct nfsd4_session *ses;
|
|
|
|
|
2010-05-11 23:13:41 +02:00
|
|
|
mark_client_expired(clp);
|
2010-05-11 23:13:16 +02:00
|
|
|
list_del(&clp->cl_lru);
|
2010-06-15 20:22:37 +02:00
|
|
|
spin_lock(&clp->cl_lock);
|
2010-10-13 01:55:25 +02:00
|
|
|
list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
|
|
|
|
list_del_init(&ses->se_hash);
|
2010-06-15 20:22:37 +02:00
|
|
|
spin_unlock(&clp->cl_lock);
|
2010-05-11 23:13:16 +02:00
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static void
|
|
|
|
expire_client(struct nfs4_client *clp)
|
|
|
|
{
|
|
|
|
struct nfs4_stateowner *sop;
|
|
|
|
struct nfs4_delegation *dp;
|
|
|
|
struct list_head reaplist;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&reaplist);
|
|
|
|
spin_lock(&recall_lock);
|
2005-06-24 07:04:17 +02:00
|
|
|
while (!list_empty(&clp->cl_delegations)) {
|
|
|
|
dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
|
|
|
|
list_del_init(&dp->dl_perclnt);
|
2005-04-17 00:20:36 +02:00
|
|
|
list_move(&dp->dl_recall_lru, &reaplist);
|
|
|
|
}
|
|
|
|
spin_unlock(&recall_lock);
|
|
|
|
while (!list_empty(&reaplist)) {
|
|
|
|
dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
|
|
|
|
list_del_init(&dp->dl_recall_lru);
|
|
|
|
unhash_delegation(dp);
|
|
|
|
}
|
2005-06-24 07:04:17 +02:00
|
|
|
while (!list_empty(&clp->cl_openowners)) {
|
|
|
|
sop = list_entry(clp->cl_openowners.next, struct nfs4_stateowner, so_perclient);
|
2009-01-11 21:24:04 +01:00
|
|
|
release_openowner(sop);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2010-06-05 02:04:45 +02:00
|
|
|
nfsd4_shutdown_callback(clp);
|
2010-05-11 23:13:16 +02:00
|
|
|
if (clp->cl_cb_conn.cb_xprt)
|
|
|
|
svc_xprt_put(clp->cl_cb_conn.cb_xprt);
|
2010-05-11 23:13:04 +02:00
|
|
|
list_del(&clp->cl_idhash);
|
|
|
|
list_del(&clp->cl_strhash);
|
2010-05-11 23:12:39 +02:00
|
|
|
spin_lock(&client_lock);
|
2010-05-11 23:13:16 +02:00
|
|
|
unhash_client_locked(clp);
|
2010-05-11 23:13:29 +02:00
|
|
|
if (atomic_read(&clp->cl_refcount) == 0)
|
|
|
|
free_client(clp);
|
2010-05-11 23:12:39 +02:00
|
|
|
spin_unlock(&client_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-11-22 04:07:08 +01: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 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-11-22 04:07:08 +01:00
|
|
|
static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
|
|
|
|
{
|
2005-04-17 00:20:36 +02:00
|
|
|
target->cl_clientid.cl_boot = source->cl_clientid.cl_boot;
|
|
|
|
target->cl_clientid.cl_id = source->cl_clientid.cl_id;
|
|
|
|
}
|
|
|
|
|
2007-11-22 04:07:08 +01:00
|
|
|
static void copy_cred(struct svc_cred *target, struct svc_cred *source)
|
|
|
|
{
|
2005-04-17 00:20:36 +02: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);
|
|
|
|
}
|
|
|
|
|
2007-11-22 04:07:08 +01:00
|
|
|
static int same_name(const char *n1, const char *n2)
|
2007-07-26 23:04:54 +02:00
|
|
|
{
|
2005-06-24 07:03:52 +02:00
|
|
|
return 0 == memcmp(n1, n2, HEXDIR_LEN);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2007-07-26 23:04:54 +02:00
|
|
|
same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
|
|
|
|
{
|
|
|
|
return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2007-07-26 23:04:54 +02: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 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* XXX what about NGROUP */
|
|
|
|
static int
|
2007-07-26 23:04:54 +02:00
|
|
|
same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
|
|
|
|
{
|
|
|
|
return cr1->cr_uid == cr2->cr_uid;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-11-22 03:58:56 +01:00
|
|
|
static void gen_clid(struct nfs4_client *clp)
|
|
|
|
{
|
|
|
|
static u32 current_clientid = 1;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
clp->cl_clientid.cl_boot = boot_time;
|
|
|
|
clp->cl_clientid.cl_id = current_clientid++;
|
|
|
|
}
|
|
|
|
|
2007-11-20 02:31:04 +01:00
|
|
|
static void gen_confirm(struct nfs4_client *clp)
|
|
|
|
{
|
|
|
|
static u32 i;
|
|
|
|
u32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
p = (u32 *)clp->cl_confirm.data;
|
2007-11-20 02:31:04 +01:00
|
|
|
*p++ = get_seconds();
|
|
|
|
*p++ = i++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2009-09-10 11:27:34 +02:00
|
|
|
static struct nfs4_client *create_client(struct xdr_netobj name, char *recdir,
|
|
|
|
struct svc_rqst *rqstp, nfs4_verifier *verf)
|
|
|
|
{
|
|
|
|
struct nfs4_client *clp;
|
|
|
|
struct sockaddr *sa = svc_addr(rqstp);
|
|
|
|
char *princ;
|
|
|
|
|
|
|
|
clp = alloc_client(name);
|
|
|
|
if (clp == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2010-10-13 01:55:25 +02:00
|
|
|
INIT_LIST_HEAD(&clp->cl_sessions);
|
|
|
|
|
2009-09-10 11:27:34 +02:00
|
|
|
princ = svc_gss_principal(rqstp);
|
|
|
|
if (princ) {
|
|
|
|
clp->cl_principal = kstrdup(princ, GFP_KERNEL);
|
|
|
|
if (clp->cl_principal == NULL) {
|
|
|
|
free_client(clp);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(clp->cl_recdir, recdir, HEXDIR_LEN);
|
2010-05-11 23:13:29 +02:00
|
|
|
atomic_set(&clp->cl_refcount, 0);
|
2010-05-01 00:51:44 +02:00
|
|
|
clp->cl_cb_state = NFSD4_CB_UNKNOWN;
|
2009-09-10 11:27:34 +02:00
|
|
|
INIT_LIST_HEAD(&clp->cl_idhash);
|
|
|
|
INIT_LIST_HEAD(&clp->cl_strhash);
|
|
|
|
INIT_LIST_HEAD(&clp->cl_openowners);
|
|
|
|
INIT_LIST_HEAD(&clp->cl_delegations);
|
|
|
|
INIT_LIST_HEAD(&clp->cl_lru);
|
2011-01-10 22:44:41 +01:00
|
|
|
INIT_LIST_HEAD(&clp->cl_callbacks);
|
2010-06-05 02:04:45 +02:00
|
|
|
spin_lock_init(&clp->cl_lock);
|
2010-05-26 23:52:14 +02:00
|
|
|
INIT_WORK(&clp->cl_cb_null.cb_work, nfsd4_do_callback_rpc);
|
2010-05-11 23:13:41 +02:00
|
|
|
clp->cl_time = get_seconds();
|
2009-09-10 11:27:34 +02:00
|
|
|
clear_bit(0, &clp->cl_cb_slot_busy);
|
|
|
|
rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
|
|
|
|
copy_verf(clp, verf);
|
|
|
|
rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
|
|
|
|
clp->cl_flavor = rqstp->rq_flavor;
|
|
|
|
copy_cred(&clp->cl_cred, &rqstp->rq_cred);
|
|
|
|
gen_confirm(clp);
|
2010-06-15 04:26:31 +02:00
|
|
|
clp->cl_cb_session = NULL;
|
2009-09-10 11:27:34 +02:00
|
|
|
return clp;
|
|
|
|
}
|
|
|
|
|
2007-11-22 04:07:08 +01:00
|
|
|
static int check_name(struct xdr_netobj name)
|
|
|
|
{
|
2005-04-17 00:20:36 +02:00
|
|
|
if (name.len == 0)
|
|
|
|
return 0;
|
|
|
|
if (name.len > NFS4_OPAQUE_LIMIT) {
|
2007-07-27 22:10:37 +02:00
|
|
|
dprintk("NFSD: check_name: name too long(%d)!\n", name.len);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-06-24 07:04:03 +02:00
|
|
|
static void
|
2005-04-17 00:20:36 +02:00
|
|
|
add_to_unconfirmed(struct nfs4_client *clp, unsigned int strhashval)
|
|
|
|
{
|
|
|
|
unsigned int idhashval;
|
|
|
|
|
|
|
|
list_add(&clp->cl_strhash, &unconf_str_hashtbl[strhashval]);
|
|
|
|
idhashval = clientid_hashval(clp->cl_clientid.cl_id);
|
|
|
|
list_add(&clp->cl_idhash, &unconf_id_hashtbl[idhashval]);
|
2010-05-11 23:13:04 +02:00
|
|
|
renew_client(clp);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2005-06-24 07:04:03 +02:00
|
|
|
static void
|
2005-04-17 00:20:36 +02:00
|
|
|
move_to_confirmed(struct nfs4_client *clp)
|
|
|
|
{
|
|
|
|
unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
|
|
|
|
unsigned int strhashval;
|
|
|
|
|
|
|
|
dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
|
2006-06-26 09:24:46 +02:00
|
|
|
list_move(&clp->cl_idhash, &conf_id_hashtbl[idhashval]);
|
2005-06-24 07:03:52 +02:00
|
|
|
strhashval = clientstr_hashval(clp->cl_recdir);
|
2010-05-11 23:12:51 +02:00
|
|
|
list_move(&clp->cl_strhash, &conf_str_hashtbl[strhashval]);
|
2005-04-17 00:20:36 +02:00
|
|
|
renew_client(clp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct nfs4_client *
|
|
|
|
find_confirmed_client(clientid_t *clid)
|
|
|
|
{
|
|
|
|
struct nfs4_client *clp;
|
|
|
|
unsigned int idhashval = clientid_hashval(clid->cl_id);
|
|
|
|
|
|
|
|
list_for_each_entry(clp, &conf_id_hashtbl[idhashval], cl_idhash) {
|
2007-07-26 23:04:54 +02:00
|
|
|
if (same_clid(&clp->cl_clientid, clid))
|
2005-04-17 00:20:36 +02:00
|
|
|
return clp;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct nfs4_client *
|
|
|
|
find_unconfirmed_client(clientid_t *clid)
|
|
|
|
{
|
|
|
|
struct nfs4_client *clp;
|
|
|
|
unsigned int idhashval = clientid_hashval(clid->cl_id);
|
|
|
|
|
|
|
|
list_for_each_entry(clp, &unconf_id_hashtbl[idhashval], cl_idhash) {
|
2007-07-26 23:04:54 +02:00
|
|
|
if (same_clid(&clp->cl_clientid, clid))
|
2005-04-17 00:20:36 +02:00
|
|
|
return clp;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-11-24 23:17:34 +01:00
|
|
|
static bool clp_used_exchangeid(struct nfs4_client *clp)
|
2009-04-03 07:28:05 +02:00
|
|
|
{
|
2010-11-24 23:17:34 +01:00
|
|
|
return clp->cl_exchange_flags != 0;
|
2010-11-24 23:30:54 +01:00
|
|
|
}
|
2009-04-03 07:28:05 +02:00
|
|
|
|
2005-06-24 07:03:56 +02:00
|
|
|
static struct nfs4_client *
|
2010-11-24 23:30:54 +01:00
|
|
|
find_confirmed_client_by_str(const char *dname, unsigned int hashval)
|
2005-06-24 07:03:56 +02:00
|
|
|
{
|
|
|
|
struct nfs4_client *clp;
|
|
|
|
|
|
|
|
list_for_each_entry(clp, &conf_str_hashtbl[hashval], cl_strhash) {
|
2010-11-24 23:30:54 +01:00
|
|
|
if (same_name(clp->cl_recdir, dname))
|
2005-06-24 07:03:56 +02:00
|
|
|
return clp;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct nfs4_client *
|
2010-11-24 23:30:54 +01:00
|
|
|
find_unconfirmed_client_by_str(const char *dname, unsigned int hashval)
|
2005-06-24 07:03:56 +02:00
|
|
|
{
|
|
|
|
struct nfs4_client *clp;
|
|
|
|
|
|
|
|
list_for_each_entry(clp, &unconf_str_hashtbl[hashval], cl_strhash) {
|
2010-11-24 23:30:54 +01:00
|
|
|
if (same_name(clp->cl_recdir, dname))
|
2005-06-24 07:03:56 +02:00
|
|
|
return clp;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-12-15 06:09:01 +01:00
|
|
|
static void rpc_svcaddr2sockaddr(struct sockaddr *sa, unsigned short family, union svc_addr_u *svcaddr)
|
|
|
|
{
|
|
|
|
switch (family) {
|
|
|
|
case AF_INET:
|
|
|
|
((struct sockaddr_in *)sa)->sin_family = AF_INET;
|
|
|
|
((struct sockaddr_in *)sa)->sin_addr = svcaddr->addr;
|
|
|
|
return;
|
|
|
|
case AF_INET6:
|
|
|
|
((struct sockaddr_in6 *)sa)->sin6_family = AF_INET6;
|
|
|
|
((struct sockaddr_in6 *)sa)->sin6_addr = svcaddr->addr6;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-06-24 07:04:03 +02:00
|
|
|
static void
|
2010-12-15 06:09:01 +01:00
|
|
|
gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2010-06-01 01:09:40 +02:00
|
|
|
struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
|
2010-12-15 06:09:01 +01:00
|
|
|
struct sockaddr *sa = svc_addr(rqstp);
|
|
|
|
u32 scopeid = rpc_get_scope_id(sa);
|
2009-08-14 18:57:58 +02: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 00:20:36 +02:00
|
|
|
goto out_err;
|
|
|
|
|
2010-06-01 01:09:40 +02:00
|
|
|
conn->cb_addrlen = rpc_uaddr2sockaddr(se->se_callback_addr_val,
|
2009-08-14 18:57:57 +02:00
|
|
|
se->se_callback_addr_len,
|
2010-06-01 01:09:40 +02:00
|
|
|
(struct sockaddr *)&conn->cb_addr,
|
|
|
|
sizeof(conn->cb_addr));
|
2009-08-14 18:57:57 +02:00
|
|
|
|
2010-06-01 01:09:40 +02:00
|
|
|
if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out_err;
|
2009-08-14 18:57:57 +02:00
|
|
|
|
2010-06-01 01:09:40 +02:00
|
|
|
if (conn->cb_addr.ss_family == AF_INET6)
|
|
|
|
((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
|
2009-08-14 18:57:59 +02:00
|
|
|
|
2010-06-01 01:09:40 +02:00
|
|
|
conn->cb_prog = se->se_callback_prog;
|
|
|
|
conn->cb_ident = se->se_callback_ident;
|
2010-12-15 06:09:01 +01:00
|
|
|
rpc_svcaddr2sockaddr((struct sockaddr *)&conn->cb_saddr, expected_family, &rqstp->rq_daddr);
|
2005-04-17 00:20:36 +02:00
|
|
|
return;
|
|
|
|
out_err:
|
2010-06-01 01:09:40 +02:00
|
|
|
conn->cb_addr.ss_family = AF_UNSPEC;
|
|
|
|
conn->cb_addrlen = 0;
|
2005-09-13 10:25:36 +02:00
|
|
|
dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
|
2005-04-17 00:20:36 +02:00
|
|
|
"will not receive delegations\n",
|
|
|
|
clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-04-03 07:28:15 +02:00
|
|
|
/*
|
2009-08-28 14:45:04 +02:00
|
|
|
* Cache a reply. nfsd4_check_drc_limit() has bounded the cache size.
|
2009-04-03 07:28:15 +02:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
|
|
|
|
{
|
2009-08-28 14:45:04 +02:00
|
|
|
struct nfsd4_slot *slot = resp->cstate.slot;
|
|
|
|
unsigned int base;
|
2009-04-03 07:28:15 +02:00
|
|
|
|
2009-08-28 14:45:04 +02:00
|
|
|
dprintk("--> %s slot %p\n", __func__, slot);
|
2009-04-03 07:28:15 +02:00
|
|
|
|
2009-08-28 14:45:04 +02:00
|
|
|
slot->sl_opcnt = resp->opcnt;
|
|
|
|
slot->sl_status = resp->cstate.status;
|
2009-04-03 07:28:15 +02:00
|
|
|
|
2009-04-03 07:28:35 +02:00
|
|
|
if (nfsd4_not_cached(resp)) {
|
2009-08-28 14:45:04 +02:00
|
|
|
slot->sl_datalen = 0;
|
2009-04-03 07:28:35 +02:00
|
|
|
return;
|
2009-04-03 07:28:15 +02:00
|
|
|
}
|
2009-08-28 14:45:04 +02:00
|
|
|
slot->sl_datalen = (char *)resp->p - (char *)resp->cstate.datap;
|
|
|
|
base = (char *)resp->cstate.datap -
|
|
|
|
(char *)resp->xbuf->head[0].iov_base;
|
|
|
|
if (read_bytes_from_xdr_buf(resp->xbuf, base, slot->sl_data,
|
|
|
|
slot->sl_datalen))
|
|
|
|
WARN("%s: sessions DRC could not cache compound\n", __func__);
|
|
|
|
return;
|
2009-04-03 07:28:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2009-07-24 01:02:18 +02: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 07:28:15 +02:00
|
|
|
*
|
|
|
|
*/
|
2009-07-24 01:02:18 +02:00
|
|
|
static __be32
|
|
|
|
nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
|
|
|
|
struct nfsd4_compoundres *resp)
|
2009-04-03 07:28:15 +02:00
|
|
|
{
|
2009-07-24 01:02:18 +02:00
|
|
|
struct nfsd4_op *op;
|
|
|
|
struct nfsd4_slot *slot = resp->cstate.slot;
|
2009-04-03 07:28:35 +02:00
|
|
|
|
2009-07-24 01:02:18 +02:00
|
|
|
dprintk("--> %s resp->opcnt %d cachethis %u \n", __func__,
|
2009-08-28 14:45:04 +02:00
|
|
|
resp->opcnt, resp->cstate.slot->sl_cachethis);
|
2009-04-03 07:28:35 +02:00
|
|
|
|
2009-07-24 01:02:18 +02:00
|
|
|
/* Encode the replayed sequence operation */
|
|
|
|
op = &args->ops[resp->opcnt - 1];
|
|
|
|
nfsd4_encode_operation(resp, op);
|
2009-04-03 07:28:35 +02:00
|
|
|
|
2009-07-24 01:02:18 +02:00
|
|
|
/* Return nfserr_retry_uncached_rep in next operation. */
|
2009-08-28 14:45:04 +02:00
|
|
|
if (args->opcnt > 1 && slot->sl_cachethis == 0) {
|
2009-07-24 01:02:18 +02:00
|
|
|
op = &args->ops[resp->opcnt++];
|
|
|
|
op->status = nfserr_retry_uncached_rep;
|
|
|
|
nfsd4_encode_operation(resp, op);
|
2009-04-03 07:28:15 +02:00
|
|
|
}
|
2009-07-24 01:02:18 +02:00
|
|
|
return op->status;
|
2009-04-03 07:28:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2009-08-28 14:45:04 +02:00
|
|
|
* The sequence operation is not cached because we can use the slot and
|
|
|
|
* session values.
|
2009-04-03 07:28:15 +02:00
|
|
|
*/
|
|
|
|
__be32
|
2009-04-03 07:28:35 +02:00
|
|
|
nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
|
|
|
|
struct nfsd4_sequence *seq)
|
2009-04-03 07:28:15 +02:00
|
|
|
{
|
2009-08-28 14:45:04 +02:00
|
|
|
struct nfsd4_slot *slot = resp->cstate.slot;
|
2009-04-03 07:28:15 +02:00
|
|
|
__be32 status;
|
|
|
|
|
2009-08-28 14:45:04 +02:00
|
|
|
dprintk("--> %s slot %p\n", __func__, slot);
|
2009-04-03 07:28:15 +02:00
|
|
|
|
2009-07-24 01:02:18 +02:00
|
|
|
/* Either returns 0 or nfserr_retry_uncached */
|
|
|
|
status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
|
|
|
|
if (status == nfserr_retry_uncached_rep)
|
|
|
|
return status;
|
2009-04-03 07:28:15 +02:00
|
|
|
|
2009-08-28 14:45:04 +02:00
|
|
|
/* The sequence operation has been encoded, cstate->datap set. */
|
|
|
|
memcpy(resp->cstate.datap, slot->sl_data, slot->sl_datalen);
|
2009-04-03 07:28:15 +02:00
|
|
|
|
2009-08-28 14:45:04 +02:00
|
|
|
resp->opcnt = slot->sl_opcnt;
|
|
|
|
resp->p = resp->cstate.datap + XDR_QUADLEN(slot->sl_datalen);
|
|
|
|
status = slot->sl_status;
|
2009-04-03 07:28:15 +02:00
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2009-04-03 07:28:01 +02: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)
|
|
|
|
{
|
|
|
|
/* pNFS is not supported */
|
|
|
|
new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2009-04-03 07:27:58 +02:00
|
|
|
__be32
|
|
|
|
nfsd4_exchange_id(struct svc_rqst *rqstp,
|
|
|
|
struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_exchange_id *exid)
|
|
|
|
{
|
2009-04-03 07:28:01 +02:00
|
|
|
struct nfs4_client *unconf, *conf, *new;
|
|
|
|
int status;
|
|
|
|
unsigned int strhashval;
|
|
|
|
char dname[HEXDIR_LEN];
|
2009-08-14 18:57:56 +02:00
|
|
|
char addr_str[INET6_ADDRSTRLEN];
|
2009-04-03 07:28:01 +02:00
|
|
|
nfs4_verifier verf = exid->verifier;
|
2009-08-14 18:57:56 +02:00
|
|
|
struct sockaddr *sa = svc_addr(rqstp);
|
2009-04-03 07:28:01 +02:00
|
|
|
|
2009-08-14 18:57:56 +02:00
|
|
|
rpc_ntop(sa, addr_str, sizeof(addr_str));
|
2009-04-03 07:28:01 +02:00
|
|
|
dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
|
2009-08-14 18:57:56 +02:00
|
|
|
"ip_addr=%s flags %x, spa_how %d\n",
|
2009-04-03 07:28:01 +02:00
|
|
|
__func__, rqstp, exid, exid->clname.len, exid->clname.data,
|
2009-08-14 18:57:56 +02:00
|
|
|
addr_str, exid->flags, exid->spa_how);
|
2009-04-03 07:28:01 +02:00
|
|
|
|
|
|
|
if (!check_name(exid->clname) || (exid->flags & ~EXCHGID4_FLAG_MASK_A))
|
|
|
|
return nfserr_inval;
|
|
|
|
|
|
|
|
/* Currently only support SP4_NONE */
|
|
|
|
switch (exid->spa_how) {
|
|
|
|
case SP4_NONE:
|
|
|
|
break;
|
|
|
|
case SP4_SSV:
|
2010-11-12 20:36:06 +01:00
|
|
|
return nfserr_serverfault;
|
2009-04-03 07:28:01 +02:00
|
|
|
default:
|
|
|
|
BUG(); /* checked by xdr code */
|
|
|
|
case SP4_MACH_CRED:
|
|
|
|
return nfserr_serverfault; /* no excuse :-/ */
|
|
|
|
}
|
|
|
|
|
|
|
|
status = nfs4_make_rec_clidname(dname, &exid->clname);
|
|
|
|
|
|
|
|
if (status)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
strhashval = clientstr_hashval(dname);
|
|
|
|
|
|
|
|
nfs4_lock_state();
|
|
|
|
status = nfs_ok;
|
|
|
|
|
2010-11-24 23:30:54 +01:00
|
|
|
conf = find_confirmed_client_by_str(dname, strhashval);
|
2009-04-03 07:28:01 +02:00
|
|
|
if (conf) {
|
2010-11-24 23:30:54 +01:00
|
|
|
if (!clp_used_exchangeid(conf)) {
|
|
|
|
status = nfserr_clid_inuse; /* XXX: ? */
|
|
|
|
goto out;
|
|
|
|
}
|
2009-04-03 07:28:01 +02:00
|
|
|
if (!same_verf(&verf, &conf->cl_verifier)) {
|
|
|
|
/* 18.35.4 case 8 */
|
|
|
|
if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
|
|
|
|
status = nfserr_not_same;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
/* Client reboot: destroy old state */
|
|
|
|
expire_client(conf);
|
|
|
|
goto out_new;
|
|
|
|
}
|
|
|
|
if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
|
|
|
|
/* 18.35.4 case 9 */
|
|
|
|
if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
|
|
|
|
status = nfserr_perm;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
expire_client(conf);
|
|
|
|
goto out_new;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Set bit when the owner id and verifier map to an already
|
|
|
|
* confirmed client id (18.35.3).
|
|
|
|
*/
|
|
|
|
exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Falling into 18.35.4 case 2, possible router replay.
|
|
|
|
* Leave confirmed record intact and return same result.
|
|
|
|
*/
|
|
|
|
copy_verf(conf, &verf);
|
|
|
|
new = conf;
|
|
|
|
goto out_copy;
|
2009-06-16 03:20:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 18.35.4 case 7 */
|
|
|
|
if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
|
|
|
|
status = nfserr_noent;
|
|
|
|
goto out;
|
2009-04-03 07:28:01 +02:00
|
|
|
}
|
|
|
|
|
2010-11-24 23:30:54 +01:00
|
|
|
unconf = find_unconfirmed_client_by_str(dname, strhashval);
|
2009-04-03 07:28:01 +02:00
|
|
|
if (unconf) {
|
|
|
|
/*
|
|
|
|
* Possible retry or client restart. Per 18.35.4 case 4,
|
|
|
|
* a new unconfirmed record should be generated regardless
|
|
|
|
* of whether any properties have changed.
|
|
|
|
*/
|
|
|
|
expire_client(unconf);
|
|
|
|
}
|
|
|
|
|
|
|
|
out_new:
|
|
|
|
/* Normal case */
|
2009-09-10 11:27:34 +02:00
|
|
|
new = create_client(exid->clname, dname, rqstp, &verf);
|
2009-04-03 07:28:01 +02:00
|
|
|
if (new == NULL) {
|
2010-06-22 22:17:12 +02:00
|
|
|
status = nfserr_jukebox;
|
2009-04-03 07:28:01 +02:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
gen_clid(new);
|
|
|
|
add_to_unconfirmed(new, strhashval);
|
|
|
|
out_copy:
|
|
|
|
exid->clientid.cl_boot = new->cl_clientid.cl_boot;
|
|
|
|
exid->clientid.cl_id = new->cl_clientid.cl_id;
|
|
|
|
|
2009-04-03 07:28:32 +02:00
|
|
|
exid->seqid = 1;
|
2009-04-03 07:28:01 +02:00
|
|
|
nfsd4_set_ex_flags(new, exid);
|
|
|
|
|
|
|
|
dprintk("nfsd4_exchange_id seqid %d flags %x\n",
|
2009-07-24 01:02:16 +02:00
|
|
|
new->cl_cs_slot.sl_seqid, new->cl_exchange_flags);
|
2009-04-03 07:28:01 +02:00
|
|
|
status = nfs_ok;
|
|
|
|
|
|
|
|
out:
|
|
|
|
nfs4_unlock_state();
|
|
|
|
error:
|
|
|
|
dprintk("nfsd4_exchange_id returns %d\n", ntohl(status));
|
|
|
|
return status;
|
2009-04-03 07:27:58 +02:00
|
|
|
}
|
|
|
|
|
2009-04-03 07:28:08 +02:00
|
|
|
static int
|
2009-07-24 01:02:15 +02:00
|
|
|
check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
|
2009-04-03 07:28:08 +02:00
|
|
|
{
|
2009-07-24 01:02:15 +02:00
|
|
|
dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
|
|
|
|
slot_seqid);
|
2009-04-03 07:28:08 +02:00
|
|
|
|
|
|
|
/* The slot is in use, and no response has been sent. */
|
2009-07-24 01:02:15 +02:00
|
|
|
if (slot_inuse) {
|
|
|
|
if (seqid == slot_seqid)
|
2009-04-03 07:28:08 +02:00
|
|
|
return nfserr_jukebox;
|
|
|
|
else
|
|
|
|
return nfserr_seq_misordered;
|
|
|
|
}
|
|
|
|
/* Normal */
|
2009-07-24 01:02:15 +02:00
|
|
|
if (likely(seqid == slot_seqid + 1))
|
2009-04-03 07:28:08 +02:00
|
|
|
return nfs_ok;
|
|
|
|
/* Replay */
|
2009-07-24 01:02:15 +02:00
|
|
|
if (seqid == slot_seqid)
|
2009-04-03 07:28:08 +02:00
|
|
|
return nfserr_replay_cache;
|
|
|
|
/* Wraparound */
|
2009-07-24 01:02:15 +02:00
|
|
|
if (seqid == 1 && (slot_seqid + 1) == 0)
|
2009-04-03 07:28:08 +02:00
|
|
|
return nfs_ok;
|
|
|
|
/* Misordered replay or misordered new request */
|
|
|
|
return nfserr_seq_misordered;
|
|
|
|
}
|
|
|
|
|
2009-07-24 01:02:16 +02: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,
|
|
|
|
struct nfsd4_clid_slot *slot, int nfserr)
|
|
|
|
{
|
|
|
|
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 08:50:17 +02: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))
|
|
|
|
|
|
|
|
static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs fchannel)
|
|
|
|
{
|
|
|
|
return fchannel.maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ
|
|
|
|
|| fchannel.maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ;
|
|
|
|
}
|
|
|
|
|
2009-04-03 07:27:58 +02:00
|
|
|
__be32
|
|
|
|
nfsd4_create_session(struct svc_rqst *rqstp,
|
|
|
|
struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_create_session *cr_ses)
|
|
|
|
{
|
2009-08-14 18:57:56 +02:00
|
|
|
struct sockaddr *sa = svc_addr(rqstp);
|
2009-04-03 07:28:28 +02:00
|
|
|
struct nfs4_client *conf, *unconf;
|
2010-06-15 01:01:57 +02:00
|
|
|
struct nfsd4_session *new;
|
2009-07-24 01:02:16 +02:00
|
|
|
struct nfsd4_clid_slot *cs_slot = NULL;
|
2010-10-02 23:04:00 +02:00
|
|
|
bool confirm_me = false;
|
2009-04-03 07:28:28 +02:00
|
|
|
int status = 0;
|
|
|
|
|
2011-03-23 10:57:07 +01:00
|
|
|
if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
|
|
|
|
return nfserr_inval;
|
|
|
|
|
2009-04-03 07:28:28 +02:00
|
|
|
nfs4_lock_state();
|
|
|
|
unconf = find_unconfirmed_client(&cr_ses->clientid);
|
|
|
|
conf = find_confirmed_client(&cr_ses->clientid);
|
|
|
|
|
|
|
|
if (conf) {
|
2009-07-24 01:02:16 +02:00
|
|
|
cs_slot = &conf->cl_cs_slot;
|
|
|
|
status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
|
2009-04-03 07:28:32 +02:00
|
|
|
if (status == nfserr_replay_cache) {
|
2009-04-03 07:28:28 +02:00
|
|
|
dprintk("Got a create_session replay! seqid= %d\n",
|
2009-07-24 01:02:16 +02:00
|
|
|
cs_slot->sl_seqid);
|
2009-04-03 07:28:32 +02:00
|
|
|
/* Return the cached reply status */
|
2009-07-24 01:02:16 +02:00
|
|
|
status = nfsd4_replay_create_session(cr_ses, cs_slot);
|
2009-04-03 07:28:32 +02:00
|
|
|
goto out;
|
2009-07-24 01:02:16 +02:00
|
|
|
} else if (cr_ses->seqid != cs_slot->sl_seqid + 1) {
|
2009-04-03 07:28:28 +02:00
|
|
|
status = nfserr_seq_misordered;
|
|
|
|
dprintk("Sequence misordered!\n");
|
|
|
|
dprintk("Expected seqid= %d but got seqid= %d\n",
|
2009-07-24 01:02:16 +02:00
|
|
|
cs_slot->sl_seqid, cr_ses->seqid);
|
2009-04-03 07:28:28 +02:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
} else if (unconf) {
|
|
|
|
if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
|
2009-08-14 18:57:56 +02:00
|
|
|
!rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
|
2009-04-03 07:28:28 +02:00
|
|
|
status = nfserr_clid_inuse;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-07-24 01:02:16 +02:00
|
|
|
cs_slot = &unconf->cl_cs_slot;
|
|
|
|
status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
|
2009-04-03 07:28:32 +02:00
|
|
|
if (status) {
|
|
|
|
/* an unconfirmed replay returns misordered */
|
2009-04-03 07:28:28 +02:00
|
|
|
status = nfserr_seq_misordered;
|
2010-10-02 23:03:35 +02:00
|
|
|
goto out;
|
2009-04-03 07:28:28 +02:00
|
|
|
}
|
|
|
|
|
2010-10-02 23:04:00 +02:00
|
|
|
confirm_me = true;
|
2009-04-03 07:28:28 +02:00
|
|
|
conf = unconf;
|
|
|
|
} else {
|
|
|
|
status = nfserr_stale_clientid;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2010-10-20 01:36:51 +02:00
|
|
|
/*
|
|
|
|
* XXX: we should probably set this at creation time, and check
|
|
|
|
* for consistent minorversion use throughout:
|
|
|
|
*/
|
|
|
|
conf->cl_minorversion = 1;
|
2010-04-15 21:11:09 +02:00
|
|
|
/*
|
|
|
|
* We do not support RDMA or persistent sessions
|
|
|
|
*/
|
|
|
|
cr_ses->flags &= ~SESSION4_PERSIST;
|
|
|
|
cr_ses->flags &= ~SESSION4_RDMA;
|
|
|
|
|
2011-07-14 08:50:17 +02:00
|
|
|
status = nfserr_toosmall;
|
|
|
|
if (check_forechannel_attrs(cr_ses->fore_channel))
|
|
|
|
goto out;
|
|
|
|
|
2010-06-15 01:01:57 +02:00
|
|
|
status = nfserr_jukebox;
|
|
|
|
new = alloc_init_session(rqstp, conf, cr_ses);
|
|
|
|
if (!new)
|
2009-04-03 07:28:28 +02:00
|
|
|
goto out;
|
2010-06-15 01:01:57 +02:00
|
|
|
status = nfs_ok;
|
|
|
|
memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
|
2009-04-03 07:28:28 +02:00
|
|
|
NFS4_MAX_SESSIONID_LEN);
|
2010-11-11 11:03:40 +01:00
|
|
|
memcpy(&cr_ses->fore_channel, &new->se_fchannel,
|
|
|
|
sizeof(struct nfsd4_channel_attrs));
|
2010-10-02 23:04:00 +02:00
|
|
|
cs_slot->sl_seqid++;
|
2009-07-24 01:02:16 +02:00
|
|
|
cr_ses->seqid = cs_slot->sl_seqid;
|
2009-04-03 07:28:28 +02:00
|
|
|
|
2009-07-24 01:02:16 +02:00
|
|
|
/* cache solo and embedded create sessions under the state lock */
|
|
|
|
nfsd4_cache_create_session(cr_ses, cs_slot, status);
|
2010-10-02 23:04:00 +02:00
|
|
|
if (confirm_me)
|
|
|
|
move_to_confirmed(conf);
|
2009-04-03 07:28:28 +02:00
|
|
|
out:
|
|
|
|
nfs4_unlock_state();
|
|
|
|
dprintk("%s returns %d\n", __func__, ntohl(status));
|
|
|
|
return status;
|
2009-04-03 07:27:58 +02:00
|
|
|
}
|
|
|
|
|
2010-04-21 18:27:19 +02:00
|
|
|
static bool nfsd4_last_compound_op(struct svc_rqst *rqstp)
|
|
|
|
{
|
|
|
|
struct nfsd4_compoundres *resp = rqstp->rq_resp;
|
|
|
|
struct nfsd4_compoundargs *argp = rqstp->rq_argp;
|
|
|
|
|
|
|
|
return argp->opcnt == resp->opcnt;
|
|
|
|
}
|
|
|
|
|
2010-10-05 05:12:59 +02: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;
|
|
|
|
};
|
|
|
|
return nfserr_inval;
|
|
|
|
}
|
|
|
|
|
|
|
|
__be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
|
|
|
|
struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_bind_conn_to_session *bcts)
|
|
|
|
{
|
|
|
|
__be32 status;
|
|
|
|
|
|
|
|
if (!nfsd4_last_compound_op(rqstp))
|
|
|
|
return nfserr_not_only_op;
|
|
|
|
spin_lock(&client_lock);
|
|
|
|
cstate->session = find_in_sessionid_hashtbl(&bcts->sessionid);
|
|
|
|
/* Sorta weird: we only need the refcnt'ing because new_conn acquires
|
|
|
|
* client_lock iself: */
|
|
|
|
if (cstate->session) {
|
|
|
|
nfsd4_get_session(cstate->session);
|
|
|
|
atomic_inc(&cstate->session->se_client->cl_refcount);
|
|
|
|
}
|
|
|
|
spin_unlock(&client_lock);
|
|
|
|
if (!cstate->session)
|
|
|
|
return nfserr_badsession;
|
|
|
|
|
|
|
|
status = nfsd4_map_bcts_dir(&bcts->dir);
|
2011-04-27 21:47:15 +02:00
|
|
|
if (!status)
|
|
|
|
nfsd4_new_conn(rqstp, cstate->session, bcts->dir);
|
|
|
|
return status;
|
2010-10-05 05:12:59 +02:00
|
|
|
}
|
|
|
|
|
2010-05-01 18:56:06 +02:00
|
|
|
static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
|
|
|
|
{
|
|
|
|
if (!session)
|
|
|
|
return 0;
|
|
|
|
return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
|
|
|
|
}
|
|
|
|
|
2009-04-03 07:27:58 +02:00
|
|
|
__be32
|
|
|
|
nfsd4_destroy_session(struct svc_rqst *r,
|
|
|
|
struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_destroy_session *sessionid)
|
|
|
|
{
|
2009-04-03 07:28:38 +02:00
|
|
|
struct nfsd4_session *ses;
|
|
|
|
u32 status = nfserr_badsession;
|
|
|
|
|
|
|
|
/* Notes:
|
|
|
|
* - The confirmed nfs4_client->cl_sessionid holds destroyed sessinid
|
|
|
|
* - Should we return nfserr_back_chan_busy if waiting for
|
|
|
|
* callbacks on to-be-destroyed session?
|
|
|
|
* - Do we need to clear any callback info from previous session?
|
|
|
|
*/
|
|
|
|
|
2010-05-01 18:56:06 +02:00
|
|
|
if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
|
2010-04-21 18:27:19 +02:00
|
|
|
if (!nfsd4_last_compound_op(r))
|
|
|
|
return nfserr_not_only_op;
|
|
|
|
}
|
2009-04-03 07:28:38 +02:00
|
|
|
dump_sessionid(__func__, &sessionid->sessionid);
|
2010-05-11 23:12:26 +02:00
|
|
|
spin_lock(&client_lock);
|
2009-04-03 07:28:38 +02:00
|
|
|
ses = find_in_sessionid_hashtbl(&sessionid->sessionid);
|
|
|
|
if (!ses) {
|
2010-05-11 23:12:26 +02:00
|
|
|
spin_unlock(&client_lock);
|
2009-04-03 07:28:38 +02:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
unhash_session(ses);
|
2010-05-11 23:12:26 +02:00
|
|
|
spin_unlock(&client_lock);
|
2009-04-03 07:28:38 +02:00
|
|
|
|
2010-05-11 23:14:06 +02:00
|
|
|
nfs4_lock_state();
|
2010-12-09 21:52:19 +01:00
|
|
|
nfsd4_probe_callback_sync(ses->se_client);
|
2010-05-11 23:14:06 +02:00
|
|
|
nfs4_unlock_state();
|
2010-06-07 00:37:16 +02:00
|
|
|
|
|
|
|
nfsd4_del_conns(ses);
|
|
|
|
|
2009-04-03 07:28:38 +02:00
|
|
|
nfsd4_put_session(ses);
|
|
|
|
status = nfs_ok;
|
|
|
|
out:
|
|
|
|
dprintk("%s returns %d\n", __func__, ntohl(status));
|
|
|
|
return status;
|
2009-04-03 07:27:58 +02:00
|
|
|
}
|
|
|
|
|
2010-10-21 23:17:31 +02:00
|
|
|
static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
|
2010-09-29 22:11:06 +02:00
|
|
|
{
|
|
|
|
struct nfsd4_conn *c;
|
|
|
|
|
|
|
|
list_for_each_entry(c, &s->se_conns, cn_persession) {
|
2010-10-21 23:17:31 +02:00
|
|
|
if (c->cn_xprt == xpt) {
|
2010-09-29 22:11:06 +02:00
|
|
|
return c;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-10-21 23:17:31 +02:00
|
|
|
static void nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
|
2010-09-29 22:11:06 +02:00
|
|
|
{
|
|
|
|
struct nfs4_client *clp = ses->se_client;
|
2010-10-21 23:17:31 +02:00
|
|
|
struct nfsd4_conn *c;
|
2010-10-26 16:07:17 +02:00
|
|
|
int ret;
|
2010-09-29 22:11:06 +02:00
|
|
|
|
|
|
|
spin_lock(&clp->cl_lock);
|
2010-10-21 23:17:31 +02:00
|
|
|
c = __nfsd4_find_conn(new->cn_xprt, ses);
|
2010-09-29 22:11:06 +02:00
|
|
|
if (c) {
|
|
|
|
spin_unlock(&clp->cl_lock);
|
|
|
|
free_conn(new);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
__nfsd4_hash_conn(new, ses);
|
|
|
|
spin_unlock(&clp->cl_lock);
|
2010-10-26 16:07:17 +02:00
|
|
|
ret = nfsd4_register_conn(new);
|
|
|
|
if (ret)
|
|
|
|
/* oops; xprt is already down: */
|
|
|
|
nfsd4_conn_lost(&new->cn_xpt_user);
|
2010-09-29 22:11:06 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-04-27 03:09:58 +02: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 08:56:02 +02: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;
|
|
|
|
}
|
|
|
|
|
2009-04-03 07:27:58 +02:00
|
|
|
__be32
|
2009-04-03 07:28:08 +02:00
|
|
|
nfsd4_sequence(struct svc_rqst *rqstp,
|
2009-04-03 07:27:58 +02:00
|
|
|
struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_sequence *seq)
|
|
|
|
{
|
2009-04-03 07:28:12 +02:00
|
|
|
struct nfsd4_compoundres *resp = rqstp->rq_resp;
|
2009-04-03 07:28:08 +02:00
|
|
|
struct nfsd4_session *session;
|
|
|
|
struct nfsd4_slot *slot;
|
2010-10-21 23:17:31 +02:00
|
|
|
struct nfsd4_conn *conn;
|
2009-04-03 07:28:08 +02:00
|
|
|
int status;
|
|
|
|
|
2009-04-03 07:28:12 +02:00
|
|
|
if (resp->opcnt != 1)
|
|
|
|
return nfserr_sequence_pos;
|
|
|
|
|
2010-10-21 23:17:31 +02: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;
|
|
|
|
|
2010-05-11 23:12:26 +02:00
|
|
|
spin_lock(&client_lock);
|
2009-04-03 07:28:08 +02:00
|
|
|
status = nfserr_badsession;
|
|
|
|
session = find_in_sessionid_hashtbl(&seq->sessionid);
|
|
|
|
if (!session)
|
|
|
|
goto out;
|
|
|
|
|
2011-04-27 03:09:58 +02:00
|
|
|
status = nfserr_too_many_ops;
|
|
|
|
if (nfsd4_session_too_many_ops(rqstp, session))
|
|
|
|
goto out;
|
|
|
|
|
2011-07-14 08:56:02 +02:00
|
|
|
status = nfserr_req_too_big;
|
|
|
|
if (nfsd4_request_too_big(rqstp, session))
|
|
|
|
goto out;
|
|
|
|
|
2009-04-03 07:28:08 +02:00
|
|
|
status = nfserr_badslot;
|
2009-06-16 03:19:13 +02:00
|
|
|
if (seq->slotid >= session->se_fchannel.maxreqs)
|
2009-04-03 07:28:08 +02:00
|
|
|
goto out;
|
|
|
|
|
2009-08-28 14:45:04 +02:00
|
|
|
slot = session->se_slots[seq->slotid];
|
2009-04-03 07:28:08 +02:00
|
|
|
dprintk("%s: slotid %d\n", __func__, seq->slotid);
|
|
|
|
|
2009-08-28 14:45:02 +02: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;
|
|
|
|
|
2009-07-24 01:02:15 +02:00
|
|
|
status = check_slot_seqid(seq->seqid, slot->sl_seqid, slot->sl_inuse);
|
2009-04-03 07:28:08 +02:00
|
|
|
if (status == nfserr_replay_cache) {
|
|
|
|
cstate->slot = slot;
|
|
|
|
cstate->session = session;
|
2009-04-03 07:28:22 +02:00
|
|
|
/* Return the cached reply status and set cstate->status
|
2009-08-28 14:45:04 +02:00
|
|
|
* for nfsd4_proc_compound processing */
|
2009-04-03 07:28:35 +02:00
|
|
|
status = nfsd4_replay_cache_entry(resp, seq);
|
2009-04-03 07:28:22 +02:00
|
|
|
cstate->status = nfserr_replay_cache;
|
2009-08-20 02:21:56 +02:00
|
|
|
goto out;
|
2009-04-03 07:28:08 +02:00
|
|
|
}
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
|
2010-10-21 23:17:31 +02:00
|
|
|
nfsd4_sequence_check_conn(conn, session);
|
|
|
|
conn = NULL;
|
2010-09-29 22:11:06 +02:00
|
|
|
|
2009-04-03 07:28:08 +02:00
|
|
|
/* Success! bump slot seqid */
|
|
|
|
slot->sl_inuse = true;
|
|
|
|
slot->sl_seqid = seq->seqid;
|
2009-08-28 14:45:04 +02:00
|
|
|
slot->sl_cachethis = seq->cachethis;
|
2009-04-03 07:28:08 +02:00
|
|
|
|
|
|
|
cstate->slot = slot;
|
|
|
|
cstate->session = session;
|
|
|
|
|
|
|
|
out:
|
2010-04-24 21:35:43 +02:00
|
|
|
/* Hold a session reference until done processing the compound. */
|
2009-08-20 02:21:56 +02:00
|
|
|
if (cstate->session) {
|
2010-11-18 14:30:33 +01:00
|
|
|
struct nfs4_client *clp = session->se_client;
|
|
|
|
|
2010-05-11 23:13:04 +02:00
|
|
|
nfsd4_get_session(cstate->session);
|
2010-11-18 14:30:33 +01:00
|
|
|
atomic_inc(&clp->cl_refcount);
|
|
|
|
if (clp->cl_cb_state == NFSD4_CB_DOWN)
|
|
|
|
seq->status_flags |= SEQ4_STATUS_CB_PATH_DOWN;
|
2009-08-20 02:21:56 +02:00
|
|
|
}
|
2010-10-21 23:17:31 +02:00
|
|
|
kfree(conn);
|
2010-05-11 23:13:04 +02:00
|
|
|
spin_unlock(&client_lock);
|
2009-04-03 07:28:08 +02:00
|
|
|
dprintk("%s: return %d\n", __func__, ntohl(status));
|
|
|
|
return status;
|
2009-04-03 07:27:58 +02:00
|
|
|
}
|
|
|
|
|
2010-04-19 21:11:28 +02:00
|
|
|
__be32
|
|
|
|
nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
|
|
|
|
{
|
2011-04-27 03:14:30 +02:00
|
|
|
int status = 0;
|
|
|
|
|
2010-04-19 21:11:28 +02: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.
|
|
|
|
*/
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
2011-04-27 03:14:30 +02:00
|
|
|
|
2010-04-19 21:11:28 +02:00
|
|
|
nfs4_lock_state();
|
2011-04-27 03:14:30 +02:00
|
|
|
status = nfserr_complete_already;
|
|
|
|
if (cstate->session->se_client->cl_firststate)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
status = nfserr_stale_clientid;
|
|
|
|
if (is_client_expired(cstate->session->se_client))
|
2010-04-19 21:11:28 +02: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 03:14:30 +02:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
status = nfs_ok;
|
2010-04-19 21:11:28 +02:00
|
|
|
nfsd4_create_clid_dir(cstate->session->se_client);
|
2011-04-27 03:14:30 +02:00
|
|
|
out:
|
2010-04-19 21:11:28 +02:00
|
|
|
nfs4_unlock_state();
|
2011-04-27 03:14:30 +02:00
|
|
|
return status;
|
2010-04-19 21:11:28 +02:00
|
|
|
}
|
|
|
|
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32
|
2006-12-13 09:35:38 +01:00
|
|
|
nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_setclientid *setclid)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_netobj clname = {
|
|
|
|
.len = setclid->se_namelen,
|
|
|
|
.data = setclid->se_name,
|
|
|
|
};
|
|
|
|
nfs4_verifier clverifier = setclid->se_verf;
|
|
|
|
unsigned int strhashval;
|
2005-06-24 07:03:56 +02:00
|
|
|
struct nfs4_client *conf, *unconf, *new;
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32 status;
|
2005-06-24 07:03:52 +02:00
|
|
|
char dname[HEXDIR_LEN];
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (!check_name(clname))
|
2005-09-13 10:25:39 +02:00
|
|
|
return nfserr_inval;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-06-24 07:03:52 +02:00
|
|
|
status = nfs4_make_rec_clidname(dname, &clname);
|
|
|
|
if (status)
|
2005-09-13 10:25:39 +02:00
|
|
|
return status;
|
2005-06-24 07:03:52 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* XXX The Duplicate Request Cache (DRC) has been checked (??)
|
|
|
|
* We get here on a DRC miss.
|
|
|
|
*/
|
|
|
|
|
2005-06-24 07:03:52 +02:00
|
|
|
strhashval = clientstr_hashval(dname);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
nfs4_lock_state();
|
2010-11-24 23:30:54 +01:00
|
|
|
conf = find_confirmed_client_by_str(dname, strhashval);
|
2005-06-24 07:03:56 +02:00
|
|
|
if (conf) {
|
2007-11-20 22:11:27 +01:00
|
|
|
/* RFC 3530 14.2.33 CASE 0: */
|
2005-04-17 00:20:36 +02:00
|
|
|
status = nfserr_clid_inuse;
|
2010-11-24 23:30:54 +01:00
|
|
|
if (clp_used_exchangeid(conf))
|
|
|
|
goto out;
|
2009-03-18 20:06:26 +01:00
|
|
|
if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
|
2009-08-14 18:57:56 +02:00
|
|
|
char addr_str[INET6_ADDRSTRLEN];
|
|
|
|
rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
|
|
|
|
sizeof(addr_str));
|
|
|
|
dprintk("NFSD: setclientid: string in use by client "
|
|
|
|
"at %s\n", addr_str);
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2007-11-20 22:11:27 +01:00
|
|
|
/*
|
|
|
|
* section 14.2.33 of RFC 3530 (under the heading "IMPLEMENTATION")
|
|
|
|
* has a description of SETCLIENTID request processing consisting
|
|
|
|
* of 5 bullet points, labeled as CASE0 - CASE4 below.
|
|
|
|
*/
|
2010-11-24 23:30:54 +01:00
|
|
|
unconf = find_unconfirmed_client_by_str(dname, strhashval);
|
2005-04-17 00:20:36 +02:00
|
|
|
status = nfserr_resource;
|
|
|
|
if (!conf) {
|
2007-11-20 22:11:27 +01:00
|
|
|
/*
|
|
|
|
* RFC 3530 14.2.33 CASE 4:
|
|
|
|
* placed first, because it is the normal case
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
if (unconf)
|
|
|
|
expire_client(unconf);
|
2009-09-10 11:27:34 +02:00
|
|
|
new = create_client(clname, dname, rqstp, &clverifier);
|
2005-06-24 07:03:52 +02:00
|
|
|
if (new == NULL)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
gen_clid(new);
|
2007-07-26 23:04:54 +02:00
|
|
|
} else if (same_verf(&conf->cl_verifier, &clverifier)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
2007-11-20 22:11:27 +01:00
|
|
|
* RFC 3530 14.2.33 CASE 1:
|
|
|
|
* probable callback update
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2005-06-24 07:04:06 +02:00
|
|
|
if (unconf) {
|
|
|
|
/* Note this is removing unconfirmed {*x***},
|
|
|
|
* which is stronger than RFC recommended {vxc**}.
|
|
|
|
* This has the advantage that there is at most
|
|
|
|
* one {*x***} in either list at any time.
|
|
|
|
*/
|
|
|
|
expire_client(unconf);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2009-09-10 11:27:34 +02:00
|
|
|
new = create_client(clname, dname, rqstp, &clverifier);
|
2005-06-24 07:03:52 +02:00
|
|
|
if (new == NULL)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
copy_clid(new, conf);
|
|
|
|
} else if (!unconf) {
|
|
|
|
/*
|
2007-11-20 22:11:27 +01:00
|
|
|
* RFC 3530 14.2.33 CASE 2:
|
|
|
|
* probable client reboot; state will be removed if
|
|
|
|
* confirmed.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2009-09-10 11:27:34 +02:00
|
|
|
new = create_client(clname, dname, rqstp, &clverifier);
|
2005-06-24 07:03:52 +02:00
|
|
|
if (new == NULL)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
gen_clid(new);
|
2007-11-20 01:09:50 +01:00
|
|
|
} else {
|
2007-11-20 22:11:27 +01:00
|
|
|
/*
|
|
|
|
* RFC 3530 14.2.33 CASE 3:
|
|
|
|
* probable client reboot; state will be removed if
|
|
|
|
* confirmed.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
expire_client(unconf);
|
2009-09-10 11:27:34 +02:00
|
|
|
new = create_client(clname, dname, rqstp, &clverifier);
|
2005-06-24 07:03:52 +02:00
|
|
|
if (new == NULL)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
gen_clid(new);
|
|
|
|
}
|
2010-10-20 01:36:51 +02:00
|
|
|
/*
|
|
|
|
* XXX: we should probably set this at creation time, and check
|
|
|
|
* for consistent minorversion use throughout:
|
|
|
|
*/
|
|
|
|
new->cl_minorversion = 0;
|
2010-12-15 06:09:01 +01:00
|
|
|
gen_callback(new, setclid, rqstp);
|
2007-08-10 00:34:32 +02:00
|
|
|
add_to_unconfirmed(new, strhashval);
|
2005-04-17 00:20:36 +02: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));
|
|
|
|
status = nfs_ok;
|
|
|
|
out:
|
|
|
|
nfs4_unlock_state();
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
2007-11-20 22:11:27 +01:00
|
|
|
* Section 14.2.34 of RFC 3530 (under the heading "IMPLEMENTATION") has
|
|
|
|
* a description of SETCLIENTID_CONFIRM request processing consisting of 4
|
|
|
|
* bullets, labeled as CASE1 - CASE4 below.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32
|
2006-12-13 09:35:38 +01:00
|
|
|
nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
|
|
|
|
struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_setclientid_confirm *setclientid_confirm)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2009-08-14 18:57:56 +02:00
|
|
|
struct sockaddr *sa = svc_addr(rqstp);
|
2005-06-24 07:04:14 +02:00
|
|
|
struct nfs4_client *conf, *unconf;
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_verifier confirm = setclientid_confirm->sc_confirm;
|
|
|
|
clientid_t * clid = &setclientid_confirm->sc_clientid;
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32 status;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (STALE_CLIENTID(clid))
|
|
|
|
return nfserr_stale_clientid;
|
|
|
|
/*
|
|
|
|
* XXX The Duplicate Request Cache (DRC) has been checked (??)
|
|
|
|
* We get here on a DRC miss.
|
|
|
|
*/
|
|
|
|
|
|
|
|
nfs4_lock_state();
|
2005-06-24 07:04:14 +02:00
|
|
|
|
|
|
|
conf = find_confirmed_client(clid);
|
|
|
|
unconf = find_unconfirmed_client(clid);
|
|
|
|
|
|
|
|
status = nfserr_clid_inuse;
|
2009-08-14 18:57:56 +02:00
|
|
|
if (conf && !rpc_cmp_addr((struct sockaddr *) &conf->cl_addr, sa))
|
2005-06-24 07:04:14 +02:00
|
|
|
goto out;
|
2009-08-14 18:57:56 +02:00
|
|
|
if (unconf && !rpc_cmp_addr((struct sockaddr *) &unconf->cl_addr, sa))
|
2005-06-24 07:04:14 +02:00
|
|
|
goto out;
|
|
|
|
|
2007-11-20 22:11:27 +01:00
|
|
|
/*
|
|
|
|
* section 14.2.34 of RFC 3530 has a description of
|
|
|
|
* SETCLIENTID_CONFIRM request processing consisting
|
|
|
|
* of 4 bullet points, labeled as CASE1 - CASE4 below.
|
|
|
|
*/
|
2007-11-20 21:54:10 +01:00
|
|
|
if (conf && unconf && same_verf(&confirm, &unconf->cl_confirm)) {
|
2007-11-20 22:11:27 +01:00
|
|
|
/*
|
|
|
|
* RFC 3530 14.2.34 CASE 1:
|
|
|
|
* callback update
|
|
|
|
*/
|
2007-07-26 23:04:54 +02:00
|
|
|
if (!same_creds(&conf->cl_cred, &unconf->cl_cred))
|
2005-04-17 00:20:36 +02:00
|
|
|
status = nfserr_clid_inuse;
|
|
|
|
else {
|
2010-10-19 23:56:52 +02:00
|
|
|
nfsd4_change_callback(conf, &unconf->cl_cb_conn);
|
|
|
|
nfsd4_probe_callback(conf);
|
2005-06-24 07:04:08 +02:00
|
|
|
expire_client(unconf);
|
2005-04-17 00:20:36 +02:00
|
|
|
status = nfs_ok;
|
2005-06-24 07:04:08 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2007-11-20 22:52:07 +01:00
|
|
|
} else if (conf && !unconf) {
|
2007-11-20 22:11:27 +01:00
|
|
|
/*
|
|
|
|
* RFC 3530 14.2.34 CASE 2:
|
|
|
|
* probable retransmitted request; play it safe and
|
|
|
|
* do nothing.
|
2005-06-24 07:04:13 +02:00
|
|
|
*/
|
2007-07-26 23:04:54 +02:00
|
|
|
if (!same_creds(&conf->cl_cred, &rqstp->rq_cred))
|
2005-04-17 00:20:36 +02:00
|
|
|
status = nfserr_clid_inuse;
|
2005-06-24 07:04:14 +02:00
|
|
|
else
|
2005-04-17 00:20:36 +02:00
|
|
|
status = nfs_ok;
|
2005-06-24 07:04:13 +02:00
|
|
|
} else if (!conf && unconf
|
2007-07-26 23:04:54 +02:00
|
|
|
&& same_verf(&unconf->cl_confirm, &confirm)) {
|
2007-11-20 22:11:27 +01:00
|
|
|
/*
|
|
|
|
* RFC 3530 14.2.34 CASE 3:
|
|
|
|
* Normal case; new or rebooted client:
|
2005-06-24 07:04:13 +02:00
|
|
|
*/
|
2007-07-26 23:04:54 +02:00
|
|
|
if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
status = nfserr_clid_inuse;
|
|
|
|
} else {
|
2005-06-24 07:04:08 +02:00
|
|
|
unsigned int hash =
|
|
|
|
clientstr_hashval(unconf->cl_recdir);
|
|
|
|
conf = find_confirmed_client_by_str(unconf->cl_recdir,
|
2010-11-24 23:30:54 +01:00
|
|
|
hash);
|
2005-06-24 07:04:08 +02:00
|
|
|
if (conf) {
|
2005-06-24 07:04:30 +02:00
|
|
|
nfsd4_remove_clid_dir(conf);
|
2005-06-24 07:04:08 +02:00
|
|
|
expire_client(conf);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
move_to_confirmed(unconf);
|
2005-06-24 07:04:14 +02:00
|
|
|
conf = unconf;
|
2010-10-19 23:56:52 +02:00
|
|
|
nfsd4_probe_callback(conf);
|
2005-06-24 07:04:08 +02:00
|
|
|
status = nfs_ok;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2007-07-26 23:04:54 +02:00
|
|
|
} else if ((!conf || (conf && !same_verf(&conf->cl_confirm, &confirm)))
|
|
|
|
&& (!unconf || (unconf && !same_verf(&unconf->cl_confirm,
|
2005-06-24 07:04:13 +02:00
|
|
|
&confirm)))) {
|
2007-11-20 22:11:27 +01:00
|
|
|
/*
|
|
|
|
* RFC 3530 14.2.34 CASE 4:
|
|
|
|
* Client probably hasn't noticed that we rebooted yet.
|
2005-06-24 07:04:13 +02:00
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
status = nfserr_stale_clientid;
|
2005-06-24 07:04:13 +02:00
|
|
|
} else {
|
2005-06-24 07:04:11 +02:00
|
|
|
/* check that we have hit one of the cases...*/
|
|
|
|
status = nfserr_clid_inuse;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
|
|
|
nfs4_unlock_state();
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* OPEN Share state helper functions */
|
|
|
|
static inline struct nfs4_file *
|
|
|
|
alloc_init_file(struct inode *ino)
|
|
|
|
{
|
|
|
|
struct nfs4_file *fp;
|
|
|
|
unsigned int hashval = file_hashval(ino);
|
|
|
|
|
2005-06-24 07:03:01 +02:00
|
|
|
fp = kmem_cache_alloc(file_slab, GFP_KERNEL);
|
|
|
|
if (fp) {
|
2009-02-22 23:51:34 +01:00
|
|
|
atomic_set(&fp->fi_ref, 1);
|
2005-04-17 00:20:36 +02:00
|
|
|
INIT_LIST_HEAD(&fp->fi_hash);
|
2005-06-24 07:03:08 +02:00
|
|
|
INIT_LIST_HEAD(&fp->fi_stateids);
|
|
|
|
INIT_LIST_HEAD(&fp->fi_delegations);
|
2005-04-17 00:20:36 +02:00
|
|
|
fp->fi_inode = igrab(ino);
|
|
|
|
fp->fi_id = current_fileid++;
|
2007-07-17 13:04:40 +02:00
|
|
|
fp->fi_had_conflict = false;
|
2011-02-01 01:20:39 +01:00
|
|
|
fp->fi_lease = NULL;
|
2010-07-08 17:02:09 +02:00
|
|
|
memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
|
|
|
|
memset(fp->fi_access, 0, sizeof(fp->fi_access));
|
2010-05-17 18:00:37 +02:00
|
|
|
spin_lock(&recall_lock);
|
|
|
|
list_add(&fp->fi_hash, &file_hashtbl[hashval]);
|
|
|
|
spin_unlock(&recall_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
return fp;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-06-24 07:03:01 +02:00
|
|
|
static void
|
2006-12-07 05:33:20 +01:00
|
|
|
nfsd4_free_slab(struct kmem_cache **slab)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-06-24 07:03:01 +02:00
|
|
|
if (*slab == NULL)
|
|
|
|
return;
|
2006-09-27 10:49:40 +02:00
|
|
|
kmem_cache_destroy(*slab);
|
2005-06-24 07:03:01 +02:00
|
|
|
*slab = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-08-01 21:30:59 +02:00
|
|
|
void
|
2005-04-17 00:20:36 +02:00
|
|
|
nfsd4_free_slabs(void)
|
|
|
|
{
|
2005-06-24 07:03:01 +02:00
|
|
|
nfsd4_free_slab(&stateowner_slab);
|
|
|
|
nfsd4_free_slab(&file_slab);
|
2005-06-24 07:03:03 +02:00
|
|
|
nfsd4_free_slab(&stateid_slab);
|
2005-06-24 07:03:04 +02:00
|
|
|
nfsd4_free_slab(&deleg_slab);
|
2005-06-24 07:03:01 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-06-24 07:03:01 +02:00
|
|
|
static int
|
|
|
|
nfsd4_init_slabs(void)
|
|
|
|
{
|
|
|
|
stateowner_slab = kmem_cache_create("nfsd4_stateowners",
|
2007-07-20 03:11:58 +02:00
|
|
|
sizeof(struct nfs4_stateowner), 0, 0, NULL);
|
2005-06-24 07:03:01 +02:00
|
|
|
if (stateowner_slab == NULL)
|
|
|
|
goto out_nomem;
|
|
|
|
file_slab = kmem_cache_create("nfsd4_files",
|
2007-07-20 03:11:58 +02:00
|
|
|
sizeof(struct nfs4_file), 0, 0, NULL);
|
2005-06-24 07:03:01 +02:00
|
|
|
if (file_slab == NULL)
|
|
|
|
goto out_nomem;
|
2005-06-24 07:03:03 +02:00
|
|
|
stateid_slab = kmem_cache_create("nfsd4_stateids",
|
2007-07-20 03:11:58 +02:00
|
|
|
sizeof(struct nfs4_stateid), 0, 0, NULL);
|
2005-06-24 07:03:03 +02:00
|
|
|
if (stateid_slab == NULL)
|
|
|
|
goto out_nomem;
|
2005-06-24 07:03:04 +02:00
|
|
|
deleg_slab = kmem_cache_create("nfsd4_delegations",
|
2007-07-20 03:11:58 +02:00
|
|
|
sizeof(struct nfs4_delegation), 0, 0, NULL);
|
2005-06-24 07:03:04 +02:00
|
|
|
if (deleg_slab == NULL)
|
|
|
|
goto out_nomem;
|
2005-06-24 07:03:01 +02:00
|
|
|
return 0;
|
|
|
|
out_nomem:
|
|
|
|
nfsd4_free_slabs();
|
|
|
|
dprintk("nfsd4: out of memory while initializing nfsv4\n");
|
|
|
|
return -ENOMEM;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nfs4_free_stateowner(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct nfs4_stateowner *sop =
|
|
|
|
container_of(kref, struct nfs4_stateowner, so_ref);
|
|
|
|
kfree(sop->so_owner.data);
|
|
|
|
kmem_cache_free(stateowner_slab, sop);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct nfs4_stateowner *
|
|
|
|
alloc_stateowner(struct xdr_netobj *owner)
|
|
|
|
{
|
|
|
|
struct nfs4_stateowner *sop;
|
|
|
|
|
|
|
|
if ((sop = kmem_cache_alloc(stateowner_slab, GFP_KERNEL))) {
|
|
|
|
if ((sop->so_owner.data = kmalloc(owner->len, GFP_KERNEL))) {
|
|
|
|
memcpy(sop->so_owner.data, owner->data, owner->len);
|
|
|
|
sop->so_owner.len = owner->len;
|
|
|
|
kref_init(&sop->so_ref);
|
|
|
|
return sop;
|
|
|
|
}
|
|
|
|
kmem_cache_free(stateowner_slab, sop);
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct nfs4_stateowner *
|
|
|
|
alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) {
|
|
|
|
struct nfs4_stateowner *sop;
|
|
|
|
struct nfs4_replay *rp;
|
|
|
|
unsigned int idhashval;
|
|
|
|
|
|
|
|
if (!(sop = alloc_stateowner(&open->op_owner)))
|
|
|
|
return NULL;
|
|
|
|
idhashval = ownerid_hashval(current_ownerid);
|
|
|
|
INIT_LIST_HEAD(&sop->so_idhash);
|
|
|
|
INIT_LIST_HEAD(&sop->so_strhash);
|
|
|
|
INIT_LIST_HEAD(&sop->so_perclient);
|
2005-06-24 07:04:17 +02:00
|
|
|
INIT_LIST_HEAD(&sop->so_stateids);
|
|
|
|
INIT_LIST_HEAD(&sop->so_perstateid); /* not used */
|
2005-04-17 00:20:36 +02:00
|
|
|
INIT_LIST_HEAD(&sop->so_close_lru);
|
|
|
|
sop->so_time = 0;
|
|
|
|
list_add(&sop->so_idhash, &ownerid_hashtbl[idhashval]);
|
|
|
|
list_add(&sop->so_strhash, &ownerstr_hashtbl[strhashval]);
|
2005-06-24 07:04:17 +02:00
|
|
|
list_add(&sop->so_perclient, &clp->cl_openowners);
|
2005-04-17 00:20:36 +02:00
|
|
|
sop->so_is_open_owner = 1;
|
|
|
|
sop->so_id = current_ownerid++;
|
|
|
|
sop->so_client = clp;
|
|
|
|
sop->so_seqid = open->op_seqid;
|
|
|
|
sop->so_confirmed = 0;
|
|
|
|
rp = &sop->so_replay;
|
2006-01-19 02:43:47 +01:00
|
|
|
rp->rp_status = nfserr_serverfault;
|
2005-04-17 00:20:36 +02:00
|
|
|
rp->rp_buflen = 0;
|
|
|
|
rp->rp_buf = rp->rp_ibuf;
|
|
|
|
return sop;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
init_stateid(struct nfs4_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) {
|
|
|
|
struct nfs4_stateowner *sop = open->op_stateowner;
|
|
|
|
unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&stp->st_hash);
|
2005-06-24 07:04:17 +02:00
|
|
|
INIT_LIST_HEAD(&stp->st_perstateowner);
|
|
|
|
INIT_LIST_HEAD(&stp->st_lockowners);
|
2005-04-17 00:20:36 +02:00
|
|
|
INIT_LIST_HEAD(&stp->st_perfile);
|
|
|
|
list_add(&stp->st_hash, &stateid_hashtbl[hashval]);
|
2005-06-24 07:04:17 +02:00
|
|
|
list_add(&stp->st_perstateowner, &sop->so_stateids);
|
2005-06-24 07:03:08 +02:00
|
|
|
list_add(&stp->st_perfile, &fp->fi_stateids);
|
2005-04-17 00:20:36 +02:00
|
|
|
stp->st_stateowner = sop;
|
2005-06-24 07:03:10 +02:00
|
|
|
get_nfs4_file(fp);
|
2005-04-17 00:20:36 +02:00
|
|
|
stp->st_file = fp;
|
2010-04-22 22:21:39 +02:00
|
|
|
stp->st_stateid.si_boot = boot_time;
|
2005-04-17 00:20:36 +02:00
|
|
|
stp->st_stateid.si_stateownerid = sop->so_id;
|
|
|
|
stp->st_stateid.si_fileid = fp->fi_id;
|
|
|
|
stp->st_stateid.si_generation = 0;
|
|
|
|
stp->st_access_bmap = 0;
|
|
|
|
stp->st_deny_bmap = 0;
|
2009-04-03 07:28:56 +02:00
|
|
|
__set_bit(open->op_share_access & ~NFS4_SHARE_WANT_MASK,
|
|
|
|
&stp->st_access_bmap);
|
2005-04-17 00:20:36 +02:00
|
|
|
__set_bit(open->op_share_deny, &stp->st_deny_bmap);
|
2005-07-08 02:59:27 +02:00
|
|
|
stp->st_openstp = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2005-06-24 07:04:03 +02:00
|
|
|
static void
|
2005-04-17 00:20:36 +02:00
|
|
|
move_to_close_lru(struct nfs4_stateowner *sop)
|
|
|
|
{
|
|
|
|
dprintk("NFSD: move_to_close_lru nfs4_stateowner %p\n", sop);
|
|
|
|
|
2006-04-11 07:55:42 +02:00
|
|
|
list_move_tail(&sop->so_close_lru, &close_lru);
|
2005-04-17 00:20:36 +02:00
|
|
|
sop->so_time = get_seconds();
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2007-07-26 23:04:54 +02:00
|
|
|
same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner,
|
|
|
|
clientid_t *clid)
|
|
|
|
{
|
|
|
|
return (sop->so_owner.len == owner->len) &&
|
|
|
|
0 == memcmp(sop->so_owner.data, owner->data, owner->len) &&
|
|
|
|
(sop->so_client->cl_clientid.cl_id == clid->cl_id);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct nfs4_stateowner *
|
|
|
|
find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open)
|
|
|
|
{
|
|
|
|
struct nfs4_stateowner *so = NULL;
|
|
|
|
|
|
|
|
list_for_each_entry(so, &ownerstr_hashtbl[hashval], so_strhash) {
|
2007-07-26 23:04:54 +02:00
|
|
|
if (same_owner_str(so, &open->op_owner, &open->op_clientid))
|
2005-04-17 00:20:36 +02:00
|
|
|
return so;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* search file_hashtbl[] for file */
|
|
|
|
static struct nfs4_file *
|
|
|
|
find_file(struct inode *ino)
|
|
|
|
{
|
|
|
|
unsigned int hashval = file_hashval(ino);
|
|
|
|
struct nfs4_file *fp;
|
|
|
|
|
2009-02-22 23:51:34 +01:00
|
|
|
spin_lock(&recall_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
list_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
|
2005-06-24 07:03:10 +02:00
|
|
|
if (fp->fi_inode == ino) {
|
|
|
|
get_nfs4_file(fp);
|
2009-02-22 23:51:34 +01:00
|
|
|
spin_unlock(&recall_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
return fp;
|
2005-06-24 07:03:10 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2009-02-22 23:51:34 +01:00
|
|
|
spin_unlock(&recall_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-04-03 07:28:53 +02:00
|
|
|
static inline int access_valid(u32 x, u32 minorversion)
|
2006-06-30 10:56:16 +02:00
|
|
|
{
|
2009-04-03 07:28:53 +02:00
|
|
|
if ((x & NFS4_SHARE_ACCESS_MASK) < NFS4_SHARE_ACCESS_READ)
|
2008-01-14 19:12:19 +01:00
|
|
|
return 0;
|
2009-04-03 07:28:53 +02:00
|
|
|
if ((x & NFS4_SHARE_ACCESS_MASK) > NFS4_SHARE_ACCESS_BOTH)
|
|
|
|
return 0;
|
|
|
|
x &= ~NFS4_SHARE_ACCESS_MASK;
|
|
|
|
if (minorversion && x) {
|
|
|
|
if ((x & NFS4_SHARE_WANT_MASK) > NFS4_SHARE_WANT_CANCEL)
|
|
|
|
return 0;
|
|
|
|
if ((x & NFS4_SHARE_WHEN_MASK) > NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED)
|
|
|
|
return 0;
|
|
|
|
x &= ~(NFS4_SHARE_WANT_MASK | NFS4_SHARE_WHEN_MASK);
|
|
|
|
}
|
|
|
|
if (x)
|
2008-01-14 19:12:19 +01:00
|
|
|
return 0;
|
|
|
|
return 1;
|
2006-06-30 10:56:16 +02:00
|
|
|
}
|
|
|
|
|
2008-01-14 19:12:19 +01:00
|
|
|
static inline int deny_valid(u32 x)
|
2006-06-30 10:56:16 +02:00
|
|
|
{
|
2008-01-14 19:12:19 +01:00
|
|
|
/* Note: unlike access bits, deny bits may be zero. */
|
|
|
|
return x <= NFS4_SHARE_DENY_BOTH;
|
2006-06-30 10:56:16 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Called to check deny when READ with all zero stateid or
|
|
|
|
* WRITE with all zero or all one stateid
|
|
|
|
*/
|
2006-10-20 08:28:59 +02:00
|
|
|
static __be32
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
|
|
|
|
{
|
|
|
|
struct inode *ino = current_fh->fh_dentry->d_inode;
|
|
|
|
struct nfs4_file *fp;
|
|
|
|
struct nfs4_stateid *stp;
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32 ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
dprintk("NFSD: nfs4_share_conflict\n");
|
|
|
|
|
|
|
|
fp = find_file(ino);
|
2005-06-24 07:03:10 +02:00
|
|
|
if (!fp)
|
|
|
|
return nfs_ok;
|
2005-07-08 02:59:23 +02:00
|
|
|
ret = nfserr_locked;
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Search for conflicting share reservations */
|
2005-06-24 07:03:10 +02:00
|
|
|
list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
|
|
|
|
if (test_bit(deny_type, &stp->st_deny_bmap) ||
|
|
|
|
test_bit(NFS4_SHARE_DENY_BOTH, &stp->st_deny_bmap))
|
|
|
|
goto out;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2005-06-24 07:03:10 +02:00
|
|
|
ret = nfs_ok;
|
|
|
|
out:
|
|
|
|
put_nfs4_file(fp);
|
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2011-01-31 17:54:04 +01:00
|
|
|
static void nfsd_break_one_deleg(struct nfs4_delegation *dp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
/* We're assuming the state code never drops its reference
|
|
|
|
* without first removing the lease. Since we're in this lease
|
|
|
|
* callback (and since the lease code is serialized by the kernel
|
|
|
|
* lock) we know the server hasn't removed the lease yet, we know
|
|
|
|
* it's safe to take a reference: */
|
|
|
|
atomic_inc(&dp->dl_count);
|
|
|
|
|
|
|
|
list_add_tail(&dp->dl_recall_lru, &del_recall_lru);
|
|
|
|
|
2010-11-17 16:26:56 +01:00
|
|
|
/* only place dl_time is set. protected by lock_flocks*/
|
2005-04-17 00:20:36 +02:00
|
|
|
dp->dl_time = get_seconds();
|
|
|
|
|
2011-01-31 17:54:04 +01:00
|
|
|
nfsd4_cb_recall(dp);
|
|
|
|
}
|
|
|
|
|
2011-02-01 01:20:39 +01:00
|
|
|
/* Called from break_lease() with lock_flocks() held. */
|
2011-01-31 17:54:04 +01:00
|
|
|
static void nfsd_break_deleg_cb(struct file_lock *fl)
|
|
|
|
{
|
2011-02-01 01:20:39 +01:00
|
|
|
struct nfs4_file *fp = (struct nfs4_file *)fl->fl_owner;
|
|
|
|
struct nfs4_delegation *dp;
|
2011-01-31 17:54:04 +01:00
|
|
|
|
2011-02-01 01:20:39 +01:00
|
|
|
BUG_ON(!fp);
|
|
|
|
/* We assume break_lease is only called once per lease: */
|
|
|
|
BUG_ON(fp->fi_had_conflict);
|
2007-09-13 00:56:12 +02:00
|
|
|
/*
|
|
|
|
* We don't want the locks code to timeout the lease for us;
|
2011-02-01 01:20:39 +01:00
|
|
|
* we'll remove it ourself if a delegation isn't returned
|
2011-01-31 17:54:04 +01:00
|
|
|
* in time:
|
2007-09-13 00:56:12 +02:00
|
|
|
*/
|
|
|
|
fl->fl_break_time = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2011-02-07 22:53:46 +01:00
|
|
|
spin_lock(&recall_lock);
|
2011-02-01 01:20:39 +01:00
|
|
|
fp->fi_had_conflict = true;
|
|
|
|
list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
|
|
|
|
nfsd_break_one_deleg(dp);
|
2011-02-07 22:53:46 +01:00
|
|
|
spin_unlock(&recall_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static
|
|
|
|
int nfsd_change_deleg_cb(struct file_lock **onlist, int arg)
|
|
|
|
{
|
|
|
|
if (arg & F_UNLCK)
|
|
|
|
return lease_modify(onlist, arg);
|
|
|
|
else
|
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
2009-09-22 02:01:12 +02:00
|
|
|
static const struct lock_manager_operations nfsd_lease_mng_ops = {
|
2011-07-21 02:21:59 +02:00
|
|
|
.lm_break = nfsd_break_deleg_cb,
|
|
|
|
.lm_change = nfsd_change_deleg_cb,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32
|
2009-04-03 07:28:45 +02:00
|
|
|
nfsd4_process_open1(struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_open *open)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
clientid_t *clientid = &open->op_clientid;
|
|
|
|
struct nfs4_client *clp = NULL;
|
|
|
|
unsigned int strhashval;
|
|
|
|
struct nfs4_stateowner *sop = NULL;
|
|
|
|
|
|
|
|
if (!check_name(open->op_owner))
|
2006-01-19 02:43:34 +01:00
|
|
|
return nfserr_inval;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (STALE_CLIENTID(&open->op_clientid))
|
|
|
|
return nfserr_stale_clientid;
|
|
|
|
|
|
|
|
strhashval = ownerstr_hashval(clientid->cl_id, open->op_owner);
|
|
|
|
sop = find_openstateowner_str(strhashval, open);
|
2006-01-19 02:43:34 +01:00
|
|
|
open->op_stateowner = sop;
|
|
|
|
if (!sop) {
|
|
|
|
/* Make sure the client's lease hasn't expired. */
|
2005-04-17 00:20:36 +02:00
|
|
|
clp = find_confirmed_client(clientid);
|
|
|
|
if (clp == NULL)
|
2006-01-19 02:43:34 +01:00
|
|
|
return nfserr_expired;
|
|
|
|
goto renew;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2009-04-03 07:28:45 +02:00
|
|
|
/* When sessions are used, skip open sequenceid processing */
|
|
|
|
if (nfsd4_has_session(cstate))
|
|
|
|
goto renew;
|
2006-01-19 02:43:34 +01:00
|
|
|
if (!sop->so_confirmed) {
|
|
|
|
/* Replace unconfirmed owners without checking for replay. */
|
|
|
|
clp = sop->so_client;
|
2009-01-11 21:24:04 +01:00
|
|
|
release_openowner(sop);
|
2006-01-19 02:43:34 +01:00
|
|
|
open->op_stateowner = NULL;
|
|
|
|
goto renew;
|
|
|
|
}
|
|
|
|
if (open->op_seqid == sop->so_seqid - 1) {
|
|
|
|
if (sop->so_replay.rp_buflen)
|
2006-10-20 08:29:03 +02:00
|
|
|
return nfserr_replay_me;
|
2006-01-19 02:43:34 +01:00
|
|
|
/* The original OPEN failed so spectacularly
|
|
|
|
* that we don't even have replay data saved!
|
|
|
|
* Therefore, we have no choice but to continue
|
|
|
|
* processing this OPEN; presumably, we'll
|
|
|
|
* fail again for the same reason.
|
|
|
|
*/
|
|
|
|
dprintk("nfsd4_process_open1: replay with no replay cache\n");
|
|
|
|
goto renew;
|
|
|
|
}
|
|
|
|
if (open->op_seqid != sop->so_seqid)
|
|
|
|
return nfserr_bad_seqid;
|
2005-04-17 00:20:36 +02:00
|
|
|
renew:
|
2006-01-19 02:43:34 +01:00
|
|
|
if (open->op_stateowner == NULL) {
|
|
|
|
sop = alloc_init_open_stateowner(strhashval, clp, open);
|
|
|
|
if (sop == NULL)
|
|
|
|
return nfserr_resource;
|
|
|
|
open->op_stateowner = sop;
|
|
|
|
}
|
|
|
|
list_del_init(&sop->so_close_lru);
|
2005-04-17 00:20:36 +02:00
|
|
|
renew_client(sop->so_client);
|
2006-01-19 02:43:34 +01:00
|
|
|
return nfs_ok;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-10-20 08:28:59 +02:00
|
|
|
static inline __be32
|
2005-06-24 07:02:50 +02: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;
|
|
|
|
}
|
|
|
|
|
2005-06-24 07:02:49 +02:00
|
|
|
static struct nfs4_delegation *
|
|
|
|
find_delegation_file(struct nfs4_file *fp, stateid_t *stid)
|
|
|
|
{
|
2011-03-07 01:11:03 +01:00
|
|
|
struct nfs4_delegation *dp;
|
2005-06-24 07:02:49 +02:00
|
|
|
|
2011-02-01 01:20:39 +01:00
|
|
|
spin_lock(&recall_lock);
|
2011-03-07 01:11:03 +01:00
|
|
|
list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
|
|
|
|
if (dp->dl_stateid.si_stateownerid == stid->si_stateownerid) {
|
|
|
|
spin_unlock(&recall_lock);
|
|
|
|
return dp;
|
|
|
|
}
|
2011-02-01 01:20:39 +01:00
|
|
|
spin_unlock(&recall_lock);
|
2011-03-07 01:11:03 +01:00
|
|
|
return NULL;
|
2005-06-24 07:02:49 +02:00
|
|
|
}
|
|
|
|
|
2011-05-16 16:38:14 +02:00
|
|
|
static int share_access_to_flags(u32 share_access)
|
2010-05-19 02:01:35 +02:00
|
|
|
{
|
|
|
|
share_access &= ~NFS4_SHARE_WANT_MASK;
|
|
|
|
|
|
|
|
return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
|
|
|
|
}
|
|
|
|
|
2006-10-20 08:28:59 +02:00
|
|
|
static __be32
|
2005-06-24 07:02:53 +02:00
|
|
|
nfs4_check_deleg(struct nfs4_file *fp, struct nfsd4_open *open,
|
|
|
|
struct nfs4_delegation **dp)
|
|
|
|
{
|
|
|
|
int flags;
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32 status = nfserr_bad_stateid;
|
2005-06-24 07:02:53 +02:00
|
|
|
|
|
|
|
*dp = find_delegation_file(fp, &open->op_delegate_stateid);
|
|
|
|
if (*dp == NULL)
|
2005-06-24 07:02:54 +02:00
|
|
|
goto out;
|
2010-05-19 02:01:35 +02:00
|
|
|
flags = share_access_to_flags(open->op_share_access);
|
2005-06-24 07:02:53 +02:00
|
|
|
status = nfs4_check_delegmode(*dp, flags);
|
|
|
|
if (status)
|
|
|
|
*dp = NULL;
|
2005-06-24 07:02:54 +02:00
|
|
|
out:
|
|
|
|
if (open->op_claim_type != NFS4_OPEN_CLAIM_DELEGATE_CUR)
|
|
|
|
return nfs_ok;
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
open->op_stateowner->so_confirmed = 1;
|
|
|
|
return nfs_ok;
|
2005-06-24 07:02:53 +02:00
|
|
|
}
|
|
|
|
|
2006-10-20 08:28:59 +02:00
|
|
|
static __be32
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_stateid **stpp)
|
|
|
|
{
|
|
|
|
struct nfs4_stateid *local;
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32 status = nfserr_share_denied;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct nfs4_stateowner *sop = open->op_stateowner;
|
|
|
|
|
2005-06-24 07:03:08 +02:00
|
|
|
list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
|
2005-04-17 00:20:36 +02:00
|
|
|
/* ignore lock owners */
|
|
|
|
if (local->st_stateowner->so_is_open_owner == 0)
|
|
|
|
continue;
|
|
|
|
/* remember if we have seen this open owner */
|
|
|
|
if (local->st_stateowner == sop)
|
|
|
|
*stpp = local;
|
|
|
|
/* check for conflicting share reservations */
|
|
|
|
if (!test_share(local, open))
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
status = 0;
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2005-06-24 07:03:03 +02:00
|
|
|
static inline struct nfs4_stateid *
|
|
|
|
nfs4_alloc_stateid(void)
|
|
|
|
{
|
|
|
|
return kmem_cache_alloc(stateid_slab, GFP_KERNEL);
|
|
|
|
}
|
|
|
|
|
2010-07-28 18:21:23 +02: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;
|
|
|
|
}
|
|
|
|
|
2011-07-23 20:58:10 +02:00
|
|
|
static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file *fp,
|
|
|
|
struct svc_fh *cur_fh, struct nfsd4_open *open)
|
2010-07-08 17:02:09 +02:00
|
|
|
{
|
|
|
|
__be32 status;
|
2011-07-23 20:58:10 +02:00
|
|
|
int oflag = nfs4_access_to_omode(open->op_share_access);
|
|
|
|
int access = nfs4_access_to_access(open->op_share_access);
|
|
|
|
|
|
|
|
/* CLAIM_DELEGATE_CUR is used in response to a broken lease;
|
|
|
|
* allowing it to break the lease and return EAGAIN leaves the
|
|
|
|
* client unable to make progress in returning the delegation */
|
|
|
|
if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
|
|
|
|
access |= NFSD_MAY_NOT_BREAK_LEASE;
|
2010-07-08 17:02:09 +02:00
|
|
|
|
|
|
|
if (!fp->fi_fds[oflag]) {
|
|
|
|
status = nfsd_open(rqstp, cur_fh, S_IFREG, access,
|
|
|
|
&fp->fi_fds[oflag]);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
nfs4_file_get_access(fp, oflag);
|
|
|
|
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2006-10-20 08:28:59 +02:00
|
|
|
static __be32
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_new_open(struct svc_rqst *rqstp, struct nfs4_stateid **stpp,
|
2010-07-08 17:02:09 +02:00
|
|
|
struct nfs4_file *fp, struct svc_fh *cur_fh,
|
|
|
|
struct nfsd4_open *open)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct nfs4_stateid *stp;
|
2010-07-08 17:02:09 +02:00
|
|
|
__be32 status;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-06-24 07:03:03 +02:00
|
|
|
stp = nfs4_alloc_stateid();
|
2005-04-17 00:20:36 +02:00
|
|
|
if (stp == NULL)
|
|
|
|
return nfserr_resource;
|
|
|
|
|
2011-07-23 20:58:10 +02:00
|
|
|
status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open);
|
2010-07-08 17:02:09 +02:00
|
|
|
if (status) {
|
|
|
|
kmem_cache_free(stateid_slab, stp);
|
|
|
|
return status;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
*stpp = stp;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-20 08:28:59 +02:00
|
|
|
static inline __be32
|
2005-04-17 00:20:36 +02:00
|
|
|
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))
|
2006-01-19 02:43:46 +01:00
|
|
|
return nfserr_inval;
|
2005-04-17 00:20:36 +02:00
|
|
|
return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
|
|
|
|
}
|
|
|
|
|
2006-10-20 08:28:59 +02:00
|
|
|
static __be32
|
2010-07-08 17:02:09 +02:00
|
|
|
nfs4_upgrade_open(struct svc_rqst *rqstp, struct nfs4_file *fp, struct svc_fh *cur_fh, struct nfs4_stateid *stp, struct nfsd4_open *open)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2010-08-21 00:09:31 +02:00
|
|
|
u32 op_share_access = open->op_share_access & ~NFS4_SHARE_WANT_MASK;
|
|
|
|
bool new_access;
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32 status;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-08-21 00:09:31 +02:00
|
|
|
new_access = !test_bit(op_share_access, &stp->st_access_bmap);
|
2010-07-08 17:02:09 +02:00
|
|
|
if (new_access) {
|
2011-07-23 20:58:10 +02:00
|
|
|
status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open);
|
2010-07-08 17:02:09 +02:00
|
|
|
if (status)
|
|
|
|
return status;
|
2006-01-19 02:43:38 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
status = nfsd4_truncate(rqstp, cur_fh, open);
|
|
|
|
if (status) {
|
2010-07-08 17:02:09 +02:00
|
|
|
if (new_access) {
|
2011-06-29 14:23:50 +02:00
|
|
|
int oflag = nfs4_access_to_omode(op_share_access);
|
2010-07-08 17:02:09 +02:00
|
|
|
nfs4_file_put_access(fp, oflag);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
/* remember the open */
|
2010-05-19 02:01:35 +02:00
|
|
|
__set_bit(op_share_access, &stp->st_access_bmap);
|
2008-04-29 00:22:50 +02:00
|
|
|
__set_bit(open->op_share_deny, &stp->st_deny_bmap);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
2005-07-08 02:59:16 +02:00
|
|
|
nfs4_set_claim_prev(struct nfsd4_open *open)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-07-08 02:59:16 +02:00
|
|
|
open->op_stateowner->so_confirmed = 1;
|
|
|
|
open->op_stateowner->so_client->cl_firststate = 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2010-12-11 01:02:49 +01: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;
|
|
|
|
}
|
|
|
|
|
2011-01-31 17:55:12 +01:00
|
|
|
static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, int flag)
|
|
|
|
{
|
|
|
|
struct file_lock *fl;
|
|
|
|
|
|
|
|
fl = locks_alloc_lock();
|
|
|
|
if (!fl)
|
|
|
|
return NULL;
|
|
|
|
locks_init_lock(fl);
|
|
|
|
fl->fl_lmops = &nfsd_lease_mng_ops;
|
|
|
|
fl->fl_flags = FL_LEASE;
|
|
|
|
fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
|
|
|
|
fl->fl_end = OFFSET_MAX;
|
2011-02-01 01:20:39 +01:00
|
|
|
fl->fl_owner = (fl_owner_t)(dp->dl_file);
|
2011-01-31 17:55:12 +01:00
|
|
|
fl->fl_pid = current->tgid;
|
|
|
|
return fl;
|
|
|
|
}
|
|
|
|
|
2011-01-31 23:58:10 +01:00
|
|
|
static int nfs4_setlease(struct nfs4_delegation *dp, int flag)
|
|
|
|
{
|
2011-02-01 01:20:39 +01:00
|
|
|
struct nfs4_file *fp = dp->dl_file;
|
2011-01-31 23:58:10 +01:00
|
|
|
struct file_lock *fl;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
fl = nfs4_alloc_init_lease(dp, flag);
|
|
|
|
if (!fl)
|
|
|
|
return -ENOMEM;
|
2011-02-01 01:20:39 +01:00
|
|
|
fl->fl_file = find_readable_file(fp);
|
|
|
|
list_add(&dp->dl_perclnt, &dp->dl_client->cl_delegations);
|
|
|
|
status = vfs_setlease(fl->fl_file, fl->fl_type, &fl);
|
2011-01-31 23:58:10 +01:00
|
|
|
if (status) {
|
2011-02-01 01:20:39 +01:00
|
|
|
list_del_init(&dp->dl_perclnt);
|
2011-01-31 23:58:10 +01:00
|
|
|
locks_free_lock(fl);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2011-02-01 01:20:39 +01:00
|
|
|
fp->fi_lease = fl;
|
|
|
|
fp->fi_deleg_file = fl->fl_file;
|
|
|
|
get_file(fp->fi_deleg_file);
|
|
|
|
atomic_set(&fp->fi_delegees, 1);
|
|
|
|
list_add(&dp->dl_perfile, &fp->fi_delegations);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nfs4_set_delegation(struct nfs4_delegation *dp, int flag)
|
|
|
|
{
|
|
|
|
struct nfs4_file *fp = dp->dl_file;
|
|
|
|
|
|
|
|
if (!fp->fi_lease)
|
|
|
|
return nfs4_setlease(dp, flag);
|
|
|
|
spin_lock(&recall_lock);
|
|
|
|
if (fp->fi_had_conflict) {
|
|
|
|
spin_unlock(&recall_lock);
|
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
atomic_inc(&fp->fi_delegees);
|
|
|
|
list_add(&dp->dl_perfile, &fp->fi_delegations);
|
|
|
|
spin_unlock(&recall_lock);
|
|
|
|
list_add(&dp->dl_perclnt, &dp->dl_client->cl_delegations);
|
2011-01-31 23:58:10 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Attempt to hand out a delegation.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open, struct nfs4_stateid *stp)
|
|
|
|
{
|
|
|
|
struct nfs4_delegation *dp;
|
|
|
|
struct nfs4_stateowner *sop = stp->st_stateowner;
|
2010-12-11 01:02:49 +01:00
|
|
|
int cb_up;
|
2005-04-17 00:20:36 +02:00
|
|
|
int status, flag = 0;
|
|
|
|
|
2010-12-11 01:02:49 +01:00
|
|
|
cb_up = nfsd4_cb_channel_good(sop->so_client);
|
2005-04-17 00:20:36 +02:00
|
|
|
flag = NFS4_OPEN_DELEGATE_NONE;
|
2005-06-24 07:03:23 +02:00
|
|
|
open->op_recall = 0;
|
|
|
|
switch (open->op_claim_type) {
|
|
|
|
case NFS4_OPEN_CLAIM_PREVIOUS:
|
2010-03-08 18:37:27 +01:00
|
|
|
if (!cb_up)
|
2005-06-24 07:03:23 +02:00
|
|
|
open->op_recall = 1;
|
|
|
|
flag = open->op_delegate_type;
|
|
|
|
if (flag == NFS4_OPEN_DELEGATE_NONE)
|
|
|
|
goto out;
|
|
|
|
break;
|
|
|
|
case NFS4_OPEN_CLAIM_NULL:
|
|
|
|
/* Let's not give out any delegations till everyone's
|
|
|
|
* had the chance to reclaim theirs.... */
|
2007-09-06 18:34:25 +02:00
|
|
|
if (locks_in_grace())
|
2005-06-24 07:03:23 +02:00
|
|
|
goto out;
|
2010-03-08 18:37:27 +01:00
|
|
|
if (!cb_up || !sop->so_confirmed)
|
2005-06-24 07:03:23 +02:00
|
|
|
goto out;
|
|
|
|
if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
|
|
|
|
flag = NFS4_OPEN_DELEGATE_WRITE;
|
|
|
|
else
|
|
|
|
flag = NFS4_OPEN_DELEGATE_READ;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
dp = alloc_init_deleg(sop->so_client, stp, fh, flag);
|
2011-01-31 23:14:55 +01:00
|
|
|
if (dp == NULL)
|
|
|
|
goto out_no_deleg;
|
2011-02-01 01:20:39 +01:00
|
|
|
status = nfs4_set_delegation(dp, flag);
|
2011-01-31 23:58:10 +01:00
|
|
|
if (status)
|
2011-01-31 23:14:55 +01:00
|
|
|
goto out_free;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
memcpy(&open->op_delegate_stateid, &dp->dl_stateid, sizeof(dp->dl_stateid));
|
|
|
|
|
2009-10-19 12:04:53 +02:00
|
|
|
dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
|
|
|
|
STATEID_VAL(&dp->dl_stateid));
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
2005-06-24 07:03:23 +02:00
|
|
|
if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS
|
|
|
|
&& flag == NFS4_OPEN_DELEGATE_NONE
|
|
|
|
&& open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE)
|
2007-07-27 22:10:37 +02:00
|
|
|
dprintk("NFSD: WARNING: refusing delegation reclaim\n");
|
2005-04-17 00:20:36 +02:00
|
|
|
open->op_delegate_type = flag;
|
2011-01-31 23:14:55 +01:00
|
|
|
return;
|
|
|
|
out_free:
|
2011-02-01 01:20:39 +01:00
|
|
|
nfs4_put_delegation(dp);
|
2011-01-31 23:14:55 +01:00
|
|
|
out_no_deleg:
|
|
|
|
flag = NFS4_OPEN_DELEGATE_NONE;
|
|
|
|
goto out;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* called with nfs4_lock_state() held.
|
|
|
|
*/
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32
|
2005-04-17 00:20:36 +02:00
|
|
|
nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
|
|
|
|
{
|
2009-04-03 07:28:45 +02:00
|
|
|
struct nfsd4_compoundres *resp = rqstp->rq_resp;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct nfs4_file *fp = NULL;
|
|
|
|
struct inode *ino = current_fh->fh_dentry->d_inode;
|
|
|
|
struct nfs4_stateid *stp = NULL;
|
2005-06-24 07:02:53 +02:00
|
|
|
struct nfs4_delegation *dp = NULL;
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32 status;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
status = nfserr_inval;
|
2009-04-03 07:28:53 +02:00
|
|
|
if (!access_valid(open->op_share_access, resp->cstate.minorversion)
|
2006-06-30 10:56:16 +02:00
|
|
|
|| !deny_valid(open->op_share_deny))
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
fp = find_file(ino);
|
|
|
|
if (fp) {
|
|
|
|
if ((status = nfs4_check_open(fp, open, &stp)))
|
|
|
|
goto out;
|
2005-06-24 07:02:54 +02:00
|
|
|
status = nfs4_check_deleg(fp, open, &dp);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
2005-04-17 00:20:36 +02:00
|
|
|
} else {
|
2005-06-24 07:02:54 +02:00
|
|
|
status = nfserr_bad_stateid;
|
|
|
|
if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
|
|
|
|
goto out;
|
2005-04-17 00:20:36 +02:00
|
|
|
status = nfserr_resource;
|
|
|
|
fp = alloc_init_file(ino);
|
|
|
|
if (fp == NULL)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* OPEN the file, or upgrade an existing OPEN.
|
|
|
|
* If truncate fails, the OPEN fails.
|
|
|
|
*/
|
|
|
|
if (stp) {
|
|
|
|
/* Stateid was found, this is an OPEN upgrade */
|
2010-07-08 17:02:09 +02:00
|
|
|
status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (status)
|
|
|
|
goto out;
|
2005-07-08 02:59:22 +02:00
|
|
|
update_stateid(&stp->st_stateid);
|
2005-04-17 00:20:36 +02:00
|
|
|
} else {
|
2010-07-08 17:02:09 +02:00
|
|
|
status = nfs4_new_open(rqstp, &stp, fp, current_fh, open);
|
2005-06-24 07:02:53 +02:00
|
|
|
if (status)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
init_stateid(stp, fp, open);
|
|
|
|
status = nfsd4_truncate(rqstp, current_fh, open);
|
|
|
|
if (status) {
|
2009-01-11 20:27:17 +01:00
|
|
|
release_open_stateid(stp);
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
}
|
2009-04-03 07:28:45 +02:00
|
|
|
if (nfsd4_has_session(&resp->cstate))
|
|
|
|
update_stateid(&stp->st_stateid);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
memcpy(&open->op_stateid, &stp->st_stateid, sizeof(stateid_t));
|
|
|
|
|
2010-04-19 21:11:28 +02:00
|
|
|
if (nfsd4_has_session(&resp->cstate))
|
2009-04-03 07:28:45 +02:00
|
|
|
open->op_stateowner->so_confirmed = 1;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Attempt to hand out a delegation. No error return, because the
|
|
|
|
* OPEN succeeds even if we fail.
|
|
|
|
*/
|
|
|
|
nfs4_open_delegation(current_fh, open, stp);
|
|
|
|
|
|
|
|
status = nfs_ok;
|
|
|
|
|
2009-10-19 12:04:53 +02:00
|
|
|
dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
|
|
|
|
STATEID_VAL(&stp->st_stateid));
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
2005-06-24 07:03:10 +02:00
|
|
|
if (fp)
|
|
|
|
put_nfs4_file(fp);
|
2005-07-08 02:59:16 +02:00
|
|
|
if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
|
|
|
|
nfs4_set_claim_prev(open);
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* To finish the open response, we just need to set the rflags.
|
|
|
|
*/
|
|
|
|
open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
|
2009-04-03 07:28:45 +02:00
|
|
|
if (!open->op_stateowner->so_confirmed &&
|
|
|
|
!nfsd4_has_session(&resp->cstate))
|
2005-04-17 00:20:36 +02:00
|
|
|
open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32
|
2006-12-13 09:35:38 +01:00
|
|
|
nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
clientid_t *clid)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct nfs4_client *clp;
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32 status;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
nfs4_lock_state();
|
|
|
|
dprintk("process_renew(%08x/%08x): starting\n",
|
|
|
|
clid->cl_boot, clid->cl_id);
|
|
|
|
status = nfserr_stale_clientid;
|
|
|
|
if (STALE_CLIENTID(clid))
|
|
|
|
goto out;
|
|
|
|
clp = find_confirmed_client(clid);
|
|
|
|
status = nfserr_expired;
|
|
|
|
if (clp == NULL) {
|
|
|
|
/* We assume the client took too long to RENEW. */
|
|
|
|
dprintk("nfsd4_renew: clientid not found!\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
renew_client(clp);
|
|
|
|
status = nfserr_cb_path_down;
|
2005-06-24 07:04:17 +02:00
|
|
|
if (!list_empty(&clp->cl_delegations)
|
2010-05-01 00:51:44 +02:00
|
|
|
&& clp->cl_cb_state != NFSD4_CB_UP)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
status = nfs_ok;
|
|
|
|
out:
|
|
|
|
nfs4_unlock_state();
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2011-05-16 16:38:14 +02:00
|
|
|
static struct lock_manager nfsd4_manager = {
|
2007-09-06 18:34:25 +02:00
|
|
|
};
|
|
|
|
|
2005-06-24 07:04:01 +02:00
|
|
|
static void
|
2007-09-06 18:34:25 +02:00
|
|
|
nfsd4_end_grace(void)
|
2005-06-24 07:04:01 +02:00
|
|
|
{
|
|
|
|
dprintk("NFSD: end of grace period\n");
|
2005-06-24 07:04:30 +02:00
|
|
|
nfsd4_recdir_purge_old();
|
2007-09-06 18:34:25 +02:00
|
|
|
locks_end_grace(&nfsd4_manager);
|
2010-03-02 01:21:21 +01:00
|
|
|
/*
|
|
|
|
* Now that every NFSv4 client has had the chance to recover and
|
|
|
|
* to see the (possibly new, possibly shorter) lease time, we
|
|
|
|
* can safely set the next grace time to the current lease time:
|
|
|
|
*/
|
|
|
|
nfsd4_grace = nfsd4_lease;
|
2005-06-24 07:04:01 +02:00
|
|
|
}
|
|
|
|
|
2005-06-24 07:04:03 +02:00
|
|
|
static time_t
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_laundromat(void)
|
|
|
|
{
|
|
|
|
struct nfs4_client *clp;
|
|
|
|
struct nfs4_stateowner *sop;
|
|
|
|
struct nfs4_delegation *dp;
|
|
|
|
struct list_head *pos, *next, reaplist;
|
2010-03-01 05:20:19 +01:00
|
|
|
time_t cutoff = get_seconds() - nfsd4_lease;
|
|
|
|
time_t t, clientid_val = nfsd4_lease;
|
|
|
|
time_t u, test_val = nfsd4_lease;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
nfs4_lock_state();
|
|
|
|
|
|
|
|
dprintk("NFSD: laundromat service - starting\n");
|
2007-09-06 18:34:25 +02:00
|
|
|
if (locks_in_grace())
|
|
|
|
nfsd4_end_grace();
|
2010-05-11 23:13:04 +02:00
|
|
|
INIT_LIST_HEAD(&reaplist);
|
|
|
|
spin_lock(&client_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
list_for_each_safe(pos, next, &client_lru) {
|
|
|
|
clp = list_entry(pos, struct nfs4_client, cl_lru);
|
|
|
|
if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
|
|
|
|
t = clp->cl_time - cutoff;
|
|
|
|
if (clientid_val > t)
|
|
|
|
clientid_val = t;
|
|
|
|
break;
|
|
|
|
}
|
2010-05-11 23:13:54 +02:00
|
|
|
if (atomic_read(&clp->cl_refcount)) {
|
|
|
|
dprintk("NFSD: client in use (clientid %08x)\n",
|
|
|
|
clp->cl_clientid.cl_id);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
unhash_client_locked(clp);
|
|
|
|
list_add(&clp->cl_lru, &reaplist);
|
2010-05-11 23:13:04 +02:00
|
|
|
}
|
|
|
|
spin_unlock(&client_lock);
|
|
|
|
list_for_each_safe(pos, next, &reaplist) {
|
|
|
|
clp = list_entry(pos, struct nfs4_client, cl_lru);
|
2005-04-17 00:20:36 +02:00
|
|
|
dprintk("NFSD: purging unused client (clientid %08x)\n",
|
|
|
|
clp->cl_clientid.cl_id);
|
2005-06-24 07:04:30 +02:00
|
|
|
nfsd4_remove_clid_dir(clp);
|
2005-04-17 00:20:36 +02:00
|
|
|
expire_client(clp);
|
|
|
|
}
|
|
|
|
spin_lock(&recall_lock);
|
|
|
|
list_for_each_safe(pos, next, &del_recall_lru) {
|
|
|
|
dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
|
|
|
|
if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
|
|
|
|
u = dp->dl_time - cutoff;
|
|
|
|
if (test_val > u)
|
|
|
|
test_val = u;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
list_move(&dp->dl_recall_lru, &reaplist);
|
|
|
|
}
|
|
|
|
spin_unlock(&recall_lock);
|
|
|
|
list_for_each_safe(pos, next, &reaplist) {
|
|
|
|
dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
|
|
|
|
list_del_init(&dp->dl_recall_lru);
|
|
|
|
unhash_delegation(dp);
|
|
|
|
}
|
2010-03-01 05:20:19 +01:00
|
|
|
test_val = nfsd4_lease;
|
2005-04-17 00:20:36 +02:00
|
|
|
list_for_each_safe(pos, next, &close_lru) {
|
|
|
|
sop = list_entry(pos, struct nfs4_stateowner, so_close_lru);
|
|
|
|
if (time_after((unsigned long)sop->so_time, (unsigned long)cutoff)) {
|
|
|
|
u = sop->so_time - cutoff;
|
|
|
|
if (test_val > u)
|
|
|
|
test_val = u;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
dprintk("NFSD: purging unused open stateowner (so_id %d)\n",
|
|
|
|
sop->so_id);
|
2009-01-11 21:24:04 +01:00
|
|
|
release_openowner(sop);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT)
|
|
|
|
clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT;
|
|
|
|
nfs4_unlock_state();
|
|
|
|
return clientid_val;
|
|
|
|
}
|
|
|
|
|
2008-02-20 21:49:00 +01:00
|
|
|
static struct workqueue_struct *laundry_wq;
|
|
|
|
static void laundromat_main(struct work_struct *);
|
|
|
|
static DECLARE_DELAYED_WORK(laundromat_work, laundromat_main);
|
|
|
|
|
|
|
|
static void
|
2006-11-22 15:57:56 +01:00
|
|
|
laundromat_main(struct work_struct *not_used)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
time_t t;
|
|
|
|
|
|
|
|
t = nfs4_laundromat();
|
|
|
|
dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
|
2005-06-24 07:03:19 +02:00
|
|
|
queue_delayed_work(laundry_wq, &laundromat_work, t*HZ);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2005-06-24 07:04:03 +02:00
|
|
|
static struct nfs4_stateowner *
|
2005-07-08 02:59:25 +02:00
|
|
|
search_close_lru(u32 st_id, int flags)
|
|
|
|
{
|
2005-04-17 00:20:36 +02:00
|
|
|
struct nfs4_stateowner *local = NULL;
|
|
|
|
|
|
|
|
if (flags & CLOSE_STATE) {
|
|
|
|
list_for_each_entry(local, &close_lru, so_close_lru) {
|
|
|
|
if (local->so_id == st_id)
|
|
|
|
return local;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
nfs4_check_fh(struct svc_fh *fhp, struct nfs4_stateid *stp)
|
|
|
|
{
|
2010-07-08 17:02:09 +02:00
|
|
|
return fhp->fh_dentry->d_inode != stp->st_file->fi_inode;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
STALE_STATEID(stateid_t *stateid)
|
|
|
|
{
|
2010-04-22 22:21:39 +02:00
|
|
|
if (stateid->si_boot == boot_time)
|
|
|
|
return 0;
|
|
|
|
dprintk("NFSD: stale stateid " STATEID_FMT "!\n",
|
2009-10-19 12:04:53 +02:00
|
|
|
STATEID_VAL(stateid));
|
2010-04-22 22:21:39 +02:00
|
|
|
return 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
access_permit_read(unsigned long access_bmap)
|
|
|
|
{
|
|
|
|
return test_bit(NFS4_SHARE_ACCESS_READ, &access_bmap) ||
|
|
|
|
test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap) ||
|
|
|
|
test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
access_permit_write(unsigned long access_bmap)
|
|
|
|
{
|
|
|
|
return test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap) ||
|
|
|
|
test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
static
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32 nfs4_check_openmode(struct nfs4_stateid *stp, int flags)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32 status = nfserr_openmode;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-07-29 21:16:59 +02:00
|
|
|
/* For lock stateid's, we test the parent open, not the lock: */
|
|
|
|
if (stp->st_openstp)
|
|
|
|
stp = stp->st_openstp;
|
2005-04-17 00:20:36 +02:00
|
|
|
if ((flags & WR_STATE) && (!access_permit_write(stp->st_access_bmap)))
|
|
|
|
goto out;
|
|
|
|
if ((flags & RD_STATE) && (!access_permit_read(stp->st_access_bmap)))
|
|
|
|
goto out;
|
|
|
|
status = nfs_ok;
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-10-20 08:28:59 +02:00
|
|
|
static inline __be32
|
2005-04-17 00:20:36 +02:00
|
|
|
check_special_stateids(svc_fh *current_fh, stateid_t *stateid, int flags)
|
|
|
|
{
|
2009-02-21 22:29:14 +01:00
|
|
|
if (ONE_STATEID(stateid) && (flags & RD_STATE))
|
2005-04-17 00:20:36 +02:00
|
|
|
return nfs_ok;
|
2007-09-06 18:34:25 +02:00
|
|
|
else if (locks_in_grace()) {
|
2011-03-31 03:57:33 +02:00
|
|
|
/* Answer in remaining cases depends on existence of
|
2005-04-17 00:20:36 +02: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);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allow READ/WRITE during grace period on recovered state only for files
|
|
|
|
* that are not able to provide mandatory locking.
|
|
|
|
*/
|
|
|
|
static inline int
|
2009-02-22 00:23:01 +01:00
|
|
|
grace_disallows_io(struct inode *inode)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2009-02-21 22:29:14 +01:00
|
|
|
return locks_in_grace() && mandatory_lock(inode);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2009-04-03 07:28:45 +02:00
|
|
|
static int check_stateid_generation(stateid_t *in, stateid_t *ref, int flags)
|
2008-01-27 01:08:12 +01:00
|
|
|
{
|
2009-04-03 07:28:45 +02:00
|
|
|
/*
|
|
|
|
* When sessions are used the stateid generation number is ignored
|
|
|
|
* when it is zero.
|
|
|
|
*/
|
|
|
|
if ((flags & HAS_SESSION) && in->si_generation == 0)
|
|
|
|
goto out;
|
|
|
|
|
2008-01-27 01:08:12 +01:00
|
|
|
/* If the client sends us a stateid from the future, it's buggy: */
|
|
|
|
if (in->si_generation > ref->si_generation)
|
|
|
|
return nfserr_bad_stateid;
|
|
|
|
/*
|
|
|
|
* The following, however, can happen. For example, if the
|
|
|
|
* client sends an open and some IO at the same time, the open
|
|
|
|
* may bump si_generation while the IO is still in flight.
|
|
|
|
* Thanks to hard links and renames, the client never knows what
|
|
|
|
* file an open will affect. So it could avoid that situation
|
|
|
|
* only by serializing all opens and IO from the same open
|
|
|
|
* owner. To recover from the old_stateid error, the client
|
|
|
|
* will just have to retry the IO:
|
|
|
|
*/
|
|
|
|
if (in->si_generation < ref->si_generation)
|
|
|
|
return nfserr_old_stateid;
|
2009-04-03 07:28:45 +02:00
|
|
|
out:
|
2008-01-27 01:08:12 +01:00
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2009-02-21 22:17:19 +01:00
|
|
|
static int is_delegation_stateid(stateid_t *stateid)
|
|
|
|
{
|
|
|
|
return stateid->si_fileid == 0;
|
|
|
|
}
|
|
|
|
|
2011-07-13 17:04:21 +02:00
|
|
|
static int is_open_stateid(struct nfs4_stateid *stateid)
|
|
|
|
{
|
|
|
|
return stateid->st_openstp == NULL;
|
|
|
|
}
|
|
|
|
|
2011-07-13 16:50:48 +02:00
|
|
|
__be32 nfs4_validate_stateid(stateid_t *stateid, int flags)
|
|
|
|
{
|
|
|
|
struct nfs4_stateid *stp = NULL;
|
|
|
|
__be32 status = nfserr_stale_stateid;
|
|
|
|
|
|
|
|
if (STALE_STATEID(stateid))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
status = nfserr_expired;
|
|
|
|
stp = search_for_stateid(stateid);
|
|
|
|
if (!stp)
|
|
|
|
goto out;
|
|
|
|
status = nfserr_bad_stateid;
|
|
|
|
|
|
|
|
if (!stp->st_stateowner->so_confirmed)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
status = check_stateid_generation(stateid, &stp->st_stateid, flags);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
status = nfs_ok;
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Checks for stateid operations
|
|
|
|
*/
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32
|
2009-04-03 07:28:41 +02:00
|
|
|
nfs4_preprocess_stateid_op(struct nfsd4_compound_state *cstate,
|
|
|
|
stateid_t *stateid, int flags, struct file **filpp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct nfs4_stateid *stp = NULL;
|
|
|
|
struct nfs4_delegation *dp = NULL;
|
2009-04-03 07:28:41 +02:00
|
|
|
struct svc_fh *current_fh = &cstate->current_fh;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct inode *ino = current_fh->fh_dentry->d_inode;
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32 status;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (filpp)
|
|
|
|
*filpp = NULL;
|
|
|
|
|
2009-02-22 00:23:01 +01:00
|
|
|
if (grace_disallows_io(ino))
|
2005-04-17 00:20:36 +02:00
|
|
|
return nfserr_grace;
|
|
|
|
|
2009-04-03 07:28:45 +02:00
|
|
|
if (nfsd4_has_session(cstate))
|
|
|
|
flags |= HAS_SESSION;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
|
|
|
|
return check_special_stateids(current_fh, stateid, flags);
|
|
|
|
|
|
|
|
status = nfserr_stale_stateid;
|
|
|
|
if (STALE_STATEID(stateid))
|
|
|
|
goto out;
|
|
|
|
|
2010-10-03 00:42:39 +02:00
|
|
|
/*
|
|
|
|
* We assume that any stateid that has the current boot time,
|
|
|
|
* but that we can't find, is expired:
|
|
|
|
*/
|
|
|
|
status = nfserr_expired;
|
2009-02-21 22:17:19 +01:00
|
|
|
if (is_delegation_stateid(stateid)) {
|
2009-02-21 19:40:22 +01:00
|
|
|
dp = find_delegation_stateid(ino, stateid);
|
2010-04-22 22:21:39 +02:00
|
|
|
if (!dp)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
2009-04-03 07:28:45 +02:00
|
|
|
status = check_stateid_generation(stateid, &dp->dl_stateid,
|
|
|
|
flags);
|
2009-02-21 20:11:50 +01:00
|
|
|
if (status)
|
|
|
|
goto out;
|
2009-02-21 20:14:43 +01:00
|
|
|
status = nfs4_check_delegmode(dp, flags);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
renew_client(dp->dl_client);
|
2010-10-27 23:19:04 +02:00
|
|
|
if (filpp) {
|
2011-02-01 01:20:39 +01:00
|
|
|
*filpp = dp->dl_file->fi_deleg_file;
|
2010-10-27 23:19:04 +02:00
|
|
|
BUG_ON(!*filpp);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
} else { /* open or lock stateid */
|
2009-02-21 19:40:22 +01:00
|
|
|
stp = find_stateid(stateid, flags);
|
2010-04-22 22:21:39 +02:00
|
|
|
if (!stp)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
2010-10-03 00:42:39 +02:00
|
|
|
status = nfserr_bad_stateid;
|
2009-02-21 22:36:16 +01:00
|
|
|
if (nfs4_check_fh(current_fh, stp))
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
if (!stp->st_stateowner->so_confirmed)
|
|
|
|
goto out;
|
2009-04-03 07:28:45 +02:00
|
|
|
status = check_stateid_generation(stateid, &stp->st_stateid,
|
|
|
|
flags);
|
2009-02-21 20:11:50 +01:00
|
|
|
if (status)
|
|
|
|
goto out;
|
2009-02-21 19:40:22 +01:00
|
|
|
status = nfs4_check_openmode(stp, flags);
|
|
|
|
if (status)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
renew_client(stp->st_stateowner->so_client);
|
2010-07-08 17:02:09 +02:00
|
|
|
if (filpp) {
|
|
|
|
if (flags & RD_STATE)
|
|
|
|
*filpp = find_readable_file(stp->st_file);
|
|
|
|
else
|
|
|
|
*filpp = find_writeable_file(stp->st_file);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
status = nfs_ok;
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2011-07-13 17:04:21 +02:00
|
|
|
static __be32
|
|
|
|
nfsd4_free_delegation_stateid(stateid_t *stateid)
|
|
|
|
{
|
|
|
|
struct nfs4_delegation *dp = search_for_delegation(stateid);
|
|
|
|
if (dp)
|
|
|
|
return nfserr_locks_held;
|
|
|
|
return nfserr_bad_stateid;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __be32
|
|
|
|
nfsd4_free_lock_stateid(struct nfs4_stateid *stp)
|
|
|
|
{
|
|
|
|
if (check_for_locks(stp->st_file, stp->st_stateowner))
|
|
|
|
return nfserr_locks_held;
|
|
|
|
release_lock_stateid(stp);
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2011-07-13 16:50:48 +02:00
|
|
|
/*
|
|
|
|
* Test if the stateid is valid
|
|
|
|
*/
|
|
|
|
__be32
|
|
|
|
nfsd4_test_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_test_stateid *test_stateid)
|
|
|
|
{
|
|
|
|
test_stateid->ts_has_session = nfsd4_has_session(cstate);
|
|
|
|
return nfs_ok;
|
|
|
|
}
|
|
|
|
|
2011-07-13 17:04:21 +02:00
|
|
|
/*
|
|
|
|
* Free a state id
|
|
|
|
*/
|
|
|
|
__be32
|
|
|
|
nfsd4_free_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_free_stateid *free_stateid)
|
|
|
|
{
|
|
|
|
stateid_t *stateid = &free_stateid->fr_stateid;
|
|
|
|
struct nfs4_stateid *stp;
|
|
|
|
__be32 ret;
|
|
|
|
|
|
|
|
nfs4_lock_state();
|
|
|
|
if (is_delegation_stateid(stateid)) {
|
|
|
|
ret = nfsd4_free_delegation_stateid(stateid);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
stp = search_for_stateid(stateid);
|
|
|
|
if (!stp) {
|
|
|
|
ret = nfserr_bad_stateid;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (stateid->si_generation != 0) {
|
|
|
|
if (stateid->si_generation < stp->st_stateid.si_generation) {
|
|
|
|
ret = nfserr_old_stateid;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (stateid->si_generation > stp->st_stateid.si_generation) {
|
|
|
|
ret = nfserr_bad_stateid;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_open_stateid(stp)) {
|
|
|
|
ret = nfserr_locks_held;
|
|
|
|
goto out;
|
|
|
|
} else {
|
|
|
|
ret = nfsd4_free_lock_stateid(stp);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
nfs4_unlock_state();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-07-08 02:59:27 +02:00
|
|
|
static inline int
|
|
|
|
setlkflg (int type)
|
|
|
|
{
|
|
|
|
return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
|
|
|
|
RD_STATE : WR_STATE;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Checks for sequence id mutating operations.
|
|
|
|
*/
|
2006-10-20 08:28:59 +02:00
|
|
|
static __be32
|
2009-04-03 07:28:41 +02:00
|
|
|
nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
|
|
|
|
stateid_t *stateid, int flags,
|
|
|
|
struct nfs4_stateowner **sopp,
|
|
|
|
struct nfs4_stateid **stpp, struct nfsd4_lock *lock)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct nfs4_stateid *stp;
|
|
|
|
struct nfs4_stateowner *sop;
|
2009-04-03 07:28:41 +02:00
|
|
|
struct svc_fh *current_fh = &cstate->current_fh;
|
2008-01-27 01:08:12 +01:00
|
|
|
__be32 status;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-10-19 12:04:53 +02:00
|
|
|
dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
|
|
|
|
seqid, STATEID_VAL(stateid));
|
2005-07-08 02:59:26 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
*stpp = NULL;
|
|
|
|
*sopp = NULL;
|
|
|
|
|
|
|
|
if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) {
|
2007-07-27 22:10:37 +02:00
|
|
|
dprintk("NFSD: preprocess_seqid_op: magic stateid!\n");
|
2005-07-08 02:59:26 +02:00
|
|
|
return nfserr_bad_stateid;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (STALE_STATEID(stateid))
|
2005-07-08 02:59:26 +02:00
|
|
|
return nfserr_stale_stateid;
|
2009-04-03 07:28:45 +02:00
|
|
|
|
|
|
|
if (nfsd4_has_session(cstate))
|
|
|
|
flags |= HAS_SESSION;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* We return BAD_STATEID if filehandle doesn't match stateid,
|
|
|
|
* the confirmed flag is incorrecly set, or the generation
|
|
|
|
* number is incorrect.
|
|
|
|
*/
|
2005-07-08 02:59:25 +02:00
|
|
|
stp = find_stateid(stateid, flags);
|
|
|
|
if (stp == NULL) {
|
|
|
|
/*
|
|
|
|
* Also, we should make sure this isn't just the result of
|
|
|
|
* a replayed close:
|
|
|
|
*/
|
|
|
|
sop = search_close_lru(stateid->si_stateownerid, flags);
|
2010-10-03 00:42:39 +02:00
|
|
|
/* It's not stale; let's assume it's expired: */
|
2005-07-08 02:59:25 +02:00
|
|
|
if (sop == NULL)
|
2010-10-03 00:42:39 +02:00
|
|
|
return nfserr_expired;
|
2005-07-08 02:59:25 +02:00
|
|
|
*sopp = sop;
|
|
|
|
goto check_replay;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-11-26 23:06:39 +01:00
|
|
|
*stpp = stp;
|
|
|
|
*sopp = sop = stp->st_stateowner;
|
|
|
|
|
2005-07-08 02:59:27 +02:00
|
|
|
if (lock) {
|
|
|
|
clientid_t *lockclid = &lock->v.new.clientid;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct nfs4_client *clp = sop->so_client;
|
2005-07-08 02:59:27 +02:00
|
|
|
int lkflg = 0;
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32 status;
|
2005-07-08 02:59:27 +02:00
|
|
|
|
|
|
|
lkflg = setlkflg(lock->lk_type);
|
|
|
|
|
|
|
|
if (lock->lk_is_new) {
|
2007-07-26 23:04:54 +02:00
|
|
|
if (!sop->so_is_open_owner)
|
|
|
|
return nfserr_bad_stateid;
|
2009-04-03 07:28:50 +02:00
|
|
|
if (!(flags & HAS_SESSION) &&
|
|
|
|
!same_clid(&clp->cl_clientid, lockclid))
|
|
|
|
return nfserr_bad_stateid;
|
2007-07-26 23:04:54 +02:00
|
|
|
/* stp is the open stateid */
|
|
|
|
status = nfs4_check_openmode(stp, lkflg);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
} else {
|
|
|
|
/* stp is the lock stateid */
|
|
|
|
status = nfs4_check_openmode(stp->st_openstp, lkflg);
|
|
|
|
if (status)
|
|
|
|
return status;
|
2005-07-08 02:59:27 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-01-26 20:58:45 +01:00
|
|
|
if (nfs4_check_fh(current_fh, stp)) {
|
2007-07-27 22:10:37 +02:00
|
|
|
dprintk("NFSD: preprocess_seqid_op: fh-stateid mismatch!\n");
|
2005-07-08 02:59:26 +02:00
|
|
|
return nfserr_bad_stateid;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We now validate the seqid and stateid generation numbers.
|
|
|
|
* For the moment, we ignore the possibility of
|
|
|
|
* generation number wraparound.
|
|
|
|
*/
|
2009-04-03 07:28:45 +02:00
|
|
|
if (!(flags & HAS_SESSION) && seqid != sop->so_seqid)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto check_replay;
|
|
|
|
|
2005-07-08 02:59:26 +02:00
|
|
|
if (sop->so_confirmed && flags & CONFIRM) {
|
2007-07-27 22:10:37 +02:00
|
|
|
dprintk("NFSD: preprocess_seqid_op: expected"
|
2005-07-08 02:59:26 +02:00
|
|
|
" unconfirmed stateowner!\n");
|
|
|
|
return nfserr_bad_stateid;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2005-07-08 02:59:26 +02:00
|
|
|
if (!sop->so_confirmed && !(flags & CONFIRM)) {
|
2007-07-27 22:10:37 +02:00
|
|
|
dprintk("NFSD: preprocess_seqid_op: stateowner not"
|
2005-07-08 02:59:26 +02:00
|
|
|
" confirmed yet!\n");
|
|
|
|
return nfserr_bad_stateid;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2009-04-03 07:28:45 +02:00
|
|
|
status = check_stateid_generation(stateid, &stp->st_stateid, flags);
|
2008-01-27 01:08:12 +01:00
|
|
|
if (status)
|
|
|
|
return status;
|
2005-07-08 02:59:24 +02:00
|
|
|
renew_client(sop->so_client);
|
2005-07-08 02:59:26 +02:00
|
|
|
return nfs_ok;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
check_replay:
|
[PATCH] nfsd4: fix open_reclaim seqid
The sequence number we store in the sequence id is the last one we received
from the client. So on the next operation we'll check that the client gives
us the next higher number.
We increment sequence id's at the last moment, in encode, so that we're sure
of knowing the right error return. (The decision to increment the sequence id
depends on the exact error returned.)
However on the *first* use of a sequence number, if we set the sequence number
to the one received from the client and then let the increment happen on
encode, we'll be left with a sequence number one to high.
For that reason, ENCODE_SEQID_OP_TAIL only increments the sequence id on
*confirmed* stateowners.
This creates a problem for open reclaims, which are confirmed on first use.
Therefore the open reclaim code, as a special exception, *decrements* the
sequence id, cancelling out the undesired increment on encode. But this
prevents the sequence id from ever being incremented in the case where
multiple reclaims are sent with the same openowner. Yuch!
We could add another exception to the open reclaim code, decrementing the
sequence id only if this is the first use of the open owner.
But it's simpler by far to modify the meaning of the op_seqid field: instead
of representing the previous value sent by the client, we take op_seqid, after
encoding, to represent the *next* sequence id that we expect from the client.
This eliminates the need for special-case handling of the first use of a
stateowner.
Signed-off-by: J. Bruce Fields <bfields@citi.umich.edu>
Signed-off-by: Neil Brown <neilb@cse.unsw.edu.au>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-08 02:59:19 +02:00
|
|
|
if (seqid == sop->so_seqid - 1) {
|
2005-09-13 10:25:36 +02:00
|
|
|
dprintk("NFSD: preprocess_seqid_op: retransmission?\n");
|
2005-04-17 00:20:36 +02:00
|
|
|
/* indicate replay to calling function */
|
2006-10-20 08:29:03 +02:00
|
|
|
return nfserr_replay_me;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2007-07-27 22:10:37 +02:00
|
|
|
dprintk("NFSD: preprocess_seqid_op: bad seqid (expected %d, got %d)\n",
|
2005-07-08 02:59:26 +02:00
|
|
|
sop->so_seqid, seqid);
|
|
|
|
*sopp = NULL;
|
|
|
|
return nfserr_bad_seqid;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32
|
2006-12-13 09:35:27 +01:00
|
|
|
nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2006-12-13 09:35:28 +01:00
|
|
|
struct nfsd4_open_confirm *oc)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32 status;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct nfs4_stateowner *sop;
|
|
|
|
struct nfs4_stateid *stp;
|
|
|
|
|
|
|
|
dprintk("NFSD: nfsd4_open_confirm on file %.*s\n",
|
2006-12-13 09:35:27 +01:00
|
|
|
(int)cstate->current_fh.fh_dentry->d_name.len,
|
|
|
|
cstate->current_fh.fh_dentry->d_name.name);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-12-13 09:35:27 +01:00
|
|
|
status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
|
2006-06-30 10:56:13 +02:00
|
|
|
if (status)
|
|
|
|
return status;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
nfs4_lock_state();
|
|
|
|
|
2009-04-03 07:28:41 +02:00
|
|
|
if ((status = nfs4_preprocess_seqid_op(cstate,
|
2006-12-13 09:35:27 +01:00
|
|
|
oc->oc_seqid, &oc->oc_req_stateid,
|
2008-01-26 20:58:45 +01:00
|
|
|
CONFIRM | OPEN_STATE,
|
2005-04-17 00:20:36 +02:00
|
|
|
&oc->oc_stateowner, &stp, NULL)))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
sop = oc->oc_stateowner;
|
|
|
|
sop->so_confirmed = 1;
|
|
|
|
update_stateid(&stp->st_stateid);
|
|
|
|
memcpy(&oc->oc_resp_stateid, &stp->st_stateid, sizeof(stateid_t));
|
2009-10-19 12:04:53 +02:00
|
|
|
dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n",
|
|
|
|
__func__, oc->oc_seqid, STATEID_VAL(&stp->st_stateid));
|
2005-06-24 07:04:30 +02:00
|
|
|
|
|
|
|
nfsd4_create_clid_dir(sop->so_client);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
2005-09-13 10:25:37 +02:00
|
|
|
if (oc->oc_stateowner) {
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_get_stateowner(oc->oc_stateowner);
|
2006-12-13 09:35:28 +01:00
|
|
|
cstate->replay_owner = oc->oc_stateowner;
|
2005-09-13 10:25:37 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_unlock_state();
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2011-06-29 14:23:50 +02:00
|
|
|
static inline void nfs4_file_downgrade(struct nfs4_stateid *stp, unsigned int to_access)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int i;
|
2011-06-29 14:23:50 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
for (i = 1; i < 4; i++) {
|
2011-06-29 14:23:50 +02:00
|
|
|
if (test_bit(i, &stp->st_access_bmap) && !(i & to_access)) {
|
|
|
|
nfs4_file_put_access(stp->st_file, i);
|
|
|
|
__clear_bit(i, &stp->st_access_bmap);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
reset_union_bmap_deny(unsigned long deny, unsigned long *bmap)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
if ((i & deny) != i)
|
|
|
|
__clear_bit(i, bmap);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32
|
2006-12-13 09:35:27 +01:00
|
|
|
nfsd4_open_downgrade(struct svc_rqst *rqstp,
|
|
|
|
struct nfsd4_compound_state *cstate,
|
2006-12-13 09:35:28 +01:00
|
|
|
struct nfsd4_open_downgrade *od)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32 status;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct nfs4_stateid *stp;
|
|
|
|
|
|
|
|
dprintk("NFSD: nfsd4_open_downgrade on file %.*s\n",
|
2006-12-13 09:35:27 +01:00
|
|
|
(int)cstate->current_fh.fh_dentry->d_name.len,
|
|
|
|
cstate->current_fh.fh_dentry->d_name.name);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-04-03 07:28:53 +02:00
|
|
|
if (!access_valid(od->od_share_access, cstate->minorversion)
|
2006-06-30 10:56:16 +02:00
|
|
|
|| !deny_valid(od->od_share_deny))
|
2005-04-17 00:20:36 +02:00
|
|
|
return nfserr_inval;
|
|
|
|
|
|
|
|
nfs4_lock_state();
|
2009-04-03 07:28:41 +02:00
|
|
|
if ((status = nfs4_preprocess_seqid_op(cstate,
|
2006-12-13 09:35:27 +01:00
|
|
|
od->od_seqid,
|
2005-04-17 00:20:36 +02:00
|
|
|
&od->od_stateid,
|
2008-01-26 20:58:45 +01:00
|
|
|
OPEN_STATE,
|
2005-04-17 00:20:36 +02:00
|
|
|
&od->od_stateowner, &stp, NULL)))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
status = nfserr_inval;
|
|
|
|
if (!test_bit(od->od_share_access, &stp->st_access_bmap)) {
|
|
|
|
dprintk("NFSD:access not a subset current bitmap: 0x%lx, input access=%08x\n",
|
|
|
|
stp->st_access_bmap, od->od_share_access);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (!test_bit(od->od_share_deny, &stp->st_deny_bmap)) {
|
|
|
|
dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
|
|
|
|
stp->st_deny_bmap, od->od_share_deny);
|
|
|
|
goto out;
|
|
|
|
}
|
2011-06-29 14:23:50 +02:00
|
|
|
nfs4_file_downgrade(stp, od->od_share_access);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
reset_union_bmap_deny(od->od_share_deny, &stp->st_deny_bmap);
|
|
|
|
|
|
|
|
update_stateid(&stp->st_stateid);
|
|
|
|
memcpy(&od->od_stateid, &stp->st_stateid, sizeof(stateid_t));
|
|
|
|
status = nfs_ok;
|
|
|
|
out:
|
2005-09-13 10:25:37 +02:00
|
|
|
if (od->od_stateowner) {
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_get_stateowner(od->od_stateowner);
|
2006-12-13 09:35:28 +01:00
|
|
|
cstate->replay_owner = od->od_stateowner;
|
2005-09-13 10:25:37 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_unlock_state();
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* nfs4_unlock_state() called after encode
|
|
|
|
*/
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32
|
2006-12-13 09:35:27 +01:00
|
|
|
nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2006-12-13 09:35:28 +01:00
|
|
|
struct nfsd4_close *close)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32 status;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct nfs4_stateid *stp;
|
|
|
|
|
|
|
|
dprintk("NFSD: nfsd4_close on file %.*s\n",
|
2006-12-13 09:35:27 +01:00
|
|
|
(int)cstate->current_fh.fh_dentry->d_name.len,
|
|
|
|
cstate->current_fh.fh_dentry->d_name.name);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
nfs4_lock_state();
|
|
|
|
/* check close_lru for replay */
|
2009-04-03 07:28:41 +02:00
|
|
|
if ((status = nfs4_preprocess_seqid_op(cstate,
|
2006-12-13 09:35:27 +01:00
|
|
|
close->cl_seqid,
|
2005-04-17 00:20:36 +02:00
|
|
|
&close->cl_stateid,
|
2008-01-26 20:58:45 +01:00
|
|
|
OPEN_STATE | CLOSE_STATE,
|
2005-04-17 00:20:36 +02:00
|
|
|
&close->cl_stateowner, &stp, NULL)))
|
|
|
|
goto out;
|
|
|
|
status = nfs_ok;
|
|
|
|
update_stateid(&stp->st_stateid);
|
|
|
|
memcpy(&close->cl_stateid, &stp->st_stateid, sizeof(stateid_t));
|
|
|
|
|
2006-01-19 02:43:21 +01:00
|
|
|
/* release_stateid() calls nfsd_close() if needed */
|
2009-01-11 20:27:17 +01:00
|
|
|
release_open_stateid(stp);
|
2006-01-19 02:43:21 +01:00
|
|
|
|
|
|
|
/* place unused nfs4_stateowners on so_close_lru list to be
|
|
|
|
* released by the laundromat service after the lease period
|
|
|
|
* to enable us to handle CLOSE replay
|
|
|
|
*/
|
|
|
|
if (list_empty(&close->cl_stateowner->so_stateids))
|
|
|
|
move_to_close_lru(close->cl_stateowner);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
2005-09-13 10:25:37 +02:00
|
|
|
if (close->cl_stateowner) {
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_get_stateowner(close->cl_stateowner);
|
2006-12-13 09:35:28 +01:00
|
|
|
cstate->replay_owner = close->cl_stateowner;
|
2005-09-13 10:25:37 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_unlock_state();
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32
|
2006-12-13 09:35:27 +01:00
|
|
|
nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_delegreturn *dr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2009-02-21 22:29:14 +01:00
|
|
|
struct nfs4_delegation *dp;
|
|
|
|
stateid_t *stateid = &dr->dr_stateid;
|
|
|
|
struct inode *inode;
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32 status;
|
2009-04-03 07:28:45 +02:00
|
|
|
int flags = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-12-13 09:35:27 +01:00
|
|
|
if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
|
2009-02-21 22:29:14 +01:00
|
|
|
return status;
|
|
|
|
inode = cstate->current_fh.fh_dentry->d_inode;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-04-03 07:28:45 +02:00
|
|
|
if (nfsd4_has_session(cstate))
|
|
|
|
flags |= HAS_SESSION;
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_lock_state();
|
2009-02-21 22:29:14 +01:00
|
|
|
status = nfserr_bad_stateid;
|
|
|
|
if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
|
|
|
|
goto out;
|
|
|
|
status = nfserr_stale_stateid;
|
|
|
|
if (STALE_STATEID(stateid))
|
|
|
|
goto out;
|
2009-02-21 22:32:28 +01:00
|
|
|
status = nfserr_bad_stateid;
|
2009-02-21 22:29:14 +01:00
|
|
|
if (!is_delegation_stateid(stateid))
|
|
|
|
goto out;
|
2010-10-03 00:42:39 +02:00
|
|
|
status = nfserr_expired;
|
2009-02-21 22:29:14 +01:00
|
|
|
dp = find_delegation_stateid(inode, stateid);
|
2010-04-22 22:21:39 +02:00
|
|
|
if (!dp)
|
2009-02-21 22:29:14 +01:00
|
|
|
goto out;
|
2009-04-03 07:28:45 +02:00
|
|
|
status = check_stateid_generation(stateid, &dp->dl_stateid, flags);
|
2009-02-21 22:29:14 +01:00
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
renew_client(dp->dl_client);
|
|
|
|
|
|
|
|
unhash_delegation(dp);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
2009-02-21 22:29:14 +01:00
|
|
|
nfs4_unlock_state();
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lock owner state (byte-range locks)
|
|
|
|
*/
|
|
|
|
#define LOFF_OVERFLOW(start, len) ((u64)(len) > ~(u64)(start))
|
|
|
|
#define LOCK_HASH_BITS 8
|
|
|
|
#define LOCK_HASH_SIZE (1 << LOCK_HASH_BITS)
|
|
|
|
#define LOCK_HASH_MASK (LOCK_HASH_SIZE - 1)
|
|
|
|
|
2008-12-15 18:42:03 +01:00
|
|
|
static inline u64
|
|
|
|
end_offset(u64 start, u64 len)
|
|
|
|
{
|
|
|
|
u64 end;
|
|
|
|
|
|
|
|
end = start + len;
|
|
|
|
return end >= start ? end: NFS4_MAX_UINT64;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* last octet in a range */
|
|
|
|
static inline u64
|
|
|
|
last_byte_offset(u64 start, u64 len)
|
|
|
|
{
|
|
|
|
u64 end;
|
|
|
|
|
|
|
|
BUG_ON(!len);
|
|
|
|
end = start + len;
|
|
|
|
return end > start ? end - 1: NFS4_MAX_UINT64;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#define lockownerid_hashval(id) \
|
|
|
|
((id) & LOCK_HASH_MASK)
|
|
|
|
|
|
|
|
static inline unsigned int
|
|
|
|
lock_ownerstr_hashval(struct inode *inode, u32 cl_id,
|
|
|
|
struct xdr_netobj *ownername)
|
|
|
|
{
|
|
|
|
return (file_hashval(inode) + cl_id
|
|
|
|
+ opaque_hashval(ownername->data, ownername->len))
|
|
|
|
& LOCK_HASH_MASK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct list_head lock_ownerid_hashtbl[LOCK_HASH_SIZE];
|
|
|
|
static struct list_head lock_ownerstr_hashtbl[LOCK_HASH_SIZE];
|
|
|
|
static struct list_head lockstateid_hashtbl[STATEID_HASH_SIZE];
|
|
|
|
|
2011-07-13 17:04:21 +02:00
|
|
|
static int
|
|
|
|
same_stateid(stateid_t *id_one, stateid_t *id_two)
|
|
|
|
{
|
|
|
|
if (id_one->si_stateownerid != id_two->si_stateownerid)
|
|
|
|
return 0;
|
|
|
|
return id_one->si_fileid == id_two->si_fileid;
|
|
|
|
}
|
|
|
|
|
2005-06-24 07:04:03 +02:00
|
|
|
static struct nfs4_stateid *
|
2005-04-17 00:20:36 +02:00
|
|
|
find_stateid(stateid_t *stid, int flags)
|
|
|
|
{
|
2008-10-20 08:14:28 +02:00
|
|
|
struct nfs4_stateid *local;
|
2005-04-17 00:20:36 +02:00
|
|
|
u32 st_id = stid->si_stateownerid;
|
|
|
|
u32 f_id = stid->si_fileid;
|
|
|
|
unsigned int hashval;
|
|
|
|
|
|
|
|
dprintk("NFSD: find_stateid flags 0x%x\n",flags);
|
2008-10-20 08:14:28 +02:00
|
|
|
if (flags & (LOCK_STATE | RD_STATE | WR_STATE)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
hashval = stateid_hashval(st_id, f_id);
|
|
|
|
list_for_each_entry(local, &lockstateid_hashtbl[hashval], st_hash) {
|
|
|
|
if ((local->st_stateid.si_stateownerid == st_id) &&
|
|
|
|
(local->st_stateid.si_fileid == f_id))
|
|
|
|
return local;
|
|
|
|
}
|
|
|
|
}
|
2008-10-20 08:14:28 +02:00
|
|
|
|
|
|
|
if (flags & (OPEN_STATE | RD_STATE | WR_STATE)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
hashval = stateid_hashval(st_id, f_id);
|
|
|
|
list_for_each_entry(local, &stateid_hashtbl[hashval], st_hash) {
|
|
|
|
if ((local->st_stateid.si_stateownerid == st_id) &&
|
|
|
|
(local->st_stateid.si_fileid == f_id))
|
|
|
|
return local;
|
|
|
|
}
|
2005-09-13 10:25:36 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-07-13 17:04:21 +02:00
|
|
|
static struct nfs4_stateid *
|
|
|
|
search_for_stateid(stateid_t *stid)
|
|
|
|
{
|
|
|
|
struct nfs4_stateid *local;
|
|
|
|
unsigned int hashval = stateid_hashval(stid->si_stateownerid, stid->si_fileid);
|
|
|
|
|
|
|
|
list_for_each_entry(local, &lockstateid_hashtbl[hashval], st_hash) {
|
|
|
|
if (same_stateid(&local->st_stateid, stid))
|
|
|
|
return local;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry(local, &stateid_hashtbl[hashval], st_hash) {
|
|
|
|
if (same_stateid(&local->st_stateid, stid))
|
|
|
|
return local;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct nfs4_delegation *
|
|
|
|
search_for_delegation(stateid_t *stid)
|
|
|
|
{
|
|
|
|
struct nfs4_file *fp;
|
|
|
|
struct nfs4_delegation *dp;
|
|
|
|
struct list_head *pos;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < FILE_HASH_SIZE; i++) {
|
|
|
|
list_for_each_entry(fp, &file_hashtbl[i], fi_hash) {
|
|
|
|
list_for_each(pos, &fp->fi_delegations) {
|
|
|
|
dp = list_entry(pos, struct nfs4_delegation, dl_perfile);
|
|
|
|
if (same_stateid(&dp->dl_stateid, stid))
|
|
|
|
return dp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static struct nfs4_delegation *
|
|
|
|
find_delegation_stateid(struct inode *ino, stateid_t *stid)
|
|
|
|
{
|
2005-06-24 07:03:10 +02:00
|
|
|
struct nfs4_file *fp;
|
|
|
|
struct nfs4_delegation *dl;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-10-19 12:04:53 +02:00
|
|
|
dprintk("NFSD: %s: stateid=" STATEID_FMT "\n", __func__,
|
|
|
|
STATEID_VAL(stid));
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
fp = find_file(ino);
|
2005-06-24 07:03:10 +02:00
|
|
|
if (!fp)
|
|
|
|
return NULL;
|
|
|
|
dl = find_delegation_file(fp, stid);
|
|
|
|
put_nfs4_file(fp);
|
|
|
|
return dl;
|
2005-04-17 00:20:36 +02: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;
|
|
|
|
}
|
|
|
|
|
2006-04-11 07:55:22 +02:00
|
|
|
/* Hack!: For now, we're defining this just so we can use a pointer to it
|
|
|
|
* as a unique cookie to identify our (NFSv4's) posix locks. */
|
2009-09-22 02:01:12 +02:00
|
|
|
static const struct lock_manager_operations nfsd_posix_mng_ops = {
|
2006-04-11 07:55:22 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
static inline void
|
|
|
|
nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
|
|
|
|
{
|
2006-04-11 07:55:22 +02:00
|
|
|
struct nfs4_stateowner *sop;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-04-11 07:55:22 +02:00
|
|
|
if (fl->fl_lmops == &nfsd_posix_mng_ops) {
|
|
|
|
sop = (struct nfs4_stateowner *) fl->fl_owner;
|
2005-04-17 00:20:36 +02:00
|
|
|
kref_get(&sop->so_ref);
|
|
|
|
deny->ld_sop = sop;
|
|
|
|
deny->ld_clientid = sop->so_client->cl_clientid;
|
2006-04-11 07:55:22 +02:00
|
|
|
} else {
|
|
|
|
deny->ld_sop = NULL;
|
|
|
|
deny->ld_clientid.cl_boot = 0;
|
|
|
|
deny->ld_clientid.cl_id = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
deny->ld_start = fl->fl_start;
|
2008-12-15 18:42:03 +01:00
|
|
|
deny->ld_length = NFS4_MAX_UINT64;
|
|
|
|
if (fl->fl_end != NFS4_MAX_UINT64)
|
2005-04-17 00:20:36 +02: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;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct nfs4_stateowner *
|
|
|
|
find_lockstateowner_str(struct inode *inode, clientid_t *clid,
|
|
|
|
struct xdr_netobj *owner)
|
|
|
|
{
|
|
|
|
unsigned int hashval = lock_ownerstr_hashval(inode, clid->cl_id, owner);
|
|
|
|
struct nfs4_stateowner *op;
|
|
|
|
|
|
|
|
list_for_each_entry(op, &lock_ownerstr_hashtbl[hashval], so_strhash) {
|
2007-07-26 23:04:54 +02:00
|
|
|
if (same_owner_str(op, owner, clid))
|
2005-04-17 00:20:36 +02:00
|
|
|
return op;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Alloc a lock owner structure.
|
|
|
|
* Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has
|
2011-03-31 03:57:33 +02:00
|
|
|
* occurred.
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* strhashval = lock_ownerstr_hashval
|
|
|
|
*/
|
|
|
|
|
|
|
|
static struct nfs4_stateowner *
|
|
|
|
alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfs4_stateid *open_stp, struct nfsd4_lock *lock) {
|
|
|
|
struct nfs4_stateowner *sop;
|
|
|
|
struct nfs4_replay *rp;
|
|
|
|
unsigned int idhashval;
|
|
|
|
|
|
|
|
if (!(sop = alloc_stateowner(&lock->lk_new_owner)))
|
|
|
|
return NULL;
|
|
|
|
idhashval = lockownerid_hashval(current_ownerid);
|
|
|
|
INIT_LIST_HEAD(&sop->so_idhash);
|
|
|
|
INIT_LIST_HEAD(&sop->so_strhash);
|
|
|
|
INIT_LIST_HEAD(&sop->so_perclient);
|
2005-06-24 07:04:17 +02:00
|
|
|
INIT_LIST_HEAD(&sop->so_stateids);
|
|
|
|
INIT_LIST_HEAD(&sop->so_perstateid);
|
2005-04-17 00:20:36 +02:00
|
|
|
INIT_LIST_HEAD(&sop->so_close_lru); /* not used */
|
|
|
|
sop->so_time = 0;
|
|
|
|
list_add(&sop->so_idhash, &lock_ownerid_hashtbl[idhashval]);
|
|
|
|
list_add(&sop->so_strhash, &lock_ownerstr_hashtbl[strhashval]);
|
2005-06-24 07:04:17 +02:00
|
|
|
list_add(&sop->so_perstateid, &open_stp->st_lockowners);
|
2005-04-17 00:20:36 +02:00
|
|
|
sop->so_is_open_owner = 0;
|
|
|
|
sop->so_id = current_ownerid++;
|
|
|
|
sop->so_client = clp;
|
2005-09-13 10:25:38 +02:00
|
|
|
/* It is the openowner seqid that will be incremented in encode in the
|
|
|
|
* case of new lockowners; so increment the lock seqid manually: */
|
|
|
|
sop->so_seqid = lock->lk_new_lock_seqid + 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
sop->so_confirmed = 1;
|
|
|
|
rp = &sop->so_replay;
|
2006-01-19 02:43:47 +01:00
|
|
|
rp->rp_status = nfserr_serverfault;
|
2005-04-17 00:20:36 +02:00
|
|
|
rp->rp_buflen = 0;
|
|
|
|
rp->rp_buf = rp->rp_ibuf;
|
|
|
|
return sop;
|
|
|
|
}
|
|
|
|
|
2005-06-24 07:04:03 +02:00
|
|
|
static struct nfs4_stateid *
|
2005-04-17 00:20:36 +02:00
|
|
|
alloc_init_lock_stateid(struct nfs4_stateowner *sop, struct nfs4_file *fp, struct nfs4_stateid *open_stp)
|
|
|
|
{
|
|
|
|
struct nfs4_stateid *stp;
|
|
|
|
unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);
|
|
|
|
|
2005-06-24 07:03:03 +02:00
|
|
|
stp = nfs4_alloc_stateid();
|
|
|
|
if (stp == NULL)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
INIT_LIST_HEAD(&stp->st_hash);
|
|
|
|
INIT_LIST_HEAD(&stp->st_perfile);
|
2005-06-24 07:04:17 +02:00
|
|
|
INIT_LIST_HEAD(&stp->st_perstateowner);
|
|
|
|
INIT_LIST_HEAD(&stp->st_lockowners); /* not used */
|
2005-04-17 00:20:36 +02:00
|
|
|
list_add(&stp->st_hash, &lockstateid_hashtbl[hashval]);
|
2005-06-24 07:03:08 +02:00
|
|
|
list_add(&stp->st_perfile, &fp->fi_stateids);
|
2005-06-24 07:04:17 +02:00
|
|
|
list_add(&stp->st_perstateowner, &sop->so_stateids);
|
2005-04-17 00:20:36 +02:00
|
|
|
stp->st_stateowner = sop;
|
2005-06-24 07:03:10 +02:00
|
|
|
get_nfs4_file(fp);
|
2005-04-17 00:20:36 +02:00
|
|
|
stp->st_file = fp;
|
2010-04-22 22:21:39 +02:00
|
|
|
stp->st_stateid.si_boot = boot_time;
|
2005-04-17 00:20:36 +02:00
|
|
|
stp->st_stateid.si_stateownerid = sop->so_id;
|
|
|
|
stp->st_stateid.si_fileid = fp->fi_id;
|
|
|
|
stp->st_stateid.si_generation = 0;
|
2011-03-03 00:01:35 +01:00
|
|
|
stp->st_access_bmap = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
stp->st_deny_bmap = open_stp->st_deny_bmap;
|
2005-07-08 02:59:27 +02:00
|
|
|
stp->st_openstp = open_stp;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
out:
|
|
|
|
return stp;
|
|
|
|
}
|
|
|
|
|
2005-06-24 07:04:03 +02:00
|
|
|
static int
|
2005-04-17 00:20:36 +02:00
|
|
|
check_lock_length(u64 offset, u64 length)
|
|
|
|
{
|
2008-12-15 18:42:03 +01:00
|
|
|
return ((length == 0) || ((length != NFS4_MAX_UINT64) &&
|
2005-04-17 00:20:36 +02:00
|
|
|
LOFF_OVERFLOW(offset, length)));
|
|
|
|
}
|
|
|
|
|
2011-03-03 00:01:35 +01:00
|
|
|
static void get_lock_access(struct nfs4_stateid *lock_stp, u32 access)
|
|
|
|
{
|
|
|
|
struct nfs4_file *fp = lock_stp->st_file;
|
|
|
|
int oflag = nfs4_access_to_omode(access);
|
|
|
|
|
|
|
|
if (test_bit(access, &lock_stp->st_access_bmap))
|
|
|
|
return;
|
|
|
|
nfs4_file_get_access(fp, oflag);
|
|
|
|
__set_bit(access, &lock_stp->st_access_bmap);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* LOCK operation
|
|
|
|
*/
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32
|
2006-12-13 09:35:27 +01:00
|
|
|
nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2006-12-13 09:35:28 +01:00
|
|
|
struct nfsd4_lock *lock)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-06-24 07:04:20 +02:00
|
|
|
struct nfs4_stateowner *open_sop = NULL;
|
2005-09-13 10:25:38 +02:00
|
|
|
struct nfs4_stateowner *lock_sop = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct nfs4_stateid *lock_stp;
|
2010-08-21 00:09:31 +02:00
|
|
|
struct nfs4_file *fp;
|
|
|
|
struct file *filp = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct file_lock file_lock;
|
2006-03-20 19:44:26 +01:00
|
|
|
struct file_lock conflock;
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32 status = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned int strhashval;
|
2006-10-20 08:29:01 +02:00
|
|
|
int err;
|
2005-04-17 00:20:36 +02: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 09:35:27 +01:00
|
|
|
if ((status = fh_verify(rqstp, &cstate->current_fh,
|
2008-06-16 13:20:29 +02:00
|
|
|
S_IFREG, NFSD_MAY_LOCK))) {
|
2006-01-19 02:43:17 +01:00
|
|
|
dprintk("NFSD: nfsd4_lock: permission denied!\n");
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_lock_state();
|
|
|
|
|
|
|
|
if (lock->lk_is_new) {
|
2005-07-08 02:59:17 +02:00
|
|
|
/*
|
|
|
|
* Client indicates that this is a new lockowner.
|
|
|
|
* Use open owner and open stateid to create lock owner and
|
|
|
|
* lock stateid.
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
struct nfs4_stateid *open_stp = NULL;
|
|
|
|
|
|
|
|
status = nfserr_stale_clientid;
|
2009-04-03 07:28:50 +02:00
|
|
|
if (!nfsd4_has_session(cstate) &&
|
|
|
|
STALE_CLIENTID(&lock->lk_new_clientid))
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* validate and update open stateid and open seqid */
|
2009-04-03 07:28:41 +02:00
|
|
|
status = nfs4_preprocess_seqid_op(cstate,
|
2005-04-17 00:20:36 +02:00
|
|
|
lock->lk_new_open_seqid,
|
|
|
|
&lock->lk_new_open_stateid,
|
2008-01-26 20:58:45 +01:00
|
|
|
OPEN_STATE,
|
2006-01-19 02:43:19 +01:00
|
|
|
&lock->lk_replay_owner, &open_stp,
|
2005-09-13 10:25:38 +02:00
|
|
|
lock);
|
2005-07-08 02:59:16 +02:00
|
|
|
if (status)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
2006-01-19 02:43:19 +01:00
|
|
|
open_sop = lock->lk_replay_owner;
|
2005-04-17 00:20:36 +02:00
|
|
|
/* create lockowner and lock stateid */
|
|
|
|
fp = open_stp->st_file;
|
|
|
|
strhashval = lock_ownerstr_hashval(fp->fi_inode,
|
|
|
|
open_sop->so_client->cl_clientid.cl_id,
|
|
|
|
&lock->v.new.owner);
|
2005-06-24 07:04:20 +02:00
|
|
|
/* XXX: Do we need to check for duplicate stateowners on
|
|
|
|
* the same file, or should they just be allowed (and
|
|
|
|
* create new stateids)? */
|
2005-04-17 00:20:36 +02:00
|
|
|
status = nfserr_resource;
|
2005-09-13 10:25:38 +02:00
|
|
|
lock_sop = alloc_init_lock_stateowner(strhashval,
|
|
|
|
open_sop->so_client, open_stp, lock);
|
|
|
|
if (lock_sop == NULL)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
2005-09-13 10:25:38 +02:00
|
|
|
lock_stp = alloc_init_lock_stateid(lock_sop, fp, open_stp);
|
2006-01-19 02:43:18 +01:00
|
|
|
if (lock_stp == NULL)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
} else {
|
|
|
|
/* lock (lock owner + lock stateid) already exists */
|
2009-04-03 07:28:41 +02:00
|
|
|
status = nfs4_preprocess_seqid_op(cstate,
|
2005-04-17 00:20:36 +02:00
|
|
|
lock->lk_old_lock_seqid,
|
|
|
|
&lock->lk_old_lock_stateid,
|
2008-01-26 20:58:45 +01:00
|
|
|
LOCK_STATE,
|
2006-01-19 02:43:19 +01:00
|
|
|
&lock->lk_replay_owner, &lock_stp, lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (status)
|
|
|
|
goto out;
|
2006-01-19 02:43:19 +01:00
|
|
|
lock_sop = lock->lk_replay_owner;
|
2010-08-21 00:09:31 +02:00
|
|
|
fp = lock_stp->st_file;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-01-19 02:43:19 +01:00
|
|
|
/* lock->lk_replay_owner and lock_stp have been created or found */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-07-08 02:59:15 +02:00
|
|
|
status = nfserr_grace;
|
2007-09-06 18:34:25 +02:00
|
|
|
if (locks_in_grace() && !lock->lk_reclaim)
|
2005-07-08 02:59:15 +02:00
|
|
|
goto out;
|
|
|
|
status = nfserr_no_grace;
|
2007-09-06 18:34:25 +02:00
|
|
|
if (!locks_in_grace() && lock->lk_reclaim)
|
2005-07-08 02:59:15 +02:00
|
|
|
goto out;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
locks_init_lock(&file_lock);
|
|
|
|
switch (lock->lk_type) {
|
|
|
|
case NFS4_READ_LT:
|
|
|
|
case NFS4_READW_LT:
|
2011-03-03 00:01:35 +01:00
|
|
|
filp = find_readable_file(lock_stp->st_file);
|
|
|
|
if (filp)
|
|
|
|
get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ);
|
2005-04-17 00:20:36 +02:00
|
|
|
file_lock.fl_type = F_RDLCK;
|
2011-03-03 05:48:33 +01:00
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
case NFS4_WRITE_LT:
|
|
|
|
case NFS4_WRITEW_LT:
|
2011-03-03 00:01:35 +01:00
|
|
|
filp = find_writeable_file(lock_stp->st_file);
|
|
|
|
if (filp)
|
|
|
|
get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE);
|
2005-04-17 00:20:36 +02:00
|
|
|
file_lock.fl_type = F_WRLCK;
|
2011-03-03 05:48:33 +01:00
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
default:
|
|
|
|
status = nfserr_inval;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-07-08 17:02:09 +02:00
|
|
|
if (!filp) {
|
|
|
|
status = nfserr_openmode;
|
|
|
|
goto out;
|
|
|
|
}
|
2005-09-13 10:25:38 +02:00
|
|
|
file_lock.fl_owner = (fl_owner_t)lock_sop;
|
2005-04-17 00:20:36 +02:00
|
|
|
file_lock.fl_pid = current->tgid;
|
|
|
|
file_lock.fl_file = filp;
|
|
|
|
file_lock.fl_flags = FL_POSIX;
|
2006-04-11 07:55:22 +02:00
|
|
|
file_lock.fl_lmops = &nfsd_posix_mng_ops;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
file_lock.fl_start = lock->lk_offset;
|
2008-12-15 18:42:03 +01:00
|
|
|
file_lock.fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_transform_lock_offset(&file_lock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to lock the file in the VFS.
|
|
|
|
* Note: locks.c uses the BKL to protect the inode's lock list.
|
|
|
|
*/
|
|
|
|
|
2011-03-03 05:48:33 +01:00
|
|
|
err = vfs_lock_file(filp, F_SETLK, &file_lock, &conflock);
|
2006-10-20 08:29:01 +02:00
|
|
|
switch (-err) {
|
2005-04-17 00:20:36 +02:00
|
|
|
case 0: /* success! */
|
|
|
|
update_stateid(&lock_stp->st_stateid);
|
|
|
|
memcpy(&lock->lk_resp_stateid, &lock_stp->st_stateid,
|
|
|
|
sizeof(stateid_t));
|
2006-10-20 08:29:01 +02:00
|
|
|
status = 0;
|
2006-03-26 11:37:26 +02:00
|
|
|
break;
|
|
|
|
case (EAGAIN): /* conflock holds conflicting lock */
|
|
|
|
status = nfserr_denied;
|
|
|
|
dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
|
|
|
|
nfs4_set_lock_denied(&conflock, &lock->lk_denied);
|
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
case (EDEADLK):
|
|
|
|
status = nfserr_deadlock;
|
2006-03-26 11:37:26 +02:00
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
default:
|
2006-11-28 22:26:41 +01:00
|
|
|
dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
|
2006-03-26 11:37:26 +02:00
|
|
|
status = nfserr_resource;
|
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
out:
|
2006-01-19 02:43:18 +01:00
|
|
|
if (status && lock->lk_is_new && lock_sop)
|
2009-01-11 21:24:04 +01:00
|
|
|
release_lockowner(lock_sop);
|
2006-01-19 02:43:19 +01:00
|
|
|
if (lock->lk_replay_owner) {
|
|
|
|
nfs4_get_stateowner(lock->lk_replay_owner);
|
2006-12-13 09:35:28 +01:00
|
|
|
cstate->replay_owner = lock->lk_replay_owner;
|
2005-09-13 10:25:37 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_unlock_state();
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2008-12-20 20:58:38 +01: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
|
|
|
|
* vfs_test_lock. (Arguably perhaps test_lock should be done with an
|
|
|
|
* inode operation.)
|
|
|
|
*/
|
|
|
|
static int nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
|
|
|
|
{
|
|
|
|
struct file *file;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
err = vfs_test_lock(file, lock);
|
|
|
|
nfsd_close(file);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* LOCKT operation
|
|
|
|
*/
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32
|
2006-12-13 09:35:27 +01:00
|
|
|
nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_lockt *lockt)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct inode *inode;
|
|
|
|
struct file_lock file_lock;
|
2006-11-28 22:26:41 +01:00
|
|
|
int error;
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32 status;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-09-06 18:34:25 +02:00
|
|
|
if (locks_in_grace())
|
2005-04-17 00:20:36 +02:00
|
|
|
return nfserr_grace;
|
|
|
|
|
|
|
|
if (check_lock_length(lockt->lt_offset, lockt->lt_length))
|
|
|
|
return nfserr_inval;
|
|
|
|
|
|
|
|
lockt->lt_stateowner = NULL;
|
|
|
|
nfs4_lock_state();
|
|
|
|
|
|
|
|
status = nfserr_stale_clientid;
|
2009-04-03 07:28:50 +02:00
|
|
|
if (!nfsd4_has_session(cstate) && STALE_CLIENTID(&lockt->lt_clientid))
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
|
2006-12-13 09:35:27 +01:00
|
|
|
if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0))) {
|
2005-09-13 10:25:36 +02:00
|
|
|
dprintk("NFSD: nfsd4_lockt: fh_verify() failed!\n");
|
2005-04-17 00:20:36 +02:00
|
|
|
if (status == nfserr_symlink)
|
|
|
|
status = nfserr_inval;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2006-12-13 09:35:27 +01:00
|
|
|
inode = cstate->current_fh.fh_dentry->d_inode;
|
2005-04-17 00:20:36 +02:00
|
|
|
locks_init_lock(&file_lock);
|
|
|
|
switch (lockt->lt_type) {
|
|
|
|
case NFS4_READ_LT:
|
|
|
|
case NFS4_READW_LT:
|
|
|
|
file_lock.fl_type = F_RDLCK;
|
|
|
|
break;
|
|
|
|
case NFS4_WRITE_LT:
|
|
|
|
case NFS4_WRITEW_LT:
|
|
|
|
file_lock.fl_type = F_WRLCK;
|
|
|
|
break;
|
|
|
|
default:
|
2007-07-27 22:10:37 +02:00
|
|
|
dprintk("NFSD: nfs4_lockt: bad lock type!\n");
|
2005-04-17 00:20:36 +02:00
|
|
|
status = nfserr_inval;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
lockt->lt_stateowner = find_lockstateowner_str(inode,
|
|
|
|
&lockt->lt_clientid, &lockt->lt_owner);
|
|
|
|
if (lockt->lt_stateowner)
|
|
|
|
file_lock.fl_owner = (fl_owner_t)lockt->lt_stateowner;
|
|
|
|
file_lock.fl_pid = current->tgid;
|
|
|
|
file_lock.fl_flags = FL_POSIX;
|
|
|
|
|
|
|
|
file_lock.fl_start = lockt->lt_offset;
|
2008-12-15 18:42:03 +01:00
|
|
|
file_lock.fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
nfs4_transform_lock_offset(&file_lock);
|
|
|
|
|
|
|
|
status = nfs_ok;
|
2008-12-20 20:58:38 +01:00
|
|
|
error = nfsd_test_lock(rqstp, &cstate->current_fh, &file_lock);
|
2006-11-28 22:26:41 +01:00
|
|
|
if (error) {
|
|
|
|
status = nfserrno(error);
|
|
|
|
goto out;
|
|
|
|
}
|
2007-02-21 06:55:18 +01:00
|
|
|
if (file_lock.fl_type != F_UNLCK) {
|
2005-04-17 00:20:36 +02:00
|
|
|
status = nfserr_denied;
|
2007-02-21 06:55:18 +01:00
|
|
|
nfs4_set_lock_denied(&file_lock, &lockt->lt_denied);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
out:
|
|
|
|
nfs4_unlock_state();
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32
|
2006-12-13 09:35:27 +01:00
|
|
|
nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
|
2006-12-13 09:35:28 +01:00
|
|
|
struct nfsd4_locku *locku)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct nfs4_stateid *stp;
|
|
|
|
struct file *filp = NULL;
|
|
|
|
struct file_lock file_lock;
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32 status;
|
2006-10-20 08:29:01 +02:00
|
|
|
int err;
|
2005-04-17 00:20:36 +02: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;
|
|
|
|
|
|
|
|
nfs4_lock_state();
|
|
|
|
|
2009-04-03 07:28:41 +02:00
|
|
|
if ((status = nfs4_preprocess_seqid_op(cstate,
|
2005-04-17 00:20:36 +02:00
|
|
|
locku->lu_seqid,
|
|
|
|
&locku->lu_stateid,
|
2008-01-26 20:58:45 +01:00
|
|
|
LOCK_STATE,
|
2005-04-17 00:20:36 +02:00
|
|
|
&locku->lu_stateowner, &stp, NULL)))
|
|
|
|
goto out;
|
|
|
|
|
2010-07-08 17:02:09 +02:00
|
|
|
filp = find_any_file(stp->st_file);
|
|
|
|
if (!filp) {
|
|
|
|
status = nfserr_lock_range;
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
BUG_ON(!filp);
|
|
|
|
locks_init_lock(&file_lock);
|
|
|
|
file_lock.fl_type = F_UNLCK;
|
|
|
|
file_lock.fl_owner = (fl_owner_t) locku->lu_stateowner;
|
|
|
|
file_lock.fl_pid = current->tgid;
|
|
|
|
file_lock.fl_file = filp;
|
|
|
|
file_lock.fl_flags = FL_POSIX;
|
2006-04-11 07:55:22 +02:00
|
|
|
file_lock.fl_lmops = &nfsd_posix_mng_ops;
|
2005-04-17 00:20:36 +02:00
|
|
|
file_lock.fl_start = locku->lu_offset;
|
|
|
|
|
2008-12-15 18:42:03 +01:00
|
|
|
file_lock.fl_end = last_byte_offset(locku->lu_offset, locku->lu_length);
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_transform_lock_offset(&file_lock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to unlock the file in the VFS.
|
|
|
|
*/
|
2006-11-28 22:26:41 +01:00
|
|
|
err = vfs_lock_file(filp, F_SETLK, &file_lock, NULL);
|
2006-10-20 08:29:01 +02:00
|
|
|
if (err) {
|
2006-11-28 22:26:41 +01:00
|
|
|
dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out_nfserr;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* OK, unlock succeeded; the only thing left to do is update the stateid.
|
|
|
|
*/
|
|
|
|
update_stateid(&stp->st_stateid);
|
|
|
|
memcpy(&locku->lu_stateid, &stp->st_stateid, sizeof(stateid_t));
|
|
|
|
|
|
|
|
out:
|
2005-09-13 10:25:37 +02:00
|
|
|
if (locku->lu_stateowner) {
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_get_stateowner(locku->lu_stateowner);
|
2006-12-13 09:35:28 +01:00
|
|
|
cstate->replay_owner = locku->lu_stateowner;
|
2005-09-13 10:25:37 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_unlock_state();
|
|
|
|
return status;
|
|
|
|
|
|
|
|
out_nfserr:
|
2006-10-20 08:29:01 +02:00
|
|
|
status = nfserrno(err);
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* returns
|
|
|
|
* 1: locks held by lockowner
|
|
|
|
* 0: no locks held by lockowner
|
|
|
|
*/
|
|
|
|
static int
|
2010-07-08 17:02:09 +02:00
|
|
|
check_for_locks(struct nfs4_file *filp, struct nfs4_stateowner *lowner)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct file_lock **flpp;
|
2010-07-08 17:02:09 +02:00
|
|
|
struct inode *inode = filp->fi_inode;
|
2005-04-17 00:20:36 +02:00
|
|
|
int status = 0;
|
|
|
|
|
2010-09-18 15:09:31 +02:00
|
|
|
lock_flocks();
|
2005-04-17 00:20:36 +02:00
|
|
|
for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
|
2006-01-19 02:43:22 +01:00
|
|
|
if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
|
2005-04-17 00:20:36 +02:00
|
|
|
status = 1;
|
|
|
|
goto out;
|
2006-01-19 02:43:22 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
out:
|
2010-09-18 15:09:31 +02:00
|
|
|
unlock_flocks();
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32
|
2006-12-13 09:35:38 +01:00
|
|
|
nfsd4_release_lockowner(struct svc_rqst *rqstp,
|
|
|
|
struct nfsd4_compound_state *cstate,
|
|
|
|
struct nfsd4_release_lockowner *rlockowner)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
clientid_t *clid = &rlockowner->rl_clientid;
|
2005-06-24 07:04:20 +02:00
|
|
|
struct nfs4_stateowner *sop;
|
|
|
|
struct nfs4_stateid *stp;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct xdr_netobj *owner = &rlockowner->rl_owner;
|
2005-06-24 07:04:20 +02:00
|
|
|
struct list_head matches;
|
|
|
|
int i;
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32 status;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
|
|
|
|
clid->cl_boot, clid->cl_id);
|
|
|
|
|
|
|
|
/* XXX check for lease expiration */
|
|
|
|
|
|
|
|
status = nfserr_stale_clientid;
|
2005-09-13 10:25:36 +02:00
|
|
|
if (STALE_CLIENTID(clid))
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
|
|
|
|
nfs4_lock_state();
|
|
|
|
|
2005-06-24 07:04:20 +02:00
|
|
|
status = nfserr_locks_held;
|
|
|
|
/* XXX: we're doing a linear search through all the lockowners.
|
|
|
|
* Yipes! For now we'll just hope clients aren't really using
|
|
|
|
* release_lockowner much, but eventually we have to fix these
|
|
|
|
* data structures. */
|
|
|
|
INIT_LIST_HEAD(&matches);
|
|
|
|
for (i = 0; i < LOCK_HASH_SIZE; i++) {
|
|
|
|
list_for_each_entry(sop, &lock_ownerid_hashtbl[i], so_idhash) {
|
2007-07-26 23:04:54 +02:00
|
|
|
if (!same_owner_str(sop, owner, clid))
|
2005-06-24 07:04:20 +02:00
|
|
|
continue;
|
|
|
|
list_for_each_entry(stp, &sop->so_stateids,
|
|
|
|
st_perstateowner) {
|
2010-07-08 17:02:09 +02:00
|
|
|
if (check_for_locks(stp->st_file, sop))
|
2005-06-24 07:04:20 +02:00
|
|
|
goto out;
|
|
|
|
/* Note: so_perclient unused for lockowners,
|
|
|
|
* so it's OK to fool with here. */
|
|
|
|
list_add(&sop->so_perclient, &matches);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2005-06-24 07:04:20 +02:00
|
|
|
}
|
|
|
|
/* Clients probably won't expect us to return with some (but not all)
|
|
|
|
* of the lockowner state released; so don't release any until all
|
|
|
|
* have been checked. */
|
|
|
|
status = nfs_ok;
|
2005-07-08 02:59:14 +02:00
|
|
|
while (!list_empty(&matches)) {
|
|
|
|
sop = list_entry(matches.next, struct nfs4_stateowner,
|
|
|
|
so_perclient);
|
|
|
|
/* unhash_stateowner deletes so_perclient only
|
|
|
|
* for openowners. */
|
|
|
|
list_del(&sop->so_perclient);
|
2009-01-11 21:24:04 +01:00
|
|
|
release_lockowner(sop);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
out:
|
|
|
|
nfs4_unlock_state();
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct nfs4_client_reclaim *
|
2005-06-24 07:03:52 +02:00
|
|
|
alloc_reclaim(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-06-24 07:03:52 +02:00
|
|
|
return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2005-06-24 07:04:30 +02:00
|
|
|
int
|
2009-04-03 07:28:05 +02:00
|
|
|
nfs4_has_reclaimed_state(const char *name, bool use_exchange_id)
|
2005-06-24 07:04:30 +02:00
|
|
|
{
|
|
|
|
unsigned int strhashval = clientstr_hashval(name);
|
|
|
|
struct nfs4_client *clp;
|
|
|
|
|
2010-11-24 23:30:54 +01:00
|
|
|
clp = find_confirmed_client_by_str(name, strhashval);
|
2005-06-24 07:04:30 +02:00
|
|
|
return clp ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* failure => all reset bets are off, nfserr_no_grace...
|
|
|
|
*/
|
2005-06-24 07:04:25 +02:00
|
|
|
int
|
|
|
|
nfs4_client_to_reclaim(const char *name)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
unsigned int strhashval;
|
|
|
|
struct nfs4_client_reclaim *crp = NULL;
|
|
|
|
|
2005-06-24 07:03:52 +02:00
|
|
|
dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
|
|
|
|
crp = alloc_reclaim();
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!crp)
|
|
|
|
return 0;
|
2005-06-24 07:03:52 +02:00
|
|
|
strhashval = clientstr_hashval(name);
|
2005-04-17 00:20:36 +02:00
|
|
|
INIT_LIST_HEAD(&crp->cr_strhash);
|
|
|
|
list_add(&crp->cr_strhash, &reclaim_str_hashtbl[strhashval]);
|
2005-06-24 07:03:52 +02:00
|
|
|
memcpy(crp->cr_recdir, name, HEXDIR_LEN);
|
2005-04-17 00:20:36 +02:00
|
|
|
reclaim_str_hashtbl_size++;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
nfs4_release_reclaim(void)
|
|
|
|
{
|
|
|
|
struct nfs4_client_reclaim *crp = NULL;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < CLIENT_HASH_SIZE; i++) {
|
|
|
|
while (!list_empty(&reclaim_str_hashtbl[i])) {
|
|
|
|
crp = list_entry(reclaim_str_hashtbl[i].next,
|
|
|
|
struct nfs4_client_reclaim, cr_strhash);
|
|
|
|
list_del(&crp->cr_strhash);
|
|
|
|
kfree(crp);
|
|
|
|
reclaim_str_hashtbl_size--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
BUG_ON(reclaim_str_hashtbl_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* called from OPEN, CLAIM_PREVIOUS with a new clientid. */
|
2005-06-24 07:04:03 +02:00
|
|
|
static struct nfs4_client_reclaim *
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_find_reclaim_client(clientid_t *clid)
|
|
|
|
{
|
|
|
|
unsigned int strhashval;
|
|
|
|
struct nfs4_client *clp;
|
|
|
|
struct nfs4_client_reclaim *crp = NULL;
|
|
|
|
|
|
|
|
|
|
|
|
/* find clientid in conf_id_hashtbl */
|
|
|
|
clp = find_confirmed_client(clid);
|
|
|
|
if (clp == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2005-06-24 07:03:52 +02:00
|
|
|
dprintk("NFSD: nfs4_find_reclaim_client for %.*s with recdir %s\n",
|
|
|
|
clp->cl_name.len, clp->cl_name.data,
|
|
|
|
clp->cl_recdir);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* find clp->cl_name in reclaim_str_hashtbl */
|
2005-06-24 07:03:52 +02:00
|
|
|
strhashval = clientstr_hashval(clp->cl_recdir);
|
2005-04-17 00:20:36 +02:00
|
|
|
list_for_each_entry(crp, &reclaim_str_hashtbl[strhashval], cr_strhash) {
|
2005-06-24 07:03:52 +02:00
|
|
|
if (same_name(crp->cr_recdir, clp->cl_recdir)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
return crp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called from OPEN. Look for clientid in reclaim list.
|
|
|
|
*/
|
2006-10-20 08:28:59 +02:00
|
|
|
__be32
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_check_open_reclaim(clientid_t *clid)
|
|
|
|
{
|
2005-06-24 07:03:16 +02:00
|
|
|
return nfs4_find_reclaim_client(clid) ? nfs_ok : nfserr_reclaim_bad;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2005-06-24 07:03:30 +02:00
|
|
|
/* initialization to perform at module load time: */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-08-01 21:30:59 +02:00
|
|
|
int
|
2005-06-24 07:03:30 +02:00
|
|
|
nfs4_state_init(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-08-01 21:30:59 +02:00
|
|
|
int i, status;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-08-01 21:30:59 +02:00
|
|
|
status = nfsd4_init_slabs();
|
|
|
|
if (status)
|
|
|
|
return status;
|
2005-04-17 00:20:36 +02:00
|
|
|
for (i = 0; i < CLIENT_HASH_SIZE; i++) {
|
|
|
|
INIT_LIST_HEAD(&conf_id_hashtbl[i]);
|
|
|
|
INIT_LIST_HEAD(&conf_str_hashtbl[i]);
|
|
|
|
INIT_LIST_HEAD(&unconf_str_hashtbl[i]);
|
|
|
|
INIT_LIST_HEAD(&unconf_id_hashtbl[i]);
|
2009-04-24 09:41:57 +02:00
|
|
|
INIT_LIST_HEAD(&reclaim_str_hashtbl[i]);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2009-04-03 07:27:52 +02:00
|
|
|
for (i = 0; i < SESSION_HASH_SIZE; i++)
|
|
|
|
INIT_LIST_HEAD(&sessionid_hashtbl[i]);
|
2005-04-17 00:20:36 +02:00
|
|
|
for (i = 0; i < FILE_HASH_SIZE; i++) {
|
|
|
|
INIT_LIST_HEAD(&file_hashtbl[i]);
|
|
|
|
}
|
|
|
|
for (i = 0; i < OWNER_HASH_SIZE; i++) {
|
|
|
|
INIT_LIST_HEAD(&ownerstr_hashtbl[i]);
|
|
|
|
INIT_LIST_HEAD(&ownerid_hashtbl[i]);
|
|
|
|
}
|
|
|
|
for (i = 0; i < STATEID_HASH_SIZE; i++) {
|
|
|
|
INIT_LIST_HEAD(&stateid_hashtbl[i]);
|
|
|
|
INIT_LIST_HEAD(&lockstateid_hashtbl[i]);
|
|
|
|
}
|
|
|
|
for (i = 0; i < LOCK_HASH_SIZE; i++) {
|
|
|
|
INIT_LIST_HEAD(&lock_ownerid_hashtbl[i]);
|
|
|
|
INIT_LIST_HEAD(&lock_ownerstr_hashtbl[i]);
|
|
|
|
}
|
|
|
|
memset(&onestateid, ~0, sizeof(stateid_t));
|
|
|
|
INIT_LIST_HEAD(&close_lru);
|
|
|
|
INIT_LIST_HEAD(&client_lru);
|
|
|
|
INIT_LIST_HEAD(&del_recall_lru);
|
2005-06-24 07:03:30 +02:00
|
|
|
reclaim_str_hashtbl_size = 0;
|
2007-08-01 21:30:59 +02:00
|
|
|
return 0;
|
2005-06-24 07:03:30 +02:00
|
|
|
}
|
|
|
|
|
2005-06-24 07:04:25 +02:00
|
|
|
static void
|
|
|
|
nfsd4_load_reboot_recovery_data(void)
|
|
|
|
{
|
|
|
|
int status;
|
|
|
|
|
2005-06-24 07:04:32 +02:00
|
|
|
nfs4_lock_state();
|
|
|
|
nfsd4_init_recdir(user_recovery_dirname);
|
2005-06-24 07:04:25 +02:00
|
|
|
status = nfsd4_recdir_load();
|
2005-06-24 07:04:32 +02:00
|
|
|
nfs4_unlock_state();
|
2005-06-24 07:04:25 +02:00
|
|
|
if (status)
|
|
|
|
printk("NFSD: Failure reading reboot recovery data\n");
|
|
|
|
}
|
|
|
|
|
2007-07-17 13:04:39 +02: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);
|
|
|
|
}
|
|
|
|
|
2005-06-24 07:03:30 +02:00
|
|
|
/* initialization to perform when the nfsd service is started: */
|
|
|
|
|
2009-09-15 21:56:50 +02:00
|
|
|
static int
|
2005-06-24 07:03:30 +02:00
|
|
|
__nfs4_state_start(void)
|
|
|
|
{
|
2010-03-03 20:52:55 +01:00
|
|
|
int ret;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
boot_time = get_seconds();
|
2007-09-06 18:34:25 +02:00
|
|
|
locks_start_grace(&nfsd4_manager);
|
2007-07-17 13:04:35 +02:00
|
|
|
printk(KERN_INFO "NFSD: starting %ld-second grace period\n",
|
2010-03-02 01:21:21 +01:00
|
|
|
nfsd4_grace);
|
2010-03-03 20:52:55 +01:00
|
|
|
ret = set_callback_cred();
|
|
|
|
if (ret)
|
|
|
|
return -ENOMEM;
|
2005-06-24 07:03:19 +02:00
|
|
|
laundry_wq = create_singlethread_workqueue("nfsd4");
|
2009-09-15 21:56:50 +02:00
|
|
|
if (laundry_wq == NULL)
|
|
|
|
return -ENOMEM;
|
2010-03-03 20:52:55 +01:00
|
|
|
ret = nfsd4_create_callback_queue();
|
|
|
|
if (ret)
|
|
|
|
goto out_free_laundry;
|
2010-03-02 01:21:21 +01:00
|
|
|
queue_delayed_work(laundry_wq, &laundromat_work, nfsd4_grace * HZ);
|
2007-07-17 13:04:39 +02:00
|
|
|
set_max_delegations();
|
2010-03-03 20:52:55 +01:00
|
|
|
return 0;
|
|
|
|
out_free_laundry:
|
|
|
|
destroy_workqueue(laundry_wq);
|
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2009-09-15 21:56:50 +02:00
|
|
|
int
|
2005-06-24 07:03:26 +02:00
|
|
|
nfs4_state_start(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-06-24 07:04:25 +02:00
|
|
|
nfsd4_load_reboot_recovery_data();
|
2010-07-19 22:50:04 +02:00
|
|
|
return __nfs4_state_start();
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
__nfs4_state_shutdown(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct nfs4_client *clp = NULL;
|
|
|
|
struct nfs4_delegation *dp = NULL;
|
|
|
|
struct list_head *pos, *next, reaplist;
|
|
|
|
|
|
|
|
for (i = 0; i < CLIENT_HASH_SIZE; i++) {
|
|
|
|
while (!list_empty(&conf_id_hashtbl[i])) {
|
|
|
|
clp = list_entry(conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
|
|
|
|
expire_client(clp);
|
|
|
|
}
|
|
|
|
while (!list_empty(&unconf_str_hashtbl[i])) {
|
|
|
|
clp = list_entry(unconf_str_hashtbl[i].next, struct nfs4_client, cl_strhash);
|
|
|
|
expire_client(clp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
INIT_LIST_HEAD(&reaplist);
|
|
|
|
spin_lock(&recall_lock);
|
|
|
|
list_for_each_safe(pos, next, &del_recall_lru) {
|
|
|
|
dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
|
|
|
|
list_move(&dp->dl_recall_lru, &reaplist);
|
|
|
|
}
|
|
|
|
spin_unlock(&recall_lock);
|
|
|
|
list_for_each_safe(pos, next, &reaplist) {
|
|
|
|
dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
|
|
|
|
list_del_init(&dp->dl_recall_lru);
|
|
|
|
unhash_delegation(dp);
|
|
|
|
}
|
|
|
|
|
2005-06-24 07:04:25 +02:00
|
|
|
nfsd4_shutdown_recdir();
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nfs4_state_shutdown(void)
|
|
|
|
{
|
2010-12-14 16:21:17 +01:00
|
|
|
cancel_delayed_work_sync(&laundromat_work);
|
2006-04-11 07:55:37 +02:00
|
|
|
destroy_workqueue(laundry_wq);
|
2008-11-20 21:36:17 +01:00
|
|
|
locks_end_grace(&nfsd4_manager);
|
2005-04-17 00:20:36 +02:00
|
|
|
nfs4_lock_state();
|
|
|
|
nfs4_release_reclaim();
|
|
|
|
__nfs4_state_shutdown();
|
|
|
|
nfs4_unlock_state();
|
2010-06-04 22:42:08 +02:00
|
|
|
nfsd4_destroy_callback_queue();
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-06-10 14:40:36 +02:00
|
|
|
/*
|
|
|
|
* user_recovery_dirname is protected by the nfsd_mutex since it's only
|
|
|
|
* accessed when nfsd is starting.
|
|
|
|
*/
|
2005-06-24 07:04:32 +02:00
|
|
|
static void
|
|
|
|
nfs4_set_recdir(char *recdir)
|
|
|
|
{
|
|
|
|
strcpy(user_recovery_dirname, recdir);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Change the NFSv4 recovery directory to recdir.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
nfs4_reset_recoverydir(char *recdir)
|
|
|
|
{
|
|
|
|
int status;
|
2008-08-02 07:03:36 +02:00
|
|
|
struct path path;
|
2005-06-24 07:04:32 +02:00
|
|
|
|
2008-08-02 07:03:36 +02:00
|
|
|
status = kern_path(recdir, LOOKUP_FOLLOW, &path);
|
2005-06-24 07:04:32 +02:00
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
status = -ENOTDIR;
|
2008-08-02 07:03:36 +02:00
|
|
|
if (S_ISDIR(path.dentry->d_inode->i_mode)) {
|
2005-06-24 07:04:32 +02:00
|
|
|
nfs4_set_recdir(recdir);
|
|
|
|
status = 0;
|
|
|
|
}
|
2008-08-02 07:03:36 +02:00
|
|
|
path_put(&path);
|
2005-06-24 07:04:32 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2008-06-10 14:40:36 +02:00
|
|
|
char *
|
|
|
|
nfs4_recoverydir(void)
|
|
|
|
{
|
|
|
|
return user_recovery_dirname;
|
|
|
|
}
|