18 files changed, 275 insertions, 118 deletions

diff --git a/fs/lockd/clnt4xdr.c b/fs/lockd/clnt4xdr.c
index 00ec0b9c94d1..d3e40db28930 100644
--- a/fs/lockd/clnt4xdr.c
+++ b/fs/lockd/clnt4xdr.c
@@ -14,6 +14,8 @@
 #include <linux/sunrpc/stats.h>
 #include <linux/lockd/lockd.h>
 
+#include <uapi/linux/nfs3.h>
+
 #define NLMDBG_FACILITY         NLMDBG_XDR
 
 #if (NLMCLNT_OHSIZE > XDR_MAX_NETOBJ)
diff --git a/fs/lockd/clntxdr.c b/fs/lockd/clntxdr.c
index 9a55797a1cd4..3e9f7874b975 100644
--- a/fs/lockd/clntxdr.c
+++ b/fs/lockd/clntxdr.c
@@ -15,6 +15,8 @@
 #include <linux/sunrpc/stats.h>
 #include <linux/lockd/lockd.h>
 
+#include <uapi/linux/nfs2.h>
+
 #define NLMDBG_FACILITY         NLMDBG_XDR
 
 #if (NLMCLNT_OHSIZE > XDR_MAX_NETOBJ)
diff --git a/fs/lockd/svc.c b/fs/lockd/svc.c
index 6bf06a07f3e0..2b431f7266c3 100644
--- a/fs/lockd/svc.c
+++ b/fs/lockd/svc.c
@@ -622,8 +622,8 @@ static int __init init_nlm(void)
 err_pernet:
 #ifdef CONFIG_SYSCTL
         unregister_sysctl_table(nlm_sysctl_table);
-#endif
 err_sysctl:
+#endif
         return err;
 }
 
diff --git a/fs/lockd/svcsubs.c b/fs/lockd/svcsubs.c
index dc5c75930f0f..b6f3b84b6e99 100644
--- a/fs/lockd/svcsubs.c
+++ b/fs/lockd/svcsubs.c
@@ -14,12 +14,11 @@
 #include <linux/mutex.h>
 #include <linux/sunrpc/svc.h>
 #include <linux/sunrpc/addr.h>
-#include <linux/nfsd/nfsfh.h>
-#include <linux/nfsd/export.h>
 #include <linux/lockd/lockd.h>
 #include <linux/lockd/share.h>
 #include <linux/module.h>
 #include <linux/mount.h>
+#include <uapi/linux/nfs2.h>
 
 #define NLMDBG_FACILITY         NLMDBG_SVCSUBS
 
diff --git a/fs/lockd/xdr.c b/fs/lockd/xdr.c
index 964666c68a86..9340e7e10ef6 100644
--- a/fs/lockd/xdr.c
+++ b/fs/lockd/xdr.c
@@ -16,6 +16,8 @@
 #include <linux/sunrpc/stats.h>
 #include <linux/lockd/lockd.h>
 
+#include <uapi/linux/nfs2.h>
+
 #define NLMDBG_FACILITY         NLMDBG_XDR
 
 
diff --git a/fs/nfsd/export.h b/fs/nfsd/export.h
new file mode 100644
index 000000000000..d7939a62a0ae
--- /dev/null
+++ b/fs/nfsd/export.h
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 1995-1997 Olaf Kirch <okir@monad.swb.de>
+ */
+#ifndef NFSD_EXPORT_H
+#define NFSD_EXPORT_H
+
+#include <linux/sunrpc/cache.h>
+#include <uapi/linux/nfsd/export.h>
+
+struct knfsd_fh;
+struct svc_fh;
+struct svc_rqst;
+
+/*
+ * FS Locations
+ */
+
+#define MAX_FS_LOCATIONS        128
+
+struct nfsd4_fs_location {
+        char *hosts; /* colon separated list of hosts */
+        char *path;  /* slash separated list of path components */
+};
+
+struct nfsd4_fs_locations {
+        uint32_t locations_count;
+        struct nfsd4_fs_location *locations;
+/* If we're not actually serving this data ourselves (only providing a
+ * list of replicas that do serve it) then we set "migrated": */
+        int migrated;
+};
+
+/*
+ * We keep an array of pseudoflavors with the export, in order from most
+ * to least preferred.  For the foreseeable future, we don't expect more
+ * than the eight pseudoflavors null, unix, krb5, krb5i, krb5p, skpm3,
+ * spkm3i, and spkm3p (and using all 8 at once should be rare).
+ */
+#define MAX_SECINFO_LIST        8
+
+struct exp_flavor_info {
+        u32     pseudoflavor;
+        u32     flags;
+};
+
+struct svc_export {
+        struct cache_head       h;
+        struct auth_domain *    ex_client;
+        int                     ex_flags;
+        struct path             ex_path;
+        kuid_t                  ex_anon_uid;
+        kgid_t                  ex_anon_gid;
+        int                     ex_fsid;
+        unsigned char *         ex_uuid; /* 16 byte fsid */
+        struct nfsd4_fs_locations ex_fslocs;
+        int                     ex_nflavors;
+        struct exp_flavor_info  ex_flavors[MAX_SECINFO_LIST];
+        struct cache_detail     *cd;
+};
+
+/* an "export key" (expkey) maps a filehandlefragement to an
+ * svc_export for a given client.  There can be several per export,
+ * for the different fsid types.
+ */
+struct svc_expkey {
+        struct cache_head       h;
+
+        struct auth_domain *    ek_client;
+        int                     ek_fsidtype;
+        u32                     ek_fsid[6];
+
+        struct path             ek_path;
+};
+
+#define EX_ISSYNC(exp)          (!((exp)->ex_flags & NFSEXP_ASYNC))
+#define EX_NOHIDE(exp)          ((exp)->ex_flags & NFSEXP_NOHIDE)
+#define EX_WGATHER(exp)         ((exp)->ex_flags & NFSEXP_GATHERED_WRITES)
+
+int nfsexp_flags(struct svc_rqst *rqstp, struct svc_export *exp);
+__be32 check_nfsd_access(struct svc_export *exp, struct svc_rqst *rqstp);
+
+/*
+ * Function declarations
+ */
+int                     nfsd_export_init(struct net *);
+void                    nfsd_export_shutdown(struct net *);
+void                    nfsd_export_flush(struct net *);
+struct svc_export *     rqst_exp_get_by_name(struct svc_rqst *,
+                                             struct path *);
+struct svc_export *     rqst_exp_parent(struct svc_rqst *,
+                                        struct path *);
+struct svc_export *     rqst_find_fsidzero_export(struct svc_rqst *);
+int                     exp_rootfh(struct net *, struct auth_domain *,
+                                        char *path, struct knfsd_fh *, int maxsize);
+__be32                  exp_pseudoroot(struct svc_rqst *, struct svc_fh *);
+__be32                  nfserrno(int errno);
+
+static inline void exp_put(struct svc_export *exp)
+{
+        cache_put(&exp->h, exp->cd);
+}
+
+static inline void exp_get(struct svc_export *exp)
+{
+        cache_get(&exp->h);
+}
+struct svc_export * rqst_exp_find(struct svc_rqst *, int, u32 *);
+
+#endif /* NFSD_EXPORT_H */
diff --git a/fs/nfsd/fault_inject.c b/fs/nfsd/fault_inject.c
index d620e7f81429..2ed05c3cd43d 100644
--- a/fs/nfsd/fault_inject.c
+++ b/fs/nfsd/fault_inject.c
@@ -97,25 +97,14 @@ static ssize_t fault_inject_read(struct file *file, char __user *buf,
 {
         static u64 val;
         char read_buf[25];
-        size_t size, ret;
+        size_t size;
         loff_t pos = *ppos;
 
         if (!pos)
                 nfsd_inject_get(file_inode(file)->i_private, &val);
         size = scnprintf(read_buf, sizeof(read_buf), "%llu\n", val);
 
-        if (pos < 0)
-                return -EINVAL;
-        if (pos >= size || !len)
-                return 0;
-        if (len > size - pos)
-                len = size - pos;
-        ret = copy_to_user(buf, read_buf + pos, len);
-        if (ret == len)
-                return -EFAULT;
-        len -= ret;
-        *ppos = pos + len;
-        return len;
+        return simple_read_from_buffer(buf, len, ppos, read_buf, size);
 }
 
 static ssize_t fault_inject_write(struct file *file, const char __user *buf,
diff --git a/fs/nfsd/nfs4acl.c b/fs/nfsd/nfs4acl.c
index f66c66b9f182..7c7c02554a81 100644
--- a/fs/nfsd/nfs4acl.c
+++ b/fs/nfsd/nfs4acl.c
@@ -36,7 +36,6 @@
 
 #include <linux/slab.h>
 #include <linux/nfs_fs.h>
-#include <linux/export.h>
 #include "nfsfh.h"
 #include "nfsd.h"
 #include "acl.h"
diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c
index d543222babf3..ac837783b37d 100644
--- a/fs/nfsd/nfs4proc.c
+++ b/fs/nfsd/nfs4proc.c
@@ -786,7 +786,6 @@ nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
         if (!nfsd4_last_compound_op(rqstp))
                 rqstp->rq_splice_ok = false;
 
-        nfs4_lock_state();
         /* check stateid */
         if ((status = nfs4_preprocess_stateid_op(SVC_NET(rqstp),
                                                  cstate, &read->rd_stateid,
@@ -794,11 +793,8 @@ nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
                 dprintk("NFSD: nfsd4_read: couldn't process stateid!\n");
                 goto out;
         }
-        if (read->rd_filp)
-                get_file(read->rd_filp);
         status = nfs_ok;
 out:
-        nfs4_unlock_state();
         read->rd_rqstp = rqstp;
         read->rd_fhp = &cstate->current_fh;
         return status;
@@ -937,10 +933,8 @@ nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
         int err;
 
         if (setattr->sa_iattr.ia_valid & ATTR_SIZE) {
-                nfs4_lock_state();
                 status = nfs4_preprocess_stateid_op(SVC_NET(rqstp), cstate,
                         &setattr->sa_stateid, WR_STATE, NULL);
-                nfs4_unlock_state();
                 if (status) {
                         dprintk("NFSD: nfsd4_setattr: couldn't process stateid!\n");
                         return status;
@@ -1006,17 +1000,12 @@ nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
         if (write->wr_offset >= OFFSET_MAX)
                 return nfserr_inval;
 
-        nfs4_lock_state();
         status = nfs4_preprocess_stateid_op(SVC_NET(rqstp),
                                         cstate, stateid, WR_STATE, &filp);
         if (status) {
-                nfs4_unlock_state();
                 dprintk("NFSD: nfsd4_write: couldn't process stateid!\n");
                 return status;
         }
-        if (filp)
-                get_file(filp);
-        nfs4_unlock_state();
 
         cnt = write->wr_buflen;
         write->wr_how_written = write->wr_stable_how;
diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index 9a77a5a21557..a037627ce5c7 100644
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -418,6 +418,8 @@ nfs4_put_delegation(struct nfs4_delegation *dp)
 
 static void nfs4_put_deleg_lease(struct nfs4_file *fp)
 {
+        if (!fp->fi_lease)
+                return;
         if (atomic_dec_and_test(&fp->fi_delegees)) {
                 vfs_setlease(fp->fi_deleg_file, F_UNLCK, &fp->fi_lease);
                 fp->fi_lease = NULL;
@@ -440,9 +442,11 @@ unhash_delegation(struct nfs4_delegation *dp)
         list_del_init(&dp->dl_perfile);
         list_del_init(&dp->dl_recall_lru);
         spin_unlock(&recall_lock);
-        nfs4_put_deleg_lease(dp->dl_file);
-        put_nfs4_file(dp->dl_file);
-        dp->dl_file = NULL;
+        if (dp->dl_file) {
+                nfs4_put_deleg_lease(dp->dl_file);
+                put_nfs4_file(dp->dl_file);
+                dp->dl_file = NULL;
+        }
 }
 
 
@@ -645,6 +649,12 @@ static void unhash_lockowner(struct nfs4_lockowner *lo)
         }
 }
 
+static void nfs4_free_lockowner(struct nfs4_lockowner *lo)
+{
+        kfree(lo->lo_owner.so_owner.data);
+        kmem_cache_free(lockowner_slab, lo);
+}
+
 static void release_lockowner(struct nfs4_lockowner *lo)
 {
         unhash_lockowner(lo);
@@ -699,6 +709,12 @@ static void release_last_closed_stateid(struct nfs4_openowner *oo)
         }
 }
 
+static void nfs4_free_openowner(struct nfs4_openowner *oo)
+{
+        kfree(oo->oo_owner.so_owner.data);
+        kmem_cache_free(openowner_slab, oo);
+}
+
 static void release_openowner(struct nfs4_openowner *oo)
 {
         unhash_openowner(oo);
@@ -1093,7 +1109,7 @@ static struct nfs4_client *alloc_client(struct xdr_netobj name)
         return clp;
 }
 
-static inline void
+static void
 free_client(struct nfs4_client *clp)
 {
         struct nfsd_net __maybe_unused *nn = net_generic(clp->net, nfsd_net_id);
@@ -2553,18 +2569,6 @@ out_nomem:
         return -ENOMEM;
 }
 
-void nfs4_free_openowner(struct nfs4_openowner *oo)
-{
-        kfree(oo->oo_owner.so_owner.data);
-        kmem_cache_free(openowner_slab, oo);
-}
-
-void nfs4_free_lockowner(struct nfs4_lockowner *lo)
-{
-        kfree(lo->lo_owner.so_owner.data);
-        kmem_cache_free(lockowner_slab, lo);
-}
-
 static void init_nfs4_replay(struct nfs4_replay *rp)
 {
         rp->rp_status = nfserr_serverfault;
@@ -3060,33 +3064,22 @@ out_free:
 
 static int nfs4_set_delegation(struct nfs4_delegation *dp, struct nfs4_file *fp)
 {
-        int status;
-
         if (fp->fi_had_conflict)
                 return -EAGAIN;
         get_nfs4_file(fp);
         dp->dl_file = fp;
-        if (!fp->fi_lease) {
-                status = nfs4_setlease(dp);
-                if (status)
-                        goto out_free;
-                return 0;
-        }
+        if (!fp->fi_lease)
+                return nfs4_setlease(dp);
         spin_lock(&recall_lock);
+        atomic_inc(&fp->fi_delegees);
         if (fp->fi_had_conflict) {
                 spin_unlock(&recall_lock);
-                status = -EAGAIN;
-                goto out_free;
+                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_stid.sc_client->cl_delegations);
         return 0;
-out_free:
-        put_nfs4_file(fp);
-        dp->dl_file = fp;
-        return status;
 }
 
 static void nfsd4_open_deleg_none_ext(struct nfsd4_open *open, int status)
@@ -3173,8 +3166,7 @@ nfs4_open_delegation(struct net *net, struct svc_fh *fh,
         open->op_delegate_type = NFS4_OPEN_DELEGATE_READ;
         return;
 out_free:
-        remove_stid(&dp->dl_stid);
-        nfs4_put_delegation(dp);
+        destroy_delegation(dp);
 out_no_deleg:
         open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE;
         if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS &&
@@ -3654,6 +3646,7 @@ nfs4_preprocess_stateid_op(struct net *net, struct nfsd4_compound_state *cstate,
         struct svc_fh *current_fh = &cstate->current_fh;
         struct inode *ino = current_fh->fh_dentry->d_inode;
         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
+        struct file *file = NULL;
         __be32 status;
 
         if (filpp)
@@ -3665,10 +3658,12 @@ nfs4_preprocess_stateid_op(struct net *net, struct nfsd4_compound_state *cstate,
         if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
                 return check_special_stateids(net, current_fh, stateid, flags);
 
+        nfs4_lock_state();
+
         status = nfsd4_lookup_stateid(stateid, NFS4_DELEG_STID|NFS4_OPEN_STID|NFS4_LOCK_STID,
                                       &s, cstate->minorversion, nn);
         if (status)
-                return status;
+                goto out;
         status = check_stateid_generation(stateid, &s->sc_stateid, nfsd4_has_session(cstate));
         if (status)
                 goto out;
@@ -3679,8 +3674,8 @@ nfs4_preprocess_stateid_op(struct net *net, struct nfsd4_compound_state *cstate,
                 if (status)
                         goto out;
                 if (filpp) {
-                        *filpp = dp->dl_file->fi_deleg_file;
-                        if (!*filpp) {
+                        file = dp->dl_file->fi_deleg_file;
+                        if (!file) {
                                 WARN_ON_ONCE(1);
                                 status = nfserr_serverfault;
                                 goto out;
@@ -3701,16 +3696,20 @@ nfs4_preprocess_stateid_op(struct net *net, struct nfsd4_compound_state *cstate,
                         goto out;
                 if (filpp) {
                         if (flags & RD_STATE)
-                                *filpp = find_readable_file(stp->st_file);
+                                file = find_readable_file(stp->st_file);
                         else
-                                *filpp = find_writeable_file(stp->st_file);
+                                file = find_writeable_file(stp->st_file);
                 }
                 break;
         default:
-                return nfserr_bad_stateid;
+                status = nfserr_bad_stateid;
+                goto out;
         }
         status = nfs_ok;
+        if (file)
+                *filpp = get_file(file);
 out:
+        nfs4_unlock_state();
         return status;
 }
 
@@ -4983,13 +4982,6 @@ struct nfs4_client *nfsd_find_client(struct sockaddr_storage *addr, size_t addr_
 
 #endif /* CONFIG_NFSD_FAULT_INJECTION */
 
-/* initialization to perform at module load time: */
-
-void
-nfs4_state_init(void)
-{
-}
-
 /*
  * 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
diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c
index f34d9de802ab..51844048937f 100644
--- a/fs/nfsd/nfsctl.c
+++ b/fs/nfsd/nfsctl.c
@@ -1179,7 +1179,6 @@ static int __init init_nfsd(void)
         retval = nfsd4_init_slabs();
         if (retval)
                 goto out_unregister_pernet;
-        nfs4_state_init();
         retval = nfsd_fault_inject_init(); /* nfsd fault injection controls */
         if (retval)
                 goto out_free_slabs;
diff --git a/fs/nfsd/nfsd.h b/fs/nfsd/nfsd.h
index 479eb681c27c..847daf37e566 100644
--- a/fs/nfsd/nfsd.h
+++ b/fs/nfsd/nfsd.h
@@ -15,11 +15,20 @@
 #include <linux/nfs2.h>
 #include <linux/nfs3.h>
 #include <linux/nfs4.h>
+#include <linux/sunrpc/svc.h>
 #include <linux/sunrpc/msg_prot.h>
 
-#include <linux/nfsd/debug.h>
-#include <linux/nfsd/export.h>
-#include <linux/nfsd/stats.h>
+#include <uapi/linux/nfsd/debug.h>
+
+#include "stats.h"
+#include "export.h"
+
+#undef ifdebug
+#ifdef NFSD_DEBUG
+# define ifdebug(flag)          if (nfsd_debug & NFSDDBG_##flag)
+#else
+# define ifdebug(flag)          if (0)
+#endif
 
 /*
  * nfsd version
@@ -106,7 +115,6 @@ static inline int nfsd_v4client(struct svc_rqst *rq)
  */
 #ifdef CONFIG_NFSD_V4
 extern unsigned long max_delegations;
-void nfs4_state_init(void);
 int nfsd4_init_slabs(void);
 void nfsd4_free_slabs(void);
 int nfs4_state_start(void);
@@ -117,7 +125,6 @@ void nfs4_reset_lease(time_t leasetime);
 int nfs4_reset_recoverydir(char *recdir);
 char * nfs4_recoverydir(void);
 #else
-static inline void nfs4_state_init(void) { }
 static inline int nfsd4_init_slabs(void) { return 0; }
 static inline void nfsd4_free_slabs(void) { }
 static inline int nfs4_state_start(void) { return 0; }
diff --git a/fs/nfsd/nfsfh.c b/fs/nfsd/nfsfh.c
index 3c37b160dcad..a337106d6875 100644
--- a/fs/nfsd/nfsfh.c
+++ b/fs/nfsd/nfsfh.c
@@ -169,8 +169,8 @@ static __be32 nfsd_set_fh_dentry(struct svc_rqst *rqstp, struct svc_fh *fhp)
                 data_left -= len;
                 if (data_left < 0)
                         return error;
-                exp = rqst_exp_find(rqstp, fh->fh_fsid_type, fh->fh_auth);
-                fid = (struct fid *)(fh->fh_auth + len);
+                exp = rqst_exp_find(rqstp, fh->fh_fsid_type, fh->fh_fsid);
+                fid = (struct fid *)(fh->fh_fsid + len);
         } else {
                 __u32 tfh[2];
                 dev_t xdev;
@@ -385,7 +385,7 @@ static void _fh_update(struct svc_fh *fhp, struct svc_export *exp,
 {
         if (dentry != exp->ex_path.dentry) {
                 struct fid *fid = (struct fid *)
-                        (fhp->fh_handle.fh_auth + fhp->fh_handle.fh_size/4 - 1);
+                        (fhp->fh_handle.fh_fsid + fhp->fh_handle.fh_size/4 - 1);
                 int maxsize = (fhp->fh_maxsize - fhp->fh_handle.fh_size)/4;
                 int subtreecheck = !(exp->ex_flags & NFSEXP_NOSUBTREECHECK);
 
@@ -513,7 +513,6 @@ fh_compose(struct svc_fh *fhp, struct svc_export *exp, struct dentry *dentry,
          */
 
         struct inode * inode = dentry->d_inode;
-        __u32 *datap;
         dev_t ex_dev = exp_sb(exp)->s_dev;
 
         dprintk("nfsd: fh_compose(exp %02x:%02x/%ld %pd2, ino=%ld)\n",
@@ -557,17 +556,16 @@ fh_compose(struct svc_fh *fhp, struct svc_export *exp, struct dentry *dentry,
                 if (inode)
                         _fh_update_old(dentry, exp, &fhp->fh_handle);
         } else {
-                int len;
+                fhp->fh_handle.fh_size =
+                        key_len(fhp->fh_handle.fh_fsid_type) + 4;
                 fhp->fh_handle.fh_auth_type = 0;
-                datap = fhp->fh_handle.fh_auth+0;
-                mk_fsid(fhp->fh_handle.fh_fsid_type, datap, ex_dev,
+
+                mk_fsid(fhp->fh_handle.fh_fsid_type,
+                        fhp->fh_handle.fh_fsid,
+                        ex_dev,
                         exp->ex_path.dentry->d_inode->i_ino,
                         exp->ex_fsid, exp->ex_uuid);
 
-                len = key_len(fhp->fh_handle.fh_fsid_type);
-                datap += len/4;
-                fhp->fh_handle.fh_size = 4 + len;
-
                 if (inode)
                         _fh_update(fhp, exp, dentry);
                 if (fhp->fh_handle.fh_fileid_type == FILEID_INVALID) {
diff --git a/fs/nfsd/nfsfh.h b/fs/nfsd/nfsfh.h
index ad67964d0bb1..2e89e70ac15c 100644
--- a/fs/nfsd/nfsfh.h
+++ b/fs/nfsd/nfsfh.h
@@ -1,9 +1,58 @@
-/* Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de> */
+/*
+ * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de>
+ *
+ * This file describes the layout of the file handles as passed
+ * over the wire.
+ */
+#ifndef _LINUX_NFSD_NFSFH_H
+#define _LINUX_NFSD_NFSFH_H
+
+#include <linux/sunrpc/svc.h>
+#include <uapi/linux/nfsd/nfsfh.h>
+
+static inline __u32 ino_t_to_u32(ino_t ino)
+{
+        return (__u32) ino;
+}
+
+static inline ino_t u32_to_ino_t(__u32 uino)
+{
+        return (ino_t) uino;
+}
 
-#ifndef _LINUX_NFSD_FH_INT_H
-#define _LINUX_NFSD_FH_INT_H
+/*
+ * This is the internal representation of an NFS handle used in knfsd.
+ * pre_mtime/post_version will be used to support wcc_attr's in NFSv3.
+ */
+typedef struct svc_fh {
+        struct knfsd_fh         fh_handle;      /* FH data */
+        struct dentry *         fh_dentry;      /* validated dentry */
+        struct svc_export *     fh_export;      /* export pointer */
+        int                     fh_maxsize;     /* max size for fh_handle */
+
+        unsigned char           fh_locked;      /* inode locked by us */
+        unsigned char           fh_want_write;  /* remount protection taken */
+
+#ifdef CONFIG_NFSD_V3
+        unsigned char           fh_post_saved;  /* post-op attrs saved */
+        unsigned char           fh_pre_saved;   /* pre-op attrs saved */
+
+        /* Pre-op attributes saved during fh_lock */
+        __u64                   fh_pre_size;    /* size before operation */
+        struct timespec         fh_pre_mtime;   /* mtime before oper */
+        struct timespec         fh_pre_ctime;   /* ctime before oper */
+        /*
+         * pre-op nfsv4 change attr: note must check IS_I_VERSION(inode)
+         *  to find out if it is valid.
+         */
+        u64                     fh_pre_change;
+
+        /* Post-op attributes saved in fh_unlock */
+        struct kstat            fh_post_attr;   /* full attrs after operation */
+        u64                     fh_post_change; /* nfsv4 change; see above */
+#endif /* CONFIG_NFSD_V3 */
 
-#include <linux/nfsd/nfsfh.h>
+} svc_fh;
 
 enum nfsd_fsid {
         FSID_DEV = 0,
@@ -215,4 +264,4 @@ fh_unlock(struct svc_fh *fhp)
         }
 }
 
-#endif /* _LINUX_NFSD_FH_INT_H */
+#endif /* _LINUX_NFSD_NFSFH_H */
diff --git a/fs/nfsd/state.h b/fs/nfsd/state.h
index 424d8f5f2317..fda9ce28b1b2 100644
--- a/fs/nfsd/state.h
+++ b/fs/nfsd/state.h
@@ -37,7 +37,6 @@
 
 #include <linux/idr.h>
 #include <linux/sunrpc/svc_xprt.h>
-#include <linux/nfsd/nfsfh.h>
 #include "nfsfh.h"
 
 typedef struct {
@@ -464,8 +463,6 @@ extern void nfs4_release_reclaim(struct nfsd_net *);
 extern struct nfs4_client_reclaim *nfsd4_find_reclaim_client(const char *recdir,
                                                         struct nfsd_net *nn);
 extern __be32 nfs4_check_open_reclaim(clientid_t *clid, bool sessions, struct nfsd_net *nn);
-extern void nfs4_free_openowner(struct nfs4_openowner *);
-extern void nfs4_free_lockowner(struct nfs4_lockowner *);
 extern int set_callback_cred(void);
 extern void nfsd4_init_callback(struct nfsd4_callback *);
 extern void nfsd4_probe_callback(struct nfs4_client *clp);
diff --git a/fs/nfsd/stats.c b/fs/nfsd/stats.c
index 6d4521feb6e3..cd90878a76aa 100644
--- a/fs/nfsd/stats.c
+++ b/fs/nfsd/stats.c
@@ -24,7 +24,6 @@
 #include <linux/seq_file.h>
 #include <linux/module.h>
 #include <linux/sunrpc/stats.h>
-#include <linux/nfsd/stats.h>
 #include <net/net_namespace.h>
 
 #include "nfsd.h"
diff --git a/fs/nfsd/stats.h b/fs/nfsd/stats.h
new file mode 100644
index 000000000000..a5c944b771c6
--- /dev/null
+++ b/fs/nfsd/stats.h
@@ -0,0 +1,43 @@
+/*
+ * Statistics for NFS server.
+ *
+ * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
+ */
+#ifndef _NFSD_STATS_H
+#define _NFSD_STATS_H
+
+#include <uapi/linux/nfsd/stats.h>
+
+
+struct nfsd_stats {
+        unsigned int    rchits;         /* repcache hits */
+        unsigned int    rcmisses;       /* repcache hits */
+        unsigned int    rcnocache;      /* uncached reqs */
+        unsigned int    fh_stale;       /* FH stale error */
+        unsigned int    fh_lookup;      /* dentry cached */
+        unsigned int    fh_anon;        /* anon file dentry returned */
+        unsigned int    fh_nocache_dir; /* filehandle not found in dcache */
+        unsigned int    fh_nocache_nondir;      /* filehandle not found in dcache */
+        unsigned int    io_read;        /* bytes returned to read requests */
+        unsigned int    io_write;       /* bytes passed in write requests */
+        unsigned int    th_cnt;         /* number of available threads */
+        unsigned int    th_usage[10];   /* number of ticks during which n perdeciles
+                                         * of available threads were in use */
+        unsigned int    th_fullcnt;     /* number of times last free thread was used */
+        unsigned int    ra_size;        /* size of ra cache */
+        unsigned int    ra_depth[11];   /* number of times ra entry was found that deep
+                                         * in the cache (10percentiles). [10] = not found */
+#ifdef CONFIG_NFSD_V4
+        unsigned int    nfs4_opcount[LAST_NFS4_OP + 1]; /* count of individual nfsv4 operations */
+#endif
+
+};
+
+
+extern struct nfsd_stats        nfsdstats;
+extern struct svc_stat          nfsd_svcstats;
+
+void    nfsd_stat_init(void);
+void    nfsd_stat_shutdown(void);
+
+#endif /* _NFSD_STATS_H */
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index 16f0673a423c..6aaa3057683a 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -857,20 +857,6 @@ nfsd_vfs_read(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
         return err;
 }
 
-static void kill_suid(struct dentry *dentry)
-{
-        struct iattr    ia;
-        ia.ia_valid = ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_KILL_PRIV;
-
-        mutex_lock(&dentry->d_inode->i_mutex);
-        /*
-         * Note we call this on write, so notify_change will not
-         * encounter any conflicting delegations:
-         */
-        notify_change(dentry, &ia, NULL);
-        mutex_unlock(&dentry->d_inode->i_mutex);
-}
-
 /*
  * Gathered writes: If another process is currently writing to the file,
  * there's a high chance this is another nfsd (triggered by a bulk write
@@ -942,10 +928,6 @@ nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
         nfsdstats.io_write += host_err;
         fsnotify_modify(file);
 
-        /* clear setuid/setgid flag after write */
-        if (inode->i_mode & (S_ISUID | S_ISGID))
-                kill_suid(dentry);
-
         if (stable) {
                 if (use_wgather)
                         host_err = wait_for_concurrent_writes(file);