Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 37ca506a authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'nfs-server-stable' of git://linux-nfs.org/~bfields/linux 

* 'nfs-server-stable' of git://linux-nfs.org/~bfields/linux:
  knfsd: query filesystem for NFSv4 getattr of FATTR4_MAXNAME
  knfsd: nfsv4 delegation recall should take reference on client
  knfsd: don't shutdown callbacks until nfsv4 client is freed
  knfsd: let nfsd manage timing out its own leases
  knfsd: Add source address to sunrpc svc errors
  knfsd: 64 bit ino support for NFS server
  svcgss: move init code into separate function
  knfsd: remove code duplication in nfsd4_setclientid()
  nfsd warning fix
  knfsd: fix callback rpc cred
  knfsd: move nfsv4 slab creation/destruction to module init/exit
  knfsd: spawn kernel thread to probe callback channel
  knfsd: nfs4 name->id mapping not correctly parsing negative downcall
  knfsd: demote some printk()s to dprintk()s
  knfsd: cleanup of nfsd4 cmp_* functions
  knfsd: delete code made redundant by map_new_errors
  nfsd: fix horrible indentation in nfsd_setattr
  nfsd: remove unused cache_for_each macro
  nfsd: tone down inaccurate dprintk
parents b9090071 a16e92ed

fs/nfsd/nfs3xdr.c

+27 −32
Original line number Diff line number Diff line
@@ -174,9 +174,6 @@ static __be32 * 
encode_fattr3(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp,

	      struct kstat *stat)

{

	struct dentry	*dentry = fhp->fh_dentry;

	struct timespec time;



	*p++ = htonl(nfs3_ftypes[(stat->mode & S_IFMT) >> 12]);

	*p++ = htonl((u32) stat->mode);

	*p++ = htonl((u32) stat->nlink);
@@ -191,10 +188,9 @@ encode_fattr3(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp, 
	*p++ = htonl((u32) MAJOR(stat->rdev));

	*p++ = htonl((u32) MINOR(stat->rdev));

	p = encode_fsid(p, fhp);

	p = xdr_encode_hyper(p, (u64) stat->ino);

	p = xdr_encode_hyper(p, stat->ino);

	p = encode_time3(p, &stat->atime);

	lease_get_mtime(dentry->d_inode, &time); 

	p = encode_time3(p, &time);

	p = encode_time3(p, &stat->mtime);

	p = encode_time3(p, &stat->ctime);



	return p;
@@ -203,31 +199,9 @@ encode_fattr3(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp, 
static __be32 *

encode_saved_post_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)

{

	struct inode	*inode = fhp->fh_dentry->d_inode;



	/* Attributes to follow */

	*p++ = xdr_one;



	*p++ = htonl(nfs3_ftypes[(fhp->fh_post_mode & S_IFMT) >> 12]);

	*p++ = htonl((u32) fhp->fh_post_mode);

	*p++ = htonl((u32) fhp->fh_post_nlink);

	*p++ = htonl((u32) nfsd_ruid(rqstp, fhp->fh_post_uid));

	*p++ = htonl((u32) nfsd_rgid(rqstp, fhp->fh_post_gid));

	if (S_ISLNK(fhp->fh_post_mode) && fhp->fh_post_size > NFS3_MAXPATHLEN) {

		p = xdr_encode_hyper(p, (u64) NFS3_MAXPATHLEN);

	} else {

		p = xdr_encode_hyper(p, (u64) fhp->fh_post_size);

	}

	p = xdr_encode_hyper(p, ((u64)fhp->fh_post_blocks) << 9);

	*p++ = fhp->fh_post_rdev[0];

	*p++ = fhp->fh_post_rdev[1];

	p = encode_fsid(p, fhp);

	p = xdr_encode_hyper(p, (u64) inode->i_ino);

	p = encode_time3(p, &fhp->fh_post_atime);

	p = encode_time3(p, &fhp->fh_post_mtime);

	p = encode_time3(p, &fhp->fh_post_ctime);



	return p;

	return encode_fattr3(rqstp, p, fhp, &fhp->fh_post_attr);

}



/*
@@ -246,6 +220,7 @@ encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp) 
		err = vfs_getattr(fhp->fh_export->ex_mnt, dentry, &stat);

		if (!err) {

			*p++ = xdr_one;		/* attributes follow */

			lease_get_mtime(dentry->d_inode, &stat.mtime);

			return encode_fattr3(rqstp, p, fhp, &stat);

		}

	}
@@ -284,6 +259,23 @@ encode_wcc_data(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp) 
	return encode_post_op_attr(rqstp, p, fhp);

}



/*

 * Fill in the post_op attr for the wcc data

 */

void fill_post_wcc(struct svc_fh *fhp)

{

	int err;



	if (fhp->fh_post_saved)

		printk("nfsd: inode locked twice during operation.\n");



	err = vfs_getattr(fhp->fh_export->ex_mnt, fhp->fh_dentry,

			&fhp->fh_post_attr);

	if (err)

		fhp->fh_post_saved = 0;

	else

		fhp->fh_post_saved = 1;

}



/*

 * XDR decode functions
@@ -643,8 +635,11 @@ int 
nfs3svc_encode_attrstat(struct svc_rqst *rqstp, __be32 *p,

					struct nfsd3_attrstat *resp)

{

	if (resp->status == 0)

	if (resp->status == 0) {

		lease_get_mtime(resp->fh.fh_dentry->d_inode,

				&resp->stat.mtime);

		p = encode_fattr3(rqstp, p, &resp->fh, &resp->stat);

	}

	return xdr_ressize_check(rqstp, p);

}
@@ -802,7 +797,7 @@ nfs3svc_encode_readdirres(struct svc_rqst *rqstp, __be32 *p, 


static __be32 *

encode_entry_baggage(struct nfsd3_readdirres *cd, __be32 *p, const char *name,

	     int namlen, ino_t ino)

	     int namlen, u64 ino)

{

	*p++ = xdr_one;				 /* mark entry present */

	p    = xdr_encode_hyper(p, ino);	 /* file id */
@@ -873,7 +868,7 @@ compose_entry_fh(struct nfsd3_readdirres *cd, struct svc_fh *fhp, 
#define NFS3_ENTRYPLUS_BAGGAGE	(1 + 21 + 1 + (NFS3_FHSIZE >> 2))

static int

encode_entry(struct readdir_cd *ccd, const char *name, int namlen,

	     loff_t offset, ino_t ino, unsigned int d_type, int plus)

	     loff_t offset, u64 ino, unsigned int d_type, int plus)

{

	struct nfsd3_readdirres *cd = container_of(ccd, struct nfsd3_readdirres,

		       					common);

fs/nfsd/nfs4callback.c

+27 −62
Original line number Diff line number Diff line
@@ -39,6 +39,7 @@ 
#include <linux/errno.h>

#include <linux/delay.h>

#include <linux/sched.h>

#include <linux/kthread.h>

#include <linux/sunrpc/xdr.h>

#include <linux/sunrpc/svc.h>

#include <linux/sunrpc/clnt.h>
@@ -343,26 +344,28 @@ static struct rpc_version * nfs_cb_version[] = { 
	&nfs_cb_version4,

};



/*

 * Use the SETCLIENTID credential

 */

static struct rpc_cred *

nfsd4_lookupcred(struct nfs4_client *clp, int taskflags)

/* Reference counting, callback cleanup, etc., all look racy as heck.

 * And why is cb_set an atomic? */



static int do_probe_callback(void *data)

{

        struct auth_cred acred;

	struct rpc_clnt *clnt = clp->cl_callback.cb_client;

	struct rpc_cred *ret;



        get_group_info(clp->cl_cred.cr_group_info);

        acred.uid = clp->cl_cred.cr_uid;

        acred.gid = clp->cl_cred.cr_gid;

        acred.group_info = clp->cl_cred.cr_group_info;



        dprintk("NFSD:     looking up %s cred\n",

                clnt->cl_auth->au_ops->au_name);

        ret = rpcauth_lookup_credcache(clnt->cl_auth, &acred, taskflags);

        put_group_info(clp->cl_cred.cr_group_info);

        return ret;

	struct nfs4_client *clp = data;

	struct nfs4_callback *cb = &clp->cl_callback;

	struct rpc_message msg = {

		.rpc_proc       = &nfs4_cb_procedures[NFSPROC4_CLNT_CB_NULL],

		.rpc_argp       = clp,

	};

	int status;



	status = rpc_call_sync(cb->cb_client, &msg, RPC_TASK_SOFT);



	if (status) {

		rpc_shutdown_client(cb->cb_client);

		cb->cb_client = NULL;

	} else

		atomic_set(&cb->cb_set, 1);

	put_nfs4_client(clp);

	return 0;

}



/*
@@ -390,11 +393,7 @@ nfsd4_probe_callback(struct nfs4_client *clp) 
		.authflavor	= RPC_AUTH_UNIX,	/* XXX: need AUTH_GSS... */

		.flags		= (RPC_CLNT_CREATE_NOPING),

	};

	struct rpc_message msg = {

		.rpc_proc       = &nfs4_cb_procedures[NFSPROC4_CLNT_CB_NULL],

		.rpc_argp       = clp,

	};

	int status;

	struct task_struct *t;



	if (atomic_read(&cb->cb_set))

		return;
@@ -426,16 +425,11 @@ nfsd4_probe_callback(struct nfs4_client *clp) 
	/* the task holds a reference to the nfs4_client struct */

	atomic_inc(&clp->cl_count);



	msg.rpc_cred = nfsd4_lookupcred(clp,0);

	if (IS_ERR(msg.rpc_cred))

		goto out_release_clp;

	status = rpc_call_async(cb->cb_client, &msg, RPC_TASK_ASYNC, &nfs4_cb_null_ops, NULL);

	put_rpccred(msg.rpc_cred);

	t = kthread_run(do_probe_callback, clp, "nfs4_cb_probe");



	if (status != 0) {

		dprintk("NFSD: asynchronous NFSPROC4_CB_NULL failed!\n");

	if (IS_ERR(t))

		goto out_release_clp;

	}



	return;



out_release_clp:
@@ -447,30 +441,6 @@ nfsd4_probe_callback(struct nfs4_client *clp) 
		(int)clp->cl_name.len, clp->cl_name.data);

}



static void

nfs4_cb_null(struct rpc_task *task, void *dummy)

{

	struct nfs4_client *clp = (struct nfs4_client *)task->tk_msg.rpc_argp;

	struct nfs4_callback *cb = &clp->cl_callback;

	__be32 addr = htonl(cb->cb_addr);



	dprintk("NFSD: nfs4_cb_null task->tk_status %d\n", task->tk_status);



	if (task->tk_status < 0) {

		dprintk("NFSD: callback establishment to client %.*s failed\n",

			(int)clp->cl_name.len, clp->cl_name.data);

		goto out;

	}

	atomic_set(&cb->cb_set, 1);

	dprintk("NFSD: callback set to client %u.%u.%u.%u\n", NIPQUAD(addr));

out:

	put_nfs4_client(clp);

}



static const struct rpc_call_ops nfs4_cb_null_ops = {

	.rpc_call_done = nfs4_cb_null,

};



/*

 * called with dp->dl_count inc'ed.

 * nfs4_lock_state() may or may not have been called.
@@ -491,10 +461,6 @@ nfsd4_cb_recall(struct nfs4_delegation *dp) 
	if ((!atomic_read(&clp->cl_callback.cb_set)) || !clnt)

		return;



	msg.rpc_cred = nfsd4_lookupcred(clp, 0);

	if (IS_ERR(msg.rpc_cred))

		goto out;



	cbr->cbr_trunc = 0; /* XXX need to implement truncate optimization */

	cbr->cbr_dp = dp;
@@ -515,13 +481,12 @@ nfsd4_cb_recall(struct nfs4_delegation *dp) 
		status = rpc_call_sync(clnt, &msg, RPC_TASK_SOFT);

	}

out_put_cred:

	put_rpccred(msg.rpc_cred);

out:

	if (status == -EIO)

		atomic_set(&clp->cl_callback.cb_set, 0);

	/* Success or failure, now we're either waiting for lease expiration

	 * or deleg_return. */

	dprintk("NFSD: nfs4_cb_recall: dp %p dl_flock %p dl_count %d\n",dp, dp->dl_flock, atomic_read(&dp->dl_count));

	put_nfs4_client(clp);

	nfs4_put_delegation(dp);

	return;

}

fs/nfsd/nfs4idmap.c

+5 −3
Original line number Diff line number Diff line
@@ -207,6 +207,7 @@ idtoname_parse(struct cache_detail *cd, char *buf, int buflen) 
{

	struct ent ent, *res;

	char *buf1, *bp;

	int len;

	int error = -EINVAL;



	if (buf[buflen - 1] != '\n')
@@ -248,10 +249,11 @@ idtoname_parse(struct cache_detail *cd, char *buf, int buflen) 
		goto out;



	/* Name */

	error = qword_get(&buf, buf1, PAGE_SIZE);

	if (error == -EINVAL)

	error = -EINVAL;

	len = qword_get(&buf, buf1, PAGE_SIZE);

	if (len < 0)

		goto out;

	if (error == -ENOENT)

	if (len == 0)

		set_bit(CACHE_NEGATIVE, &ent.h.flags);

	else {

		if (error >= IDMAP_NAMESZ) {

fs/nfsd/nfs4proc.c

+2 −2
Original line number Diff line number Diff line
@@ -238,12 +238,12 @@ nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 
			break;

             	case NFS4_OPEN_CLAIM_DELEGATE_PREV:

			open->op_stateowner->so_confirmed = 1;

			printk("NFSD: unsupported OPEN claim type %d\n",

			dprintk("NFSD: unsupported OPEN claim type %d\n",

				open->op_claim_type);

			status = nfserr_notsupp;

			goto out;

		default:

			printk("NFSD: Invalid OPEN claim type %d\n",

			dprintk("NFSD: Invalid OPEN claim type %d\n",

				open->op_claim_type);

			status = nfserr_inval;

			goto out;

fs/nfsd/nfs4state.c

+94 −106
Original line number Diff line number Diff line
@@ -358,9 +358,22 @@ alloc_client(struct xdr_netobj name) 
	return clp;

}



static void

shutdown_callback_client(struct nfs4_client *clp)

{

	struct rpc_clnt *clnt = clp->cl_callback.cb_client;



	/* shutdown rpc client, ending any outstanding recall rpcs */

	if (clnt) {

		clp->cl_callback.cb_client = NULL;

		rpc_shutdown_client(clnt);

	}

}



static inline void

free_client(struct nfs4_client *clp)

{

	shutdown_callback_client(clp);

	if (clp->cl_cred.cr_group_info)

		put_group_info(clp->cl_cred.cr_group_info);

	kfree(clp->cl_name.data);
@@ -374,18 +387,6 @@ put_nfs4_client(struct nfs4_client *clp) 
		free_client(clp);

}



static void

shutdown_callback_client(struct nfs4_client *clp)

{

	struct rpc_clnt *clnt = clp->cl_callback.cb_client;



	/* shutdown rpc client, ending any outstanding recall rpcs */

	if (clnt) {

		clp->cl_callback.cb_client = NULL;

		rpc_shutdown_client(clnt);

	}

}



static void

expire_client(struct nfs4_client *clp)

{
@@ -396,8 +397,6 @@ expire_client(struct nfs4_client *clp) 
	dprintk("NFSD: expire_client cl_count %d\n",

	                    atomic_read(&clp->cl_count));



	shutdown_callback_client(clp);



	INIT_LIST_HEAD(&reaplist);

	spin_lock(&recall_lock);

	while (!list_empty(&clp->cl_delegations)) {
@@ -462,26 +461,28 @@ copy_cred(struct svc_cred *target, struct svc_cred *source) { 
}



static inline int

same_name(const char *n1, const char *n2) {

same_name(const char *n1, const char *n2)

{

	return 0 == memcmp(n1, n2, HEXDIR_LEN);

}



static int

cmp_verf(nfs4_verifier *v1, nfs4_verifier *v2) {

	return(!memcmp(v1->data,v2->data,sizeof(v1->data)));

same_verf(nfs4_verifier *v1, nfs4_verifier *v2)

{

	return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));

}



static int

cmp_clid(clientid_t * cl1, clientid_t * cl2) {

	return((cl1->cl_boot == cl2->cl_boot) &&

	   	(cl1->cl_id == cl2->cl_id));

same_clid(clientid_t *cl1, clientid_t *cl2)

{

	return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);

}



/* XXX what about NGROUP */

static int

cmp_creds(struct svc_cred *cr1, struct svc_cred *cr2){

	return(cr1->cr_uid == cr2->cr_uid);



same_creds(struct svc_cred *cr1, struct svc_cred *cr2)

{

	return cr1->cr_uid == cr2->cr_uid;

}



static void
@@ -507,7 +508,7 @@ check_name(struct xdr_netobj name) { 
	if (name.len == 0) 

		return 0;

	if (name.len > NFS4_OPAQUE_LIMIT) {

		printk("NFSD: check_name: name too long(%d)!\n", name.len);

		dprintk("NFSD: check_name: name too long(%d)!\n", name.len);

		return 0;

	}

	return 1;
@@ -546,7 +547,7 @@ find_confirmed_client(clientid_t *clid) 
	unsigned int idhashval = clientid_hashval(clid->cl_id);



	list_for_each_entry(clp, &conf_id_hashtbl[idhashval], cl_idhash) {

		if (cmp_clid(&clp->cl_clientid, clid))

		if (same_clid(&clp->cl_clientid, clid))

			return clp;

	}

	return NULL;
@@ -559,7 +560,7 @@ find_unconfirmed_client(clientid_t *clid) 
	unsigned int idhashval = clientid_hashval(clid->cl_id);



	list_for_each_entry(clp, &unconf_id_hashtbl[idhashval], cl_idhash) {

		if (cmp_clid(&clp->cl_clientid, clid))

		if (same_clid(&clp->cl_clientid, clid))

			return clp;

	}

	return NULL;
@@ -753,7 +754,7 @@ nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 
		 * or different ip_address

		 */

		status = nfserr_clid_inuse;

		if (!cmp_creds(&conf->cl_cred, &rqstp->rq_cred)

		if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)

				|| conf->cl_addr != sin->sin_addr.s_addr) {

			dprintk("NFSD: setclientid: string in use by client"

				"at %u.%u.%u.%u\n", NIPQUAD(conf->cl_addr));
@@ -772,14 +773,8 @@ nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 
		new = create_client(clname, dname);

		if (new == NULL)

			goto out;

		copy_verf(new, &clverifier);

		new->cl_addr = sin->sin_addr.s_addr;

		copy_cred(&new->cl_cred,&rqstp->rq_cred);

		gen_clid(new);

		gen_confirm(new);

		gen_callback(new, setclid);

		add_to_unconfirmed(new, strhashval);

	} else if (cmp_verf(&conf->cl_verifier, &clverifier)) {

	} else if (same_verf(&conf->cl_verifier, &clverifier)) {

		/*

		 * CASE 1:

		 * cl_name match, confirmed, principal match
@@ -804,13 +799,7 @@ nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 
		new = create_client(clname, dname);

		if (new == NULL)

			goto out;

		copy_verf(new,&conf->cl_verifier);

		new->cl_addr = sin->sin_addr.s_addr;

		copy_cred(&new->cl_cred,&rqstp->rq_cred);

		copy_clid(new, conf);

		gen_confirm(new);

		gen_callback(new, setclid);

		add_to_unconfirmed(new,strhashval);

	} else if (!unconf) {

		/*

		 * CASE 2:
@@ -823,14 +812,8 @@ nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 
		new = create_client(clname, dname);

		if (new == NULL)

			goto out;

		copy_verf(new,&clverifier);

		new->cl_addr = sin->sin_addr.s_addr;

		copy_cred(&new->cl_cred,&rqstp->rq_cred);

		gen_clid(new);

		gen_confirm(new);

		gen_callback(new, setclid);

		add_to_unconfirmed(new, strhashval);

	} else if (!cmp_verf(&conf->cl_confirm, &unconf->cl_confirm)) {

	} else if (!same_verf(&conf->cl_confirm, &unconf->cl_confirm)) {

		/*	

		 * CASE3:

		 * confirmed found (name, principal match)
@@ -850,19 +833,19 @@ nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 
		new = create_client(clname, dname);

		if (new == NULL)

			goto out;

		copy_verf(new,&clverifier);

		new->cl_addr = sin->sin_addr.s_addr;

		copy_cred(&new->cl_cred,&rqstp->rq_cred);

		gen_clid(new);

		gen_confirm(new);

		gen_callback(new, setclid);

		add_to_unconfirmed(new, strhashval);

	} else {

		/* No cases hit !!! */

		status = nfserr_inval;

		goto out;



	}

	copy_verf(new, &clverifier);

	new->cl_addr = sin->sin_addr.s_addr;

	copy_cred(&new->cl_cred, &rqstp->rq_cred);

	gen_confirm(new);

	gen_callback(new, setclid);

	add_to_unconfirmed(new, strhashval);

	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));
@@ -910,16 +893,16 @@ nfsd4_setclientid_confirm(struct svc_rqst *rqstp, 
		goto out;



	if ((conf && unconf) && 

	    (cmp_verf(&unconf->cl_confirm, &confirm)) &&

	    (cmp_verf(&conf->cl_verifier, &unconf->cl_verifier)) &&

	    (same_verf(&unconf->cl_confirm, &confirm)) &&

	    (same_verf(&conf->cl_verifier, &unconf->cl_verifier)) &&

	    (same_name(conf->cl_recdir,unconf->cl_recdir))  &&

	    (!cmp_verf(&conf->cl_confirm, &unconf->cl_confirm))) {

	    (!same_verf(&conf->cl_confirm, &unconf->cl_confirm))) {

		/* CASE 1:

		* unconf record that matches input clientid and input confirm.

		* conf record that matches input clientid.

		* conf and unconf records match names, verifiers

		*/

		if (!cmp_creds(&conf->cl_cred, &unconf->cl_cred)) 

		if (!same_creds(&conf->cl_cred, &unconf->cl_cred))

			status = nfserr_clid_inuse;

		else {

			/* XXX: We just turn off callbacks until we can handle
@@ -933,7 +916,7 @@ nfsd4_setclientid_confirm(struct svc_rqst *rqstp, 
		}

	} else if ((conf && !unconf) ||

	    ((conf && unconf) && 

	     (!cmp_verf(&conf->cl_verifier, &unconf->cl_verifier) ||

	     (!same_verf(&conf->cl_verifier, &unconf->cl_verifier) ||

	      !same_name(conf->cl_recdir, unconf->cl_recdir)))) {

		/* CASE 2:

		 * conf record that matches input clientid.
@@ -941,18 +924,18 @@ nfsd4_setclientid_confirm(struct svc_rqst *rqstp, 
		 * unconf->cl_name or unconf->cl_verifier don't match the

		 * conf record.

		 */

		if (!cmp_creds(&conf->cl_cred,&rqstp->rq_cred))

		if (!same_creds(&conf->cl_cred, &rqstp->rq_cred))

			status = nfserr_clid_inuse;

		else

			status = nfs_ok;

	} else if (!conf && unconf

			&& cmp_verf(&unconf->cl_confirm, &confirm)) {

			&& same_verf(&unconf->cl_confirm, &confirm)) {

		/* CASE 3:

		 * conf record not found.

		 * unconf record found.

		 * unconf->cl_confirm matches input confirm

		 */

		if (!cmp_creds(&unconf->cl_cred, &rqstp->rq_cred)) {

		if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred)) {

			status = nfserr_clid_inuse;

		} else {

			unsigned int hash =
@@ -967,8 +950,8 @@ nfsd4_setclientid_confirm(struct svc_rqst *rqstp, 
			conf = unconf;

			status = nfs_ok;

		}

	} else if ((!conf || (conf && !cmp_verf(&conf->cl_confirm, &confirm)))

	    && (!unconf || (unconf && !cmp_verf(&unconf->cl_confirm,

	} else if ((!conf || (conf && !same_verf(&conf->cl_confirm, &confirm)))

	    && (!unconf || (unconf && !same_verf(&unconf->cl_confirm,

				    				&confirm)))) {

		/* CASE 4:

		 * conf record not found, or if conf, conf->cl_confirm does not
@@ -1019,7 +1002,7 @@ nfsd4_free_slab(struct kmem_cache **slab) 
	*slab = NULL;

}



static void

void

nfsd4_free_slabs(void)

{

	nfsd4_free_slab(&stateowner_slab);
@@ -1207,10 +1190,12 @@ move_to_close_lru(struct nfs4_stateowner *sop) 
}



static int

cmp_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner, clientid_t *clid) {

	return ((sop->so_owner.len == owner->len) && 

	 !memcmp(sop->so_owner.data, owner->data, owner->len) && 

	  (sop->so_client->cl_clientid.cl_id == clid->cl_id));

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);

}



static struct nfs4_stateowner *
@@ -1219,7 +1204,7 @@ 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) {

		if (cmp_owner_str(so, &open->op_owner, &open->op_clientid))

		if (same_owner_str(so, &open->op_owner, &open->op_clientid))

			return so;

	}

	return NULL;
@@ -1360,6 +1345,7 @@ void nfsd_break_deleg_cb(struct file_lock *fl) 
	 * 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);

	atomic_inc(&dp->dl_client->cl_count);



	spin_lock(&recall_lock);

	list_add_tail(&dp->dl_recall_lru, &del_recall_lru);
@@ -1368,8 +1354,12 @@ void nfsd_break_deleg_cb(struct file_lock *fl) 
	/* only place dl_time is set. protected by lock_kernel*/

	dp->dl_time = get_seconds();



	/* XXX need to merge NFSD_LEASE_TIME with fs/locks.c:lease_break_time */

	fl->fl_break_time = jiffies + NFSD_LEASE_TIME * HZ;

	/*

	 * We don't want the locks code to timeout the lease for us;

	 * we'll remove it ourself if the delegation isn't returned

	 * in time.

	 */

	fl->fl_break_time = 0;



	t = kthread_run(do_recall, dp, "%s", "nfs4_cb_recall");

	if (IS_ERR(t)) {
@@ -1378,6 +1368,7 @@ void nfsd_break_deleg_cb(struct file_lock *fl) 
		printk(KERN_INFO "NFSD: Callback thread failed for "

			"for client (clientid %08x/%08x)\n",

			clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);

		put_nfs4_client(dp->dl_client);

		nfs4_put_delegation(dp);

	}

}
@@ -1738,7 +1729,7 @@ nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open, struct nfs4_sta 
	if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS

			&& flag == NFS4_OPEN_DELEGATE_NONE

			&& open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE)

		printk("NFSD: WARNING: refusing delegation reclaim\n");

		dprintk("NFSD: WARNING: refusing delegation reclaim\n");

	open->op_delegate_type = flag;

}
@@ -2147,7 +2138,7 @@ nfs4_preprocess_seqid_op(struct svc_fh *current_fh, u32 seqid, stateid_t *statei 
	*sopp = NULL;



	if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) {

		printk("NFSD: preprocess_seqid_op: magic stateid!\n");

		dprintk("NFSD: preprocess_seqid_op: magic stateid!\n");

		return nfserr_bad_stateid;

	}
@@ -2183,7 +2174,7 @@ nfs4_preprocess_seqid_op(struct svc_fh *current_fh, u32 seqid, stateid_t *statei 
		if (lock->lk_is_new) {

			if (!sop->so_is_open_owner)

				return nfserr_bad_stateid;

                       if (!cmp_clid(&clp->cl_clientid, lockclid))

			if (!same_clid(&clp->cl_clientid, lockclid))

			       return nfserr_bad_stateid;

			/* stp is the open stateid */

			status = nfs4_check_openmode(stp, lkflg);
@@ -2195,11 +2186,10 @@ nfs4_preprocess_seqid_op(struct svc_fh *current_fh, u32 seqid, stateid_t *statei 
			if (status)

				return status;

               }



	}



	if ((flags & CHECK_FH) && nfs4_check_fh(current_fh, stp)) {

		printk("NFSD: preprocess_seqid_op: fh-stateid mismatch!\n");

		dprintk("NFSD: preprocess_seqid_op: fh-stateid mismatch!\n");

		return nfserr_bad_stateid;

	}
@@ -2215,22 +2205,22 @@ nfs4_preprocess_seqid_op(struct svc_fh *current_fh, u32 seqid, stateid_t *statei 
		goto check_replay;



	if (sop->so_confirmed && flags & CONFIRM) {

		printk("NFSD: preprocess_seqid_op: expected"

		dprintk("NFSD: preprocess_seqid_op: expected"

				" unconfirmed stateowner!\n");

		return nfserr_bad_stateid;

	}

	if (!sop->so_confirmed && !(flags & CONFIRM)) {

		printk("NFSD: preprocess_seqid_op: stateowner not"

		dprintk("NFSD: preprocess_seqid_op: stateowner not"

				" confirmed yet!\n");

		return nfserr_bad_stateid;

	}

	if (stateid->si_generation > stp->st_stateid.si_generation) {

		printk("NFSD: preprocess_seqid_op: future stateid?!\n");

		dprintk("NFSD: preprocess_seqid_op: future stateid?!\n");

		return nfserr_bad_stateid;

	}



	if (stateid->si_generation < stp->st_stateid.si_generation) {

		printk("NFSD: preprocess_seqid_op: old stateid!\n");

		dprintk("NFSD: preprocess_seqid_op: old stateid!\n");

		return nfserr_old_stateid;

	}

	renew_client(sop->so_client);
@@ -2242,7 +2232,7 @@ nfs4_preprocess_seqid_op(struct svc_fh *current_fh, u32 seqid, stateid_t *statei 
		/* indicate replay to calling function */

		return nfserr_replay_me;

	}

	printk("NFSD: preprocess_seqid_op: bad seqid (expected %d, got %d)\n",

	dprintk("NFSD: preprocess_seqid_op: bad seqid (expected %d, got %d)\n",

			sop->so_seqid, seqid);

	*sopp = NULL;

	return nfserr_bad_seqid;
@@ -2561,7 +2551,7 @@ find_lockstateowner_str(struct inode *inode, clientid_t *clid, 
	struct nfs4_stateowner *op;



	list_for_each_entry(op, &lock_ownerstr_hashtbl[hashval], so_strhash) {

		if (cmp_owner_str(op, owner, clid))

		if (same_owner_str(op, owner, clid))

			return op;

	}

	return NULL;
@@ -2855,7 +2845,7 @@ nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 
			file_lock.fl_type = F_WRLCK;

		break;

		default:

			printk("NFSD: nfs4_lockt: bad lock type!\n");

			dprintk("NFSD: nfs4_lockt: bad lock type!\n");

			status = nfserr_inval;

		goto out;

	}
@@ -3025,7 +3015,7 @@ nfsd4_release_lockowner(struct svc_rqst *rqstp, 
	INIT_LIST_HEAD(&matches);

	for (i = 0; i < LOCK_HASH_SIZE; i++) {

		list_for_each_entry(sop, &lock_ownerid_hashtbl[i], so_idhash) {

			if (!cmp_owner_str(sop, owner, clid))

			if (!same_owner_str(sop, owner, clid))

				continue;

			list_for_each_entry(stp, &sop->so_stateids,

					st_perstateowner) {
@@ -3149,11 +3139,14 @@ nfs4_check_open_reclaim(clientid_t *clid) 


/* initialization to perform at module load time: */



void

int

nfs4_state_init(void)

{

	int i;

	int i, status;



	status = nfsd4_init_slabs();

	if (status)

		return status;

	for (i = 0; i < CLIENT_HASH_SIZE; i++) {

		INIT_LIST_HEAD(&conf_id_hashtbl[i]);

		INIT_LIST_HEAD(&conf_str_hashtbl[i]);
@@ -3182,6 +3175,7 @@ nfs4_state_init(void) 
	for (i = 0; i < CLIENT_HASH_SIZE; i++)

		INIT_LIST_HEAD(&reclaim_str_hashtbl[i]);

	reclaim_str_hashtbl_size = 0;

	return 0;

}



static void
@@ -3242,20 +3236,15 @@ __nfs4_state_start(void) 
	set_max_delegations();

}



int

void

nfs4_state_start(void)

{

	int status;



	if (nfs4_init)

		return 0;

	status = nfsd4_init_slabs();

	if (status)

		return status;

		return;

	nfsd4_load_reboot_recovery_data();

	__nfs4_state_start();

	nfs4_init = 1;

	return 0;

	return;

}



int
@@ -3313,7 +3302,6 @@ nfs4_state_shutdown(void) 
	nfs4_lock_state();

	nfs4_release_reclaim();

	__nfs4_state_shutdown();

	nfsd4_free_slabs();

	nfs4_unlock_state();

}