NFS: Split fs/nfs/inode.c
David Howells [Fri, 9 Jun 2006 13:34:33 +0000 (09:34 -0400)]
As fs/nfs/inode.c is rather large, heterogenous and unwieldy, the attached
patch splits it up into a number of files:

 (*) fs/nfs/inode.c

     Strictly inode specific functions.

 (*) fs/nfs/super.c

     Superblock management functions for NFS and NFS4, normal access, clones
     and referrals.  The NFS4 superblock functions _could_ move out into a
     separate conditionally compiled file, but it's probably not worth it as
     there're so many common bits.

 (*) fs/nfs/namespace.c

     Some namespace-specific functions have been moved here.

 (*) fs/nfs/nfs4namespace.c

     NFS4-specific namespace functions (this could be merged into the previous
     file).  This file is conditionally compiled.

 (*) fs/nfs/internal.h

     Inter-file declarations, plus a few simple utility functions moved from
     fs/nfs/inode.c.

     Additionally, all the in-.c-file externs have been moved here, and those
     files they were moved from now includes this file.

For the most part, the functions have not been changed, only some multiplexor
functions have changed significantly.

I've also:

 (*) Added some extra banner comments above some functions.

 (*) Rearranged the function order within the files to be more logical and
     better grouped (IMO), though someone may prefer a different order.

 (*) Reduced the number of #ifdefs in .c files.

 (*) Added missing __init and __exit directives.

Signed-Off-By: David Howells <dhowells@redhat.com>

16 files changed:
fs/nfs/Makefile
fs/nfs/callback.c
fs/nfs/direct.c
fs/nfs/inode.c
fs/nfs/internal.h [new file with mode: 0644]
fs/nfs/namespace.c
fs/nfs/nfs2xdr.c
fs/nfs/nfs3proc.c
fs/nfs/nfs3xdr.c
fs/nfs/nfs4namespace.c [new file with mode: 0644]
fs/nfs/nfs4proc.c
fs/nfs/pagelist.c
fs/nfs/proc.c
fs/nfs/read.c
fs/nfs/super.c [new file with mode: 0644]
fs/nfs/write.c

index d9d494c..0b572a0 100644 (file)
@@ -4,7 +4,7 @@
 
 obj-$(CONFIG_NFS_FS) += nfs.o
 
-nfs-y                  := dir.o file.o inode.o nfs2xdr.o pagelist.o \
+nfs-y                  := dir.o file.o inode.o super.o nfs2xdr.o pagelist.o \
                           proc.o read.o symlink.o unlink.o write.o \
                           namespace.o
 nfs-$(CONFIG_ROOT_NFS) += nfsroot.o mount_clnt.o      
@@ -12,7 +12,8 @@ nfs-$(CONFIG_NFS_V3)  += nfs3proc.o nfs3xdr.o
 nfs-$(CONFIG_NFS_V3_ACL)       += nfs3acl.o
 nfs-$(CONFIG_NFS_V4)   += nfs4proc.o nfs4xdr.o nfs4state.o nfs4renewd.o \
                           delegation.o idmap.o \
-                          callback.o callback_xdr.o callback_proc.o
+                          callback.o callback_xdr.o callback_proc.o \
+                          nfs4namespace.o
 nfs-$(CONFIG_NFS_DIRECTIO) += direct.o
 nfs-$(CONFIG_SYSCTL) += sysctl.o
 nfs-objs               := $(nfs-y)
index 90c95ad..d53f8c6 100644 (file)
@@ -182,8 +182,6 @@ static int nfs_callback_authenticate(struct svc_rqst *rqstp)
 /*
  * Define NFS4 callback program
  */
-extern struct svc_version nfs4_callback_version1;
-
 static struct svc_version *nfs4_callback_version[] = {
        [1] = &nfs4_callback_version1,
 };
index 3c72b0c..402005c 100644 (file)
@@ -892,7 +892,7 @@ out:
  * nfs_init_directcache - create a slab cache for nfs_direct_req structures
  *
  */
-int nfs_init_directcache(void)
+int __init nfs_init_directcache(void)
 {
        nfs_direct_cachep = kmem_cache_create("nfs_direct_cache",
                                                sizeof(struct nfs_direct_req),
@@ -906,10 +906,10 @@ int nfs_init_directcache(void)
 }
 
 /**
- * nfs_init_directcache - destroy the slab cache for nfs_direct_req structures
+ * nfs_destroy_directcache - destroy the slab cache for nfs_direct_req structures
  *
  */
-void nfs_destroy_directcache(void)
+void __exit nfs_destroy_directcache(void)
 {
        if (kmem_cache_destroy(nfs_direct_cachep))
                printk(KERN_INFO "nfs_direct_cache: not all structures were freed\n");
index 7ab2b38..24a7139 100644 (file)
 #include "callback.h"
 #include "delegation.h"
 #include "iostat.h"
+#include "internal.h"
 
 #define NFSDBG_FACILITY                NFSDBG_VFS
 #define NFS_PARANOIA 1
 
-/* Maximum number of readahead requests
- * FIXME: this should really be a sysctl so that users may tune it to suit
- *        their needs. People that do NFS over a slow network, might for
- *        instance want to reduce it to something closer to 1 for improved
- *        interactive response.
- */
-#define NFS_MAX_READAHEAD      (RPC_DEF_SLOT_TABLE - 1)
-
 static void nfs_invalidate_inode(struct inode *);
 static int nfs_update_inode(struct inode *, struct nfs_fattr *);
 
-static struct inode *nfs_alloc_inode(struct super_block *sb);
-static void nfs_destroy_inode(struct inode *);
-static int nfs_write_inode(struct inode *,int);
-static void nfs_clear_inode(struct inode *);
-static void nfs_umount_begin(struct vfsmount *, int);
-static int  nfs_statfs(struct super_block *, struct kstatfs *);
-static int  nfs_show_options(struct seq_file *, struct vfsmount *);
-static int  nfs_show_stats(struct seq_file *, struct vfsmount *);
 static void nfs_zap_acl_cache(struct inode *);
 
-static struct rpc_program      nfs_program;
-
-static struct super_operations nfs_sops = { 
-       .alloc_inode    = nfs_alloc_inode,
-       .destroy_inode  = nfs_destroy_inode,
-       .write_inode    = nfs_write_inode,
-       .statfs         = nfs_statfs,
-       .clear_inode    = nfs_clear_inode,
-       .umount_begin   = nfs_umount_begin,
-       .show_options   = nfs_show_options,
-       .show_stats     = nfs_show_stats,
-};
-
-/*
- * RPC cruft for NFS
- */
-static struct rpc_stat         nfs_rpcstat = {
-       .program                = &nfs_program
-};
-static struct rpc_version *    nfs_version[] = {
-       NULL,
-       NULL,
-       &nfs_version2,
-#if defined(CONFIG_NFS_V3)
-       &nfs_version3,
-#elif defined(CONFIG_NFS_V4)
-       NULL,
-#endif
-#if defined(CONFIG_NFS_V4)
-       &nfs_version4,
-#endif
-};
-
-static struct rpc_program      nfs_program = {
-       .name                   = "nfs",
-       .number                 = NFS_PROGRAM,
-       .nrvers                 = ARRAY_SIZE(nfs_version),
-       .version                = nfs_version,
-       .stats                  = &nfs_rpcstat,
-       .pipe_dir_name          = "/nfs",
-};
-
-#ifdef CONFIG_NFS_V3_ACL
-static struct rpc_stat         nfsacl_rpcstat = { &nfsacl_program };
-static struct rpc_version *    nfsacl_version[] = {
-       [3]                     = &nfsacl_version3,
-};
-
-struct rpc_program             nfsacl_program = {
-       .name =                 "nfsacl",
-       .number =               NFS_ACL_PROGRAM,
-       .nrvers =               ARRAY_SIZE(nfsacl_version),
-       .version =              nfsacl_version,
-       .stats =                &nfsacl_rpcstat,
-};
-#endif  /* CONFIG_NFS_V3_ACL */
+static kmem_cache_t * nfs_inode_cachep;
 
 static inline unsigned long
 nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
@@ -134,8 +64,7 @@ nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
        return nfs_fileid_to_ino_t(fattr->fileid);
 }
 
-static int
-nfs_write_inode(struct inode *inode, int sync)
+int nfs_write_inode(struct inode *inode, int sync)
 {
        int flags = sync ? FLUSH_SYNC : 0;
        int ret;
@@ -146,8 +75,7 @@ nfs_write_inode(struct inode *inode, int sync)
        return 0;
 }
 
-static void
-nfs_clear_inode(struct inode *inode)
+void nfs_clear_inode(struct inode *inode)
 {
        struct nfs_inode *nfsi = NFS_I(inode);
        struct rpc_cred *cred;
@@ -164,566 +92,6 @@ nfs_clear_inode(struct inode *inode)
        BUG_ON(atomic_read(&nfsi->data_updates) != 0);
 }
 
-static void nfs_umount_begin(struct vfsmount *vfsmnt, int flags)
-{
-       struct nfs_server *server;
-       struct rpc_clnt *rpc;
-
-       shrink_submounts(vfsmnt, &nfs_automount_list);
-       if (!(flags & MNT_FORCE))
-               return;
-       /* -EIO all pending I/O */
-       server = NFS_SB(vfsmnt->mnt_sb);
-       rpc = server->client;
-       if (!IS_ERR(rpc))
-               rpc_killall_tasks(rpc);
-       rpc = server->client_acl;
-       if (!IS_ERR(rpc))
-               rpc_killall_tasks(rpc);
-}
-
-
-static inline unsigned long
-nfs_block_bits(unsigned long bsize, unsigned char *nrbitsp)
-{
-       /* make sure blocksize is a power of two */
-       if ((bsize & (bsize - 1)) || nrbitsp) {
-               unsigned char   nrbits;
-
-               for (nrbits = 31; nrbits && !(bsize & (1 << nrbits)); nrbits--)
-                       ;
-               bsize = 1 << nrbits;
-               if (nrbitsp)
-                       *nrbitsp = nrbits;
-       }
-
-       return bsize;
-}
-
-/*
- * Calculate the number of 512byte blocks used.
- */
-static inline unsigned long
-nfs_calc_block_size(u64 tsize)
-{
-       loff_t used = (tsize + 511) >> 9;
-       return (used > ULONG_MAX) ? ULONG_MAX : used;
-}
-
-/*
- * Compute and set NFS server blocksize
- */
-static inline unsigned long
-nfs_block_size(unsigned long bsize, unsigned char *nrbitsp)
-{
-       if (bsize < NFS_MIN_FILE_IO_SIZE)
-               bsize = NFS_DEF_FILE_IO_SIZE;
-       else if (bsize >= NFS_MAX_FILE_IO_SIZE)
-               bsize = NFS_MAX_FILE_IO_SIZE;
-
-       return nfs_block_bits(bsize, nrbitsp);
-}
-
-static inline void
-nfs_super_set_maxbytes(struct super_block *sb, __u64 maxfilesize)
-{
-       sb->s_maxbytes = (loff_t)maxfilesize;
-       if (sb->s_maxbytes > MAX_LFS_FILESIZE || sb->s_maxbytes <= 0)
-               sb->s_maxbytes = MAX_LFS_FILESIZE;
-}
-
-/*
- * Obtain the root inode of the file system.
- */
-static struct inode *
-nfs_get_root(struct super_block *sb, struct nfs_fh *rootfh, struct nfs_fsinfo *fsinfo)
-{
-       struct nfs_server       *server = NFS_SB(sb);
-       int                     error;
-
-       error = server->rpc_ops->getroot(server, rootfh, fsinfo);
-       if (error < 0) {
-               dprintk("nfs_get_root: getattr error = %d\n", -error);
-               return ERR_PTR(error);
-       }
-
-       server->fsid = fsinfo->fattr->fsid;
-       return nfs_fhget(sb, rootfh, fsinfo->fattr);
-}
-
-/*
- * Do NFS version-independent mount processing, and sanity checking
- */
-static int
-nfs_sb_init(struct super_block *sb, rpc_authflavor_t authflavor)
-{
-       struct nfs_server       *server;
-       struct inode            *root_inode;
-       struct nfs_fattr        fattr;
-       struct nfs_fsinfo       fsinfo = {
-                                       .fattr = &fattr,
-                               };
-       struct nfs_pathconf pathinfo = {
-                       .fattr = &fattr,
-       };
-       int no_root_error = 0;
-       unsigned long max_rpc_payload;
-
-       /* We probably want something more informative here */
-       snprintf(sb->s_id, sizeof(sb->s_id), "%x:%x", MAJOR(sb->s_dev), MINOR(sb->s_dev));
-
-       server = NFS_SB(sb);
-
-       sb->s_magic      = NFS_SUPER_MAGIC;
-
-       server->io_stats = nfs_alloc_iostats();
-       if (server->io_stats == NULL)
-               return -ENOMEM;
-
-       root_inode = nfs_get_root(sb, &server->fh, &fsinfo);
-       /* Did getting the root inode fail? */
-       if (IS_ERR(root_inode)) {
-               no_root_error = PTR_ERR(root_inode);
-               goto out_no_root;
-       }
-       sb->s_root = d_alloc_root(root_inode);
-       if (!sb->s_root) {
-               no_root_error = -ENOMEM;
-               goto out_no_root;
-       }
-       sb->s_root->d_op = server->rpc_ops->dentry_ops;
-
-       /* mount time stamp, in seconds */
-       server->mount_time = jiffies;
-
-       /* Get some general file system info */
-       if (server->namelen == 0 &&
-           server->rpc_ops->pathconf(server, &server->fh, &pathinfo) >= 0)
-               server->namelen = pathinfo.max_namelen;
-       /* Work out a lot of parameters */
-       if (server->rsize == 0)
-               server->rsize = nfs_block_size(fsinfo.rtpref, NULL);
-       if (server->wsize == 0)
-               server->wsize = nfs_block_size(fsinfo.wtpref, NULL);
-
-       if (fsinfo.rtmax >= 512 && server->rsize > fsinfo.rtmax)
-               server->rsize = nfs_block_size(fsinfo.rtmax, NULL);
-       if (fsinfo.wtmax >= 512 && server->wsize > fsinfo.wtmax)
-               server->wsize = nfs_block_size(fsinfo.wtmax, NULL);
-
-       max_rpc_payload = nfs_block_size(rpc_max_payload(server->client), NULL);
-       if (server->rsize > max_rpc_payload)
-               server->rsize = max_rpc_payload;
-       if (server->rsize > NFS_MAX_FILE_IO_SIZE)
-               server->rsize = NFS_MAX_FILE_IO_SIZE;
-       server->rpages = (server->rsize + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
-
-       if (server->wsize > max_rpc_payload)
-               server->wsize = max_rpc_payload;
-       if (server->wsize > NFS_MAX_FILE_IO_SIZE)
-               server->wsize = NFS_MAX_FILE_IO_SIZE;
-       server->wpages = (server->wsize + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
-
-       if (sb->s_blocksize == 0)
-               sb->s_blocksize = nfs_block_bits(server->wsize,
-                                                        &sb->s_blocksize_bits);
-       server->wtmult = nfs_block_bits(fsinfo.wtmult, NULL);
-
-       server->dtsize = nfs_block_size(fsinfo.dtpref, NULL);
-       if (server->dtsize > PAGE_CACHE_SIZE)
-               server->dtsize = PAGE_CACHE_SIZE;
-       if (server->dtsize > server->rsize)
-               server->dtsize = server->rsize;
-
-       if (server->flags & NFS_MOUNT_NOAC) {
-               server->acregmin = server->acregmax = 0;
-               server->acdirmin = server->acdirmax = 0;
-               sb->s_flags |= MS_SYNCHRONOUS;
-       }
-       server->backing_dev_info.ra_pages = server->rpages * NFS_MAX_READAHEAD;
-
-       nfs_super_set_maxbytes(sb, fsinfo.maxfilesize);
-
-       server->client->cl_intr = (server->flags & NFS_MOUNT_INTR) ? 1 : 0;
-       server->client->cl_softrtry = (server->flags & NFS_MOUNT_SOFT) ? 1 : 0;
-
-       /* We're airborne Set socket buffersize */
-       rpc_setbufsize(server->client, server->wsize + 100, server->rsize + 100);
-       return 0;
-       /* Yargs. It didn't work out. */
-out_no_root:
-       dprintk("nfs_sb_init: get root inode failed: errno %d\n", -no_root_error);
-       if (!IS_ERR(root_inode))
-               iput(root_inode);
-       return no_root_error;
-}
-
-static void nfs_init_timeout_values(struct rpc_timeout *to, int proto, unsigned int timeo, unsigned int retrans)
-{
-       to->to_initval = timeo * HZ / 10;
-       to->to_retries = retrans;
-       if (!to->to_retries)
-               to->to_retries = 2;
-
-       switch (proto) {
-       case IPPROTO_TCP:
-               if (!to->to_initval)
-                       to->to_initval = 60 * HZ;
-               if (to->to_initval > NFS_MAX_TCP_TIMEOUT)
-                       to->to_initval = NFS_MAX_TCP_TIMEOUT;
-               to->to_increment = to->to_initval;
-               to->to_maxval = to->to_initval + (to->to_increment * to->to_retries);
-               to->to_exponential = 0;
-               break;
-       case IPPROTO_UDP:
-       default:
-               if (!to->to_initval)
-                       to->to_initval = 11 * HZ / 10;
-               if (to->to_initval > NFS_MAX_UDP_TIMEOUT)
-                       to->to_initval = NFS_MAX_UDP_TIMEOUT;
-               to->to_maxval = NFS_MAX_UDP_TIMEOUT;
-               to->to_exponential = 1;
-               break;
-       }
-}
-
-/*
- * Create an RPC client handle.
- */
-static struct rpc_clnt *
-nfs_create_client(struct nfs_server *server, const struct nfs_mount_data *data)
-{
-       struct rpc_timeout      timeparms;
-       struct rpc_xprt         *xprt = NULL;
-       struct rpc_clnt         *clnt = NULL;
-       int                     proto = (data->flags & NFS_MOUNT_TCP) ? IPPROTO_TCP : IPPROTO_UDP;
-
-       nfs_init_timeout_values(&timeparms, proto, data->timeo, data->retrans);
-
-       server->retrans_timeo = timeparms.to_initval;
-       server->retrans_count = timeparms.to_retries;
-
-       /* create transport and client */
-       xprt = xprt_create_proto(proto, &server->addr, &timeparms);
-       if (IS_ERR(xprt)) {
-               dprintk("%s: cannot create RPC transport. Error = %ld\n",
-                               __FUNCTION__, PTR_ERR(xprt));
-               return (struct rpc_clnt *)xprt;
-       }
-       clnt = rpc_create_client(xprt, server->hostname, &nfs_program,
-                                server->rpc_ops->version, data->pseudoflavor);
-       if (IS_ERR(clnt)) {
-               dprintk("%s: cannot create RPC client. Error = %ld\n",
-                               __FUNCTION__, PTR_ERR(xprt));
-               goto out_fail;
-       }
-
-       clnt->cl_intr     = 1;
-       clnt->cl_softrtry = 1;
-
-       return clnt;
-
-out_fail:
-       return clnt;
-}
-
-/*
- * The way this works is that the mount process passes a structure
- * in the data argument which contains the server's IP address
- * and the root file handle obtained from the server's mount
- * daemon. We stash these away in the private superblock fields.
- */
-static int
-nfs_fill_super(struct super_block *sb, struct nfs_mount_data *data, int silent)
-{
-       struct nfs_server       *server;
-       rpc_authflavor_t        authflavor;
-
-       server           = NFS_SB(sb);
-       sb->s_blocksize_bits = 0;
-       sb->s_blocksize = 0;
-       if (data->bsize)
-               sb->s_blocksize = nfs_block_size(data->bsize, &sb->s_blocksize_bits);
-       if (data->rsize)
-               server->rsize = nfs_block_size(data->rsize, NULL);
-       if (data->wsize)
-               server->wsize = nfs_block_size(data->wsize, NULL);
-       server->flags    = data->flags & NFS_MOUNT_FLAGMASK;
-
-       server->acregmin = data->acregmin*HZ;
-       server->acregmax = data->acregmax*HZ;
-       server->acdirmin = data->acdirmin*HZ;
-       server->acdirmax = data->acdirmax*HZ;
-
-       /* Start lockd here, before we might error out */
-       if (!(server->flags & NFS_MOUNT_NONLM))
-               lockd_up();
-
-       server->namelen  = data->namlen;
-       server->hostname = kmalloc(strlen(data->hostname) + 1, GFP_KERNEL);
-       if (!server->hostname)
-               return -ENOMEM;
-       strcpy(server->hostname, data->hostname);
-
-       /* Check NFS protocol revision and initialize RPC op vector
-        * and file handle pool. */
-#ifdef CONFIG_NFS_V3
-       if (server->flags & NFS_MOUNT_VER3) {
-               server->rpc_ops = &nfs_v3_clientops;
-               server->caps |= NFS_CAP_READDIRPLUS;
-       } else {
-               server->rpc_ops = &nfs_v2_clientops;
-       }
-#else
-       server->rpc_ops = &nfs_v2_clientops;
-#endif
-
-       /* Fill in pseudoflavor for mount version < 5 */
-       if (!(data->flags & NFS_MOUNT_SECFLAVOUR))
-               data->pseudoflavor = RPC_AUTH_UNIX;
-       authflavor = data->pseudoflavor;        /* save for sb_init() */
-       /* XXX maybe we want to add a server->pseudoflavor field */
-
-       /* Create RPC client handles */
-       server->client = nfs_create_client(server, data);
-       if (IS_ERR(server->client))
-               return PTR_ERR(server->client);
-       /* RFC 2623, sec 2.3.2 */
-       if (authflavor != RPC_AUTH_UNIX) {
-               struct rpc_auth *auth;
-
-               server->client_sys = rpc_clone_client(server->client);
-               if (IS_ERR(server->client_sys))
-                       return PTR_ERR(server->client_sys);
-               auth = rpcauth_create(RPC_AUTH_UNIX, server->client_sys);
-               if (IS_ERR(auth))
-                       return PTR_ERR(auth);
-       } else {
-               atomic_inc(&server->client->cl_count);
-               server->client_sys = server->client;
-       }
-       if (server->flags & NFS_MOUNT_VER3) {
-#ifdef CONFIG_NFS_V3_ACL
-               if (!(server->flags & NFS_MOUNT_NOACL)) {
-                       server->client_acl = rpc_bind_new_program(server->client, &nfsacl_program, 3);
-                       /* No errors! Assume that Sun nfsacls are supported */
-                       if (!IS_ERR(server->client_acl))
-                               server->caps |= NFS_CAP_ACLS;
-               }
-#else
-               server->flags &= ~NFS_MOUNT_NOACL;
-#endif /* CONFIG_NFS_V3_ACL */
-               /*
-                * The VFS shouldn't apply the umask to mode bits. We will
-                * do so ourselves when necessary.
-                */
-               sb->s_flags |= MS_POSIXACL;
-               if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)
-                       server->namelen = NFS3_MAXNAMLEN;
-               sb->s_time_gran = 1;
-       } else {
-               if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)
-                       server->namelen = NFS2_MAXNAMLEN;
-       }
-
-       sb->s_op = &nfs_sops;
-       return nfs_sb_init(sb, authflavor);
-}
-
-static int
-nfs_statfs(struct super_block *sb, struct kstatfs *buf)
-{
-       struct nfs_server *server = NFS_SB(sb);
-       unsigned char blockbits;
-       unsigned long blockres;
-       struct nfs_fh *rootfh = NFS_FH(sb->s_root->d_inode);
-       struct nfs_fattr fattr;
-       struct nfs_fsstat res = {
-                       .fattr = &fattr,
-       };
-       int error;
-
-       lock_kernel();
-
-       error = server->rpc_ops->statfs(server, rootfh, &res);
-       buf->f_type = NFS_SUPER_MAGIC;
-       if (error < 0)
-               goto out_err;
-
-       /*
-        * Current versions of glibc do not correctly handle the
-        * case where f_frsize != f_bsize.  Eventually we want to
-        * report the value of wtmult in this field.
-        */
-       buf->f_frsize = sb->s_blocksize;
-
-       /*
-        * On most *nix systems, f_blocks, f_bfree, and f_bavail
-        * are reported in units of f_frsize.  Linux hasn't had
-        * an f_frsize field in its statfs struct until recently,
-        * thus historically Linux's sys_statfs reports these
-        * fields in units of f_bsize.
-        */
-       buf->f_bsize = sb->s_blocksize;
-       blockbits = sb->s_blocksize_bits;
-       blockres = (1 << blockbits) - 1;
-       buf->f_blocks = (res.tbytes + blockres) >> blockbits;
-       buf->f_bfree = (res.fbytes + blockres) >> blockbits;
-       buf->f_bavail = (res.abytes + blockres) >> blockbits;
-
-       buf->f_files = res.tfiles;
-       buf->f_ffree = res.afiles;
-
-       buf->f_namelen = server->namelen;
- out:
-       unlock_kernel();
-       return 0;
-
- out_err:
-       dprintk("%s: statfs error = %d\n", __FUNCTION__, -error);
-       buf->f_bsize = buf->f_blocks = buf->f_bfree = buf->f_bavail = -1;
-       goto out;
-
-}
-
-static void nfs_show_mount_options(struct seq_file *m, struct nfs_server *nfss, int showdefaults)
-{
-       static struct proc_nfs_info {
-               int flag;
-               char *str;
-               char *nostr;
-       } nfs_info[] = {
-               { NFS_MOUNT_SOFT, ",soft", ",hard" },
-               { NFS_MOUNT_INTR, ",intr", "" },
-               { NFS_MOUNT_NOCTO, ",nocto", "" },
-               { NFS_MOUNT_NOAC, ",noac", "" },
-               { NFS_MOUNT_NONLM, ",nolock", "" },
-               { NFS_MOUNT_NOACL, ",noacl", "" },
-               { 0, NULL, NULL }
-       };
-       struct proc_nfs_info *nfs_infop;
-       char buf[12];
-       char *proto;
-
-       seq_printf(m, ",vers=%d", nfss->rpc_ops->version);
-       seq_printf(m, ",rsize=%d", nfss->rsize);
-       seq_printf(m, ",wsize=%d", nfss->wsize);
-       if (nfss->acregmin != 3*HZ || showdefaults)
-               seq_printf(m, ",acregmin=%d", nfss->acregmin/HZ);
-       if (nfss->acregmax != 60*HZ || showdefaults)
-               seq_printf(m, ",acregmax=%d", nfss->acregmax/HZ);
-       if (nfss->acdirmin != 30*HZ || showdefaults)
-               seq_printf(m, ",acdirmin=%d", nfss->acdirmin/HZ);
-       if (nfss->acdirmax != 60*HZ || showdefaults)
-               seq_printf(m, ",acdirmax=%d", nfss->acdirmax/HZ);
-       for (nfs_infop = nfs_info; nfs_infop->flag; nfs_infop++) {
-               if (nfss->flags & nfs_infop->flag)
-                       seq_puts(m, nfs_infop->str);
-               else
-                       seq_puts(m, nfs_infop->nostr);
-       }
-       switch (nfss->client->cl_xprt->prot) {
-               case IPPROTO_TCP:
-                       proto = "tcp";
-                       break;
-               case IPPROTO_UDP:
-                       proto = "udp";
-                       break;
-               default:
-                       snprintf(buf, sizeof(buf), "%u", nfss->client->cl_xprt->prot);
-                       proto = buf;
-       }
-       seq_printf(m, ",proto=%s", proto);
-       seq_printf(m, ",timeo=%lu", 10U * nfss->retrans_timeo / HZ);
-       seq_printf(m, ",retrans=%u", nfss->retrans_count);
-}
-
-static int nfs_show_options(struct seq_file *m, struct vfsmount *mnt)
-{
-       struct nfs_server *nfss = NFS_SB(mnt->mnt_sb);
-
-       nfs_show_mount_options(m, nfss, 0);
-
-       seq_puts(m, ",addr=");
-       seq_escape(m, nfss->hostname, " \t\n\\");
-
-       return 0;
-}
-
-static int nfs_show_stats(struct seq_file *m, struct vfsmount *mnt)
-{
-       int i, cpu;
-       struct nfs_server *nfss = NFS_SB(mnt->mnt_sb);
-       struct rpc_auth *auth = nfss->client->cl_auth;
-       struct nfs_iostats totals = { };
-
-       seq_printf(m, "statvers=%s", NFS_IOSTAT_VERS);
-
-       /*
-        * Display all mount option settings
-        */
-       seq_printf(m, "\n\topts:\t");
-       seq_puts(m, mnt->mnt_sb->s_flags & MS_RDONLY ? "ro" : "rw");
-       seq_puts(m, mnt->mnt_sb->s_flags & MS_SYNCHRONOUS ? ",sync" : "");
-       seq_puts(m, mnt->mnt_sb->s_flags & MS_NOATIME ? ",noatime" : "");
-       seq_puts(m, mnt->mnt_sb->s_flags & MS_NODIRATIME ? ",nodiratime" : "");
-       nfs_show_mount_options(m, nfss, 1);
-
-       seq_printf(m, "\n\tage:\t%lu", (jiffies - nfss->mount_time) / HZ);
-
-       seq_printf(m, "\n\tcaps:\t");
-       seq_printf(m, "caps=0x%x", nfss->caps);
-       seq_printf(m, ",wtmult=%d", nfss->wtmult);
-       seq_printf(m, ",dtsize=%d", nfss->dtsize);
-       seq_printf(m, ",bsize=%d", nfss->bsize);
-       seq_printf(m, ",namelen=%d", nfss->namelen);
-
-#ifdef CONFIG_NFS_V4
-       if (nfss->rpc_ops->version == 4) {
-               seq_printf(m, "\n\tnfsv4:\t");
-               seq_printf(m, "bm0=0x%x", nfss->attr_bitmask[0]);
-               seq_printf(m, ",bm1=0x%x", nfss->attr_bitmask[1]);
-               seq_printf(m, ",acl=0x%x", nfss->acl_bitmask);
-       }
-#endif
-
-       /*
-        * Display security flavor in effect for this mount
-        */
-       seq_printf(m, "\n\tsec:\tflavor=%d", auth->au_ops->au_flavor);
-       if (auth->au_flavor)
-               seq_printf(m, ",pseudoflavor=%d", auth->au_flavor);
-
-       /*
-        * Display superblock I/O counters
-        */
-       for_each_possible_cpu(cpu) {
-               struct nfs_iostats *stats;
-
-               preempt_disable();
-               stats = per_cpu_ptr(nfss->io_stats, cpu);
-
-               for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
-                       totals.events[i] += stats->events[i];
-               for (i = 0; i < __NFSIOS_BYTESMAX; i++)
-                       totals.bytes[i] += stats->bytes[i];
-
-               preempt_enable();
-       }
-
-       seq_printf(m, "\n\tevents:\t");
-       for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
-               seq_printf(m, "%lu ", totals.events[i]);
-       seq_printf(m, "\n\tbytes:\t");
-       for (i = 0; i < __NFSIOS_BYTESMAX; i++)
-               seq_printf(m, "%Lu ", totals.bytes[i]);
-       seq_printf(m, "\n");
-
-       rpc_print_iostats(m, nfss->client);
-
-       return 0;
-}
-
 /**
  * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
  */
@@ -1663,371 +1031,15 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
        goto out_err;
 }
 
-/*
- * File system information
- */
-
-/*
- * nfs_path - reconstruct the path given an arbitrary dentry
- * @base - arbitrary string to prepend to the path
- * @dentry - pointer to dentry
- * @buffer - result buffer
- * @buflen - length of buffer
- *
- * Helper function for constructing the path from the
- * root dentry to an arbitrary hashed dentry.
- *
- * This is mainly for use in figuring out the path on the
- * server side when automounting on top of an existing partition.
- */
-static char *nfs_path(const char *base, const struct dentry *dentry,
-                     char *buffer, ssize_t buflen)
-{
-       char *end = buffer+buflen;
-       int namelen;
-
-       *--end = '\0';
-       buflen--;
-       spin_lock(&dcache_lock);
-       while (!IS_ROOT(dentry)) {
-               namelen = dentry->d_name.len;
-               buflen -= namelen + 1;
-               if (buflen < 0)
-                       goto Elong;
-               end -= namelen;
-               memcpy(end, dentry->d_name.name, namelen);
-               *--end = '/';
-               dentry = dentry->d_parent;
-       }
-       spin_unlock(&dcache_lock);
-       namelen = strlen(base);
-       /* Strip off excess slashes in base string */
-       while (namelen > 0 && base[namelen - 1] == '/')
-               namelen--;
-       buflen -= namelen;
-       if (buflen < 0)
-               goto Elong;
-       end -= namelen;
-       memcpy(end, base, namelen);
-       return end;
-Elong:
-       return ERR_PTR(-ENAMETOOLONG);
-}
-
-struct nfs_clone_mount {
-       const struct super_block *sb;
-       const struct dentry *dentry;
-       struct nfs_fh *fh;
-       struct nfs_fattr *fattr;
-       char *hostname;
-       char *mnt_path;
-       struct sockaddr_in *addr;
-       rpc_authflavor_t authflavor;
-};
-
-static struct super_block *nfs_clone_generic_sb(struct nfs_clone_mount *data,
-               struct super_block *(*fill_sb)(struct nfs_server *, struct nfs_clone_mount *),
-               struct nfs_server *(*fill_server)(struct super_block *, struct nfs_clone_mount *))
-{
-       struct nfs_server *server;
-       struct nfs_server *parent = NFS_SB(data->sb);
-       struct super_block *sb = ERR_PTR(-EINVAL);
-       void *err = ERR_PTR(-ENOMEM);
-       char *hostname;
-       int len;
-
-       server = kmalloc(sizeof(struct nfs_server), GFP_KERNEL);
-       if (server == NULL)
-               goto out_err;
-       memcpy(server, parent, sizeof(*server));
-       hostname = (data->hostname != NULL) ? data->hostname : parent->hostname;
-       len = strlen(hostname) + 1;
-       server->hostname = kmalloc(len, GFP_KERNEL);
-       if (server->hostname == NULL)
-               goto free_server;
-       memcpy(server->hostname, hostname, len);
-       if (rpciod_up() != 0)
-               goto free_hostname;
-
-       sb = fill_sb(server, data);
-       if (IS_ERR((err = sb)) || sb->s_root)
-               goto kill_rpciod;
-
-       server = fill_server(sb, data);
-       if (IS_ERR((err = server)))
-               goto out_deactivate;
-       return sb;
-out_deactivate:
-       up_write(&sb->s_umount);
-       deactivate_super(sb);
-       return (struct super_block *)err;
-kill_rpciod:
-       rpciod_down();
-free_hostname:
-       kfree(server->hostname);
-free_server:
-       kfree(server);
-out_err:
-       return (struct super_block *)err;
-}
-
-static int nfs_set_super(struct super_block *s, void *data)
-{
-       s->s_fs_info = data;
-       return set_anon_super(s, data);
-}
-static int nfs_compare_super(struct super_block *sb, void *data)
-{
-       struct nfs_server *server = data;
-       struct nfs_server *old = NFS_SB(sb);
-
-       if (old->addr.sin_addr.s_addr != server->addr.sin_addr.s_addr)
-               return 0;
-       if (old->addr.sin_port != server->addr.sin_port)
-               return 0;
-       return !nfs_compare_fh(&old->fh, &server->fh);
-}
-
-static struct super_block *nfs_get_sb(struct file_system_type *fs_type,
-       int flags, const char *dev_name, void *raw_data)
-{
-       int error;
-       struct nfs_server *server = NULL;
-       struct super_block *s;
-       struct nfs_fh *root;
-       struct nfs_mount_data *data = raw_data;
-
-       s = ERR_PTR(-EINVAL);
-       if (data == NULL) {
-               dprintk("%s: missing data argument\n", __FUNCTION__);
-               goto out_err;
-       }
-       if (data->version <= 0 || data->version > NFS_MOUNT_VERSION) {
-               dprintk("%s: bad mount version\n", __FUNCTION__);
-               goto out_err;
-       }
-       switch (data->version) {
-               case 1:
-                       data->namlen = 0;
-               case 2:
-                       data->bsize  = 0;
-               case 3:
-                       if (data->flags & NFS_MOUNT_VER3) {
-                               dprintk("%s: mount structure version %d does not support NFSv3\n",
-                                               __FUNCTION__,
-                                               data->version);
-                               goto out_err;
-                       }
-                       data->root.size = NFS2_FHSIZE;
-                       memcpy(data->root.data, data->old_root.data, NFS2_FHSIZE);
-               case 4:
-                       if (data->flags & NFS_MOUNT_SECFLAVOUR) {
-                               dprintk("%s: mount structure version %d does not support strong security\n",
-                                               __FUNCTION__,
-                                               data->version);
-                               goto out_err;
-                       }
-               case 5:
-                       memset(data->context, 0, sizeof(data->context));
-       }
-#ifndef CONFIG_NFS_V3
-       /* If NFSv3 is not compiled in, return -EPROTONOSUPPORT */
-       s = ERR_PTR(-EPROTONOSUPPORT);
-       if (data->flags & NFS_MOUNT_VER3) {
-               dprintk("%s: NFSv3 not compiled into kernel\n", __FUNCTION__);
-               goto out_err;
-       }
-#endif /* CONFIG_NFS_V3 */
-
-       s = ERR_PTR(-ENOMEM);
-       server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL);
-       if (!server)
-               goto out_err;
-       /* Zero out the NFS state stuff */
-       init_nfsv4_state(server);
-       server->client = server->client_sys = server->client_acl = ERR_PTR(-EINVAL);
-
-       root = &server->fh;
-       if (data->flags & NFS_MOUNT_VER3)
-               root->size = data->root.size;
-       else
-               root->size = NFS2_FHSIZE;
-       s = ERR_PTR(-EINVAL);
-       if (root->size > sizeof(root->data)) {
-               dprintk("%s: invalid root filehandle\n", __FUNCTION__);
-               goto out_err;
-       }
-       memcpy(root->data, data->root.data, root->size);
-
-       /* We now require that the mount process passes the remote address */
-       memcpy(&server->addr, &data->addr, sizeof(server->addr));
-       if (server->addr.sin_addr.s_addr == INADDR_ANY) {
-               dprintk("%s: mount program didn't pass remote address!\n",
-                               __FUNCTION__);
-               goto out_err;
-       }
-
-       /* Fire up rpciod if not yet running */
-       s = ERR_PTR(rpciod_up());
-       if (IS_ERR(s)) {
-               dprintk("%s: couldn't start rpciod! Error = %ld\n",
-                               __FUNCTION__, PTR_ERR(s));
-               goto out_err;
-       }
-
-       s = sget(fs_type, nfs_compare_super, nfs_set_super, server);
-       if (IS_ERR(s) || s->s_root)
-               goto out_rpciod_down;
-
-       s->s_flags = flags;
-
-       error = nfs_fill_super(s, data, flags & MS_SILENT ? 1 : 0);
-       if (error) {
-               up_write(&s->s_umount);
-               deactivate_super(s);
-               return ERR_PTR(error);
-       }
-       s->s_flags |= MS_ACTIVE;
-       return s;
-out_rpciod_down:
-       rpciod_down();
-out_err:
-       kfree(server);
-       return s;
-}
-
-static void nfs_kill_super(struct super_block *s)
-{
-       struct nfs_server *server = NFS_SB(s);
-
-       kill_anon_super(s);
-
-       if (!IS_ERR(server->client))
-               rpc_shutdown_client(server->client);
-       if (!IS_ERR(server->client_sys))
-               rpc_shutdown_client(server->client_sys);
-       if (!IS_ERR(server->client_acl))
-               rpc_shutdown_client(server->client_acl);
-
-       if (!(server->flags & NFS_MOUNT_NONLM))
-               lockd_down();   /* release rpc.lockd */
-
-       rpciod_down();          /* release rpciod */
-
-       nfs_free_iostats(server->io_stats);
-       kfree(server->hostname);
-       kfree(server);
-       nfs_release_automount_timer();
-}
-
-static struct file_system_type nfs_fs_type = {
-       .owner          = THIS_MODULE,
-       .name           = "nfs",
-       .get_sb         = nfs_get_sb,
-       .kill_sb        = nfs_kill_super,
-       .fs_flags       = FS_ODD_RENAME|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
-};
-
-static struct super_block *nfs_clone_sb(struct nfs_server *server, struct nfs_clone_mount *data)
-{
-       struct super_block *sb;
-
-       server->fsid = data->fattr->fsid;
-       nfs_copy_fh(&server->fh, data->fh);
-       sb = sget(&nfs_fs_type, nfs_compare_super, nfs_set_super, server);
-       if (!IS_ERR(sb) && sb->s_root == NULL && !(server->flags & NFS_MOUNT_NONLM))
-               lockd_up();
-       return sb;
-}
-
-static struct nfs_server *nfs_clone_server(struct super_block *sb, struct nfs_clone_mount *data)
-{
-       struct nfs_server *server = NFS_SB(sb);
-       struct nfs_server *parent = NFS_SB(data->sb);
-       struct inode *root_inode;
-       struct nfs_fsinfo fsinfo;
-       void *err = ERR_PTR(-ENOMEM);
-
-       sb->s_op = data->sb->s_op;
-       sb->s_blocksize = data->sb->s_blocksize;
-       sb->s_blocksize_bits = data->sb->s_blocksize_bits;
-       sb->s_maxbytes = data->sb->s_maxbytes;
-
-       server->client_sys = server->client_acl = ERR_PTR(-EINVAL);
-       server->io_stats = nfs_alloc_iostats();
-       if (server->io_stats == NULL)
-               goto out;
-
-       server->client = rpc_clone_client(parent->client);
-       if (IS_ERR((err = server->client)))
-               goto out;
-
-       if (!IS_ERR(parent->client_sys)) {
-               server->client_sys = rpc_clone_client(parent->client_sys);
-               if (IS_ERR((err = server->client_sys)))
-                       goto out;
-       }
-       if (!IS_ERR(parent->client_acl)) {
-               server->client_acl = rpc_clone_client(parent->client_acl);
-               if (IS_ERR((err = server->client_acl)))
-                       goto out;
-       }
-       root_inode = nfs_fhget(sb, data->fh, data->fattr);
-       if (!root_inode)
-               goto out;
-       sb->s_root = d_alloc_root(root_inode);
-       if (!sb->s_root)
-               goto out_put_root;
-       fsinfo.fattr = data->fattr;
-       if (NFS_PROTO(root_inode)->fsinfo(server, data->fh, &fsinfo) == 0)
-               nfs_super_set_maxbytes(sb, fsinfo.maxfilesize);
-       sb->s_root->d_op = server->rpc_ops->dentry_ops;
-       sb->s_flags |= MS_ACTIVE;
-       return server;
-out_put_root:
-       iput(root_inode);
-out:
-       return err;
-}
-
-static struct super_block *nfs_clone_nfs_sb(struct file_system_type *fs_type,
-               int flags, const char *dev_name, void *raw_data)
-{
-       struct nfs_clone_mount *data = raw_data;
-       return nfs_clone_generic_sb(data, nfs_clone_sb, nfs_clone_server);
-}
-
-static struct file_system_type clone_nfs_fs_type = {
-       .owner          = THIS_MODULE,
-       .name           = "nfs",
-       .get_sb         = nfs_clone_nfs_sb,
-       .kill_sb        = nfs_kill_super,
-       .fs_flags       = FS_ODD_RENAME|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
-};
 
 #ifdef CONFIG_NFS_V4
 
-static void nfs4_clear_inode(struct inode *);
-
-
-static struct super_operations nfs4_sops = { 
-       .alloc_inode    = nfs_alloc_inode,
-       .destroy_inode  = nfs_destroy_inode,
-       .write_inode    = nfs_write_inode,
-       .statfs         = nfs_statfs,
-       .clear_inode    = nfs4_clear_inode,
-       .umount_begin   = nfs_umount_begin,
-       .show_options   = nfs_show_options,
-       .show_stats     = nfs_show_stats,
-};
-
 /*
  * Clean out any remaining NFSv4 state that might be left over due
  * to open() calls that passed nfs_atomic_lookup, but failed to call
  * nfs_open().
  */
-static void nfs4_clear_inode(struct inode *inode)
+void nfs4_clear_inode(struct inode *inode)
 {
        struct nfs_inode *nfsi = NFS_I(inode);
 
@@ -2051,774 +1063,9 @@ static void nfs4_clear_inode(struct inode *inode)
                nfs4_close_state(state, state->state);
        }
 }
-
-
-static struct rpc_clnt *nfs4_create_client(struct nfs_server *server,
-       struct rpc_timeout *timeparms, int proto, rpc_authflavor_t flavor)
-{
-       struct nfs4_client *clp;
-       struct rpc_xprt *xprt = NULL;
-       struct rpc_clnt *clnt = NULL;
-       int err = -EIO;
-
-       clp = nfs4_get_client(&server->addr.sin_addr);
-       if (!clp) {
-               dprintk("%s: failed to create NFS4 client.\n", __FUNCTION__);
-               return ERR_PTR(err);
-       }
-
-       /* Now create transport and client */
-       down_write(&clp->cl_sem);
-       if (IS_ERR(clp->cl_rpcclient)) {
-               xprt = xprt_create_proto(proto, &server->addr, timeparms);
-               if (IS_ERR(xprt)) {
-                       up_write(&clp->cl_sem);
-                       err = PTR_ERR(xprt);
-                       dprintk("%s: cannot create RPC transport. Error = %d\n",
-                                       __FUNCTION__, err);
-                       goto out_fail;
-               }
-               /* Bind to a reserved port! */
-               xprt->resvport = 1;
-               clnt = rpc_create_client(xprt, server->hostname, &nfs_program,
-                               server->rpc_ops->version, flavor);
-               if (IS_ERR(clnt)) {
-                       up_write(&clp->cl_sem);
-                       err = PTR_ERR(clnt);
-                       dprintk("%s: cannot create RPC client. Error = %d\n",
-                                       __FUNCTION__, err);
-                       goto out_fail;
-               }
-               clnt->cl_intr     = 1;
-               clnt->cl_softrtry = 1;
-               clp->cl_rpcclient = clnt;
-               memcpy(clp->cl_ipaddr, server->ip_addr, sizeof(clp->cl_ipaddr));
-               nfs_idmap_new(clp);
-       }
-       list_add_tail(&server->nfs4_siblings, &clp->cl_superblocks);
-       clnt = rpc_clone_client(clp->cl_rpcclient);
-       if (!IS_ERR(clnt))
-               server->nfs4_state = clp;
-       up_write(&clp->cl_sem);
-       clp = NULL;
-
-       if (IS_ERR(clnt)) {
-               dprintk("%s: cannot create RPC client. Error = %d\n",
-                               __FUNCTION__, err);
-               return clnt;
-       }
-
-       if (server->nfs4_state->cl_idmap == NULL) {
-               dprintk("%s: failed to create idmapper.\n", __FUNCTION__);
-               return ERR_PTR(-ENOMEM);
-       }
-
-       if (clnt->cl_auth->au_flavor != flavor) {
-               struct rpc_auth *auth;
-
-               auth = rpcauth_create(flavor, clnt);
-               if (IS_ERR(auth)) {
-                       dprintk("%s: couldn't create credcache!\n", __FUNCTION__);
-                       return (struct rpc_clnt *)auth;
-               }
-       }
-       return clnt;
-
- out_fail:
-       if (clp)
-               nfs4_put_client(clp);
-       return ERR_PTR(err);
-}
-
-static int nfs4_fill_super(struct super_block *sb, struct nfs4_mount_data *data, int silent)
-{
-       struct nfs_server *server;
-       struct rpc_timeout timeparms;
-       rpc_authflavor_t authflavour;
-       int err = -EIO;
-
-       sb->s_blocksize_bits = 0;
-       sb->s_blocksize = 0;
-       server = NFS_SB(sb);
-       if (data->rsize != 0)
-               server->rsize = nfs_block_size(data->rsize, NULL);
-       if (data->wsize != 0)
-               server->wsize = nfs_block_size(data->wsize, NULL);
-       server->flags = data->flags & NFS_MOUNT_FLAGMASK;
-       server->caps = NFS_CAP_ATOMIC_OPEN;
-
-       server->acregmin = data->acregmin*HZ;
-       server->acregmax = data->acregmax*HZ;
-       server->acdirmin = data->acdirmin*HZ;
-       server->acdirmax = data->acdirmax*HZ;
-
-       server->rpc_ops = &nfs_v4_clientops;
-
-       nfs_init_timeout_values(&timeparms, data->proto, data->timeo, data->retrans);
-
-       server->retrans_timeo = timeparms.to_initval;
-       server->retrans_count = timeparms.to_retries;
-
-       /* Now create transport and client */
-       authflavour = RPC_AUTH_UNIX;
-       if (data->auth_flavourlen != 0) {
-               if (data->auth_flavourlen != 1) {
-                       dprintk("%s: Invalid number of RPC auth flavours %d.\n",
-                                       __FUNCTION__, data->auth_flavourlen);
-                       err = -EINVAL;
-                       goto out_fail;
-               }
-               if (copy_from_user(&authflavour, data->auth_flavours, sizeof(authflavour))) {
-                       err = -EFAULT;
-                       goto out_fail;
-               }
-       }
-
-       server->client = nfs4_create_client(server, &timeparms, data->proto, authflavour);
-       if (IS_ERR(server->client)) {
-               err = PTR_ERR(server->client);
-                       dprintk("%s: cannot create RPC client. Error = %d\n",
-                                       __FUNCTION__, err);
-                       goto out_fail;
-       }
-
-       sb->s_time_gran = 1;
-
-       sb->s_op = &nfs4_sops;
-       err = nfs_sb_init(sb, authflavour);
-
- out_fail:
-       return err;
-}
-
-static int nfs4_compare_super(struct super_block *sb, void *data)
-{
-       struct nfs_server *server = data;
-       struct nfs_server *old = NFS_SB(sb);
-
-       if (strcmp(server->hostname, old->hostname) != 0)
-               return 0;
-       if (strcmp(server->mnt_path, old->mnt_path) != 0)
-               return 0;
-       return 1;
-}
-
-static void *
-nfs_copy_user_string(char *dst, struct nfs_string *src, int maxlen)
-{
-       void *p = NULL;
-
-       if (!src->len)
-               return ERR_PTR(-EINVAL);
-       if (src->len < maxlen)
-               maxlen = src->len;
-       if (dst == NULL) {
-               p = dst = kmalloc(maxlen + 1, GFP_KERNEL);
-               if (p == NULL)
-                       return ERR_PTR(-ENOMEM);
-       }
-       if (copy_from_user(dst, src->data, maxlen)) {
-               kfree(p);
-               return ERR_PTR(-EFAULT);
-       }
-       dst[maxlen] = '\0';
-       return dst;
-}
-
-static struct super_block *nfs4_get_sb(struct file_system_type *fs_type,
-       int flags, const char *dev_name, void *raw_data)
-{
-       int error;
-       struct nfs_server *server;
-       struct super_block *s;
-       struct nfs4_mount_data *data = raw_data;
-       void *p;
-
-       if (data == NULL) {
-               dprintk("%s: missing data argument\n", __FUNCTION__);
-               return ERR_PTR(-EINVAL);
-       }
-       if (data->version <= 0 || data->version > NFS4_MOUNT_VERSION) {
-               dprintk("%s: bad mount version\n", __FUNCTION__);
-               return ERR_PTR(-EINVAL);
-       }
-
-       server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL);
-       if (!server)
-               return ERR_PTR(-ENOMEM);
-       /* Zero out the NFS state stuff */
-       init_nfsv4_state(server);
-       server->client = server->client_sys = server->client_acl = ERR_PTR(-EINVAL);
-
-       p = nfs_copy_user_string(NULL, &data->hostname, 256);
-       if (IS_ERR(p))
-               goto out_err;
-       server->hostname = p;
-
-       p = nfs_copy_user_string(NULL, &data->mnt_path, 1024);
-       if (IS_ERR(p))
-               goto out_err;
-       server->mnt_path = p;
-
-       p = nfs_copy_user_string(server->ip_addr, &data->client_addr,
-                       sizeof(server->ip_addr) - 1);
-       if (IS_ERR(p))
-               goto out_err;
-
-       /* We now require that the mount process passes the remote address */
-       if (data->host_addrlen != sizeof(server->addr)) {
-               s = ERR_PTR(-EINVAL);
-               goto out_free;
-       }
-       if (copy_from_user(&server->addr, data->host_addr, sizeof(server->addr))) {
-               s = ERR_PTR(-EFAULT);
-               goto out_free;
-       }
-       if (server->addr.sin_family != AF_INET ||
-           server->addr.sin_addr.s_addr == INADDR_ANY) {
-               dprintk("%s: mount program didn't pass remote IP address!\n",
-                               __FUNCTION__);
-               s = ERR_PTR(-EINVAL);
-               goto out_free;
-       }
-
-       /* Fire up rpciod if not yet running */
-       s = ERR_PTR(rpciod_up());
-       if (IS_ERR(s)) {
-               dprintk("%s: couldn't start rpciod! Error = %ld\n",
-                               __FUNCTION__, PTR_ERR(s));
-               goto out_free;
-       }
-
-       s = sget(fs_type, nfs4_compare_super, nfs_set_super, server);
-
-       if (IS_ERR(s) || s->s_root)
-               goto out_free;
-
-       s->s_flags = flags;
-
-       error = nfs4_fill_super(s, data, flags & MS_SILENT ? 1 : 0);
-       if (error) {
-               up_write(&s->s_umount);
-               deactivate_super(s);
-               return ERR_PTR(error);
-       }
-       s->s_flags |= MS_ACTIVE;
-       return s;
-out_err:
-       s = (struct super_block *)p;
-out_free:
-       kfree(server->mnt_path);
-       kfree(server->hostname);
-       kfree(server);
-       return s;
-}
-
-static void nfs4_kill_super(struct super_block *sb)
-{
-       struct nfs_server *server = NFS_SB(sb);
-
-       nfs_return_all_delegations(sb);
-       kill_anon_super(sb);
-
-       nfs4_renewd_prepare_shutdown(server);
-
-       if (server->client != NULL && !IS_ERR(server->client))
-               rpc_shutdown_client(server->client);
-
-       destroy_nfsv4_state(server);
-
-       rpciod_down();
-
-       nfs_free_iostats(server->io_stats);
-       kfree(server->hostname);
-       kfree(server);
-       nfs_release_automount_timer();
-}
-
-static struct file_system_type nfs4_fs_type = {
-       .owner          = THIS_MODULE,
-       .name           = "nfs4",
-       .get_sb         = nfs4_get_sb,
-       .kill_sb        = nfs4_kill_super,
-       .fs_flags       = FS_ODD_RENAME|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
-};
-
-static const int nfs_set_port_min = 0;
-static const int nfs_set_port_max = 65535;
-static int param_set_port(const char *val, struct kernel_param *kp)
-{
-       char *endp;
-       int num = simple_strtol(val, &endp, 0);
-       if (endp == val || *endp || num < nfs_set_port_min || num > nfs_set_port_max)
-               return -EINVAL;
-       *((int *)kp->arg) = num;
-       return 0;
-}
-
-module_param_call(callback_tcpport, param_set_port, param_get_int,
-                &nfs_callback_set_tcpport, 0644);
-
-static int param_set_idmap_timeout(const char *val, struct kernel_param *kp)
-{
-       char *endp;
-       int num = simple_strtol(val, &endp, 0);
-       int jif = num * HZ;
-       if (endp == val || *endp || num < 0 || jif < num)
-               return -EINVAL;
-       *((int *)kp->arg) = jif;
-       return 0;
-}
-
-module_param_call(idmap_cache_timeout, param_set_idmap_timeout, param_get_int,
-                &nfs_idmap_cache_timeout, 0644);
-
-/* Constructs the SERVER-side path */
-static inline char *nfs4_path(const struct dentry *dentry, char *buffer, ssize_t buflen)
-{
-       return nfs_path(NFS_SB(dentry->d_sb)->mnt_path, dentry, buffer, buflen);
-}
-
-static inline char *nfs4_dup_path(const struct dentry *dentry)
-{
-       char *page = (char *) __get_free_page(GFP_USER);
-       char *path;
-
-       path = nfs4_path(dentry, page, PAGE_SIZE);
-       if (!IS_ERR(path)) {
-               int len = PAGE_SIZE + page - path;
-               char *tmp = path;
-
-               path = kmalloc(len, GFP_KERNEL);
-               if (path)
-                       memcpy(path, tmp, len);
-               else
-                       path = ERR_PTR(-ENOMEM);
-       }
-       free_page((unsigned long)page);
-       return path;
-}
-
-static struct super_block *nfs4_clone_sb(struct nfs_server *server, struct nfs_clone_mount *data)
-{
-       const struct dentry *dentry = data->dentry;
-       struct nfs4_client *clp = server->nfs4_state;
-       struct super_block *sb;
-
-       server->fsid = data->fattr->fsid;
-       nfs_copy_fh(&server->fh, data->fh);
-       server->mnt_path = nfs4_dup_path(dentry);
-       if (IS_ERR(server->mnt_path)) {
-               sb = (struct super_block *)server->mnt_path;
-               goto err;
-       }
-       sb = sget(&nfs4_fs_type, nfs4_compare_super, nfs_set_super, server);
-       if (IS_ERR(sb) || sb->s_root)
-               goto free_path;
-       nfs4_server_capabilities(server, &server->fh);
-
-       down_write(&clp->cl_sem);
-       atomic_inc(&clp->cl_count);
-       list_add_tail(&server->nfs4_siblings, &clp->cl_superblocks);
-       up_write(&clp->cl_sem);
-       return sb;
-free_path:
-       kfree(server->mnt_path);
-err:
-       server->mnt_path = NULL;
-       return sb;
-}
-
-static struct super_block *nfs_clone_nfs4_sb(struct file_system_type *fs_type,
-               int flags, const char *dev_name, void *raw_data)
-{
-       struct nfs_clone_mount *data = raw_data;
-       return nfs_clone_generic_sb(data, nfs4_clone_sb, nfs_clone_server);
-}
-
-static struct file_system_type clone_nfs4_fs_type = {
-       .owner          = THIS_MODULE,
-       .name           = "nfs4",
-       .get_sb         = nfs_clone_nfs4_sb,
-       .kill_sb        = nfs4_kill_super,
-       .fs_flags       = FS_ODD_RENAME|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
-};
-
-static struct vfsmount *nfs_do_clone_mount(struct nfs_server *server, char *devname, struct nfs_clone_mount *mountdata)
-{
-       struct vfsmount *mnt = NULL;
-       switch (server->rpc_ops->version) {
-               case 2:
-               case 3:
-                       mnt = vfs_kern_mount(&clone_nfs_fs_type, 0, devname, mountdata);
-                       break;
-               case 4:
-                       mnt = vfs_kern_mount(&clone_nfs4_fs_type, 0, devname, mountdata);
-       }
-       return mnt;
-}
-
-#define nfs4_init_once(nfsi) \
-       do { \
-               INIT_LIST_HEAD(&(nfsi)->open_states); \
-               nfsi->delegation = NULL; \
-               nfsi->delegation_state = 0; \
-               init_rwsem(&nfsi->rwsem); \
-       } while(0)
-
-static inline int register_nfs4fs(void)
-{
-       int ret;
-
-       ret = nfs_register_sysctl();
-       if (ret != 0)
-               return ret;
-       ret = register_filesystem(&nfs4_fs_type);
-       if (ret != 0)
-               nfs_unregister_sysctl();
-       return ret;
-}
-
-static inline void unregister_nfs4fs(void)
-{
-       unregister_filesystem(&nfs4_fs_type);
-       nfs_unregister_sysctl();
-}
-#else
-#define nfs4_fill_sb(a,b)      ERR_PTR(-EINVAL)
-#define nfs4_fill_super(a,b)   ERR_PTR(-EINVAL)
-#define nfs4_init_once(nfsi) \
-       do { } while (0)
-#define register_nfs4fs() (0)
-#define unregister_nfs4fs()
-static struct vfsmount *nfs_do_clone_mount(struct nfs_server *server, char *devname, struct nfs_clone_mount *mountdata)
-{
-       return vfs_kern_mount(&clone_nfs_fs_type, 0, devname, mountdata);
-}
 #endif
 
-static inline char *nfs_devname(const struct vfsmount *mnt_parent,
-                        const struct dentry *dentry,
-                        char *buffer, ssize_t buflen)
-{
-       return nfs_path(mnt_parent->mnt_devname, dentry, buffer, buflen);
-}
-
-/**
- * nfs_do_submount - set up mountpoint when crossing a filesystem boundary
- * @mnt_parent - mountpoint of parent directory
- * @dentry - parent directory
- * @fh - filehandle for new root dentry
- * @fattr - attributes for new root inode
- *
- */
-struct vfsmount *nfs_do_submount(const struct vfsmount *mnt_parent,
-               const struct dentry *dentry, struct nfs_fh *fh,
-               struct nfs_fattr *fattr)
-{
-       struct nfs_clone_mount mountdata = {
-               .sb = mnt_parent->mnt_sb,
-               .dentry = dentry,
-               .fh = fh,
-               .fattr = fattr,
-       };
-       struct vfsmount *mnt = ERR_PTR(-ENOMEM);
-       char *page = (char *) __get_free_page(GFP_USER);
-       char *devname;
-
-       dprintk("%s: submounting on %s/%s\n", __FUNCTION__,
-                       dentry->d_parent->d_name.name,
-                       dentry->d_name.name);
-       if (page == NULL)
-               goto out;
-       devname = nfs_devname(mnt_parent, dentry, page, PAGE_SIZE);
-       mnt = (struct vfsmount *)devname;
-       if (IS_ERR(devname))
-               goto free_page;
-       mnt = nfs_do_clone_mount(NFS_SB(mnt_parent->mnt_sb), devname, &mountdata);
-free_page:
-       free_page((unsigned long)page);
-out:
-       dprintk("%s: done\n", __FUNCTION__);
-       return mnt;
-}
-
-#ifdef CONFIG_NFS_V4
-/* Check if fs_root is valid */
-static inline char *nfs4_pathname_string(struct nfs4_pathname *pathname, char *buffer, ssize_t buflen)
-{
-       char *end = buffer + buflen;
-       int n;
-
-       *--end = '\0';
-       buflen--;
-
-       n = pathname->ncomponents;
-       while (--n >= 0) {
-               struct nfs4_string *component = &pathname->components[n];
-               buflen -= component->len + 1;
-               if (buflen < 0)
-                       goto Elong;
-               end -= component->len;
-               memcpy(end, component->data, component->len);
-               *--end = '/';
-       }
-       return end;
-Elong:
-       return ERR_PTR(-ENAMETOOLONG);
-}
-
-/* Check if the string represents a "valid" IPv4 address */
-static inline int valid_ipaddr4(const char *buf)
-{
-       int rc, count, in[4];
-
-       rc = sscanf(buf, "%d.%d.%d.%d", &in[0], &in[1], &in[2], &in[3]);
-       if (rc != 4)
-               return -EINVAL;
-       for (count = 0; count < 4; count++) {
-               if (in[count] > 255)
-                       return -EINVAL;
-       }
-       return 0;
-}
-
-static struct super_block *nfs4_referral_sb(struct nfs_server *server, struct nfs_clone_mount *data)
-{
-       struct super_block *sb = ERR_PTR(-ENOMEM);
-       int len;
-
-       len = strlen(data->mnt_path) + 1;
-       server->mnt_path = kmalloc(len, GFP_KERNEL);
-       if (server->mnt_path == NULL)
-               goto err;
-       memcpy(server->mnt_path, data->mnt_path, len);
-       memcpy(&server->addr, data->addr, sizeof(struct sockaddr_in));
-
-       sb = sget(&nfs4_fs_type, nfs4_compare_super, nfs_set_super, server);
-       if (IS_ERR(sb) || sb->s_root)
-               goto free_path;
-       return sb;
-free_path:
-       kfree(server->mnt_path);
-err:
-       server->mnt_path = NULL;
-       return sb;
-}
-
-static struct nfs_server *nfs4_referral_server(struct super_block *sb, struct nfs_clone_mount *data)
-{
-       struct nfs_server *server = NFS_SB(sb);
-       struct rpc_timeout timeparms;
-       int proto, timeo, retrans;
-       void *err;
-
-       proto = IPPROTO_TCP;
-       /* Since we are following a referral and there may be alternatives,
-          set the timeouts and retries to low values */
-       timeo = 2;
-       retrans = 1;
-       nfs_init_timeout_values(&timeparms, proto, timeo, retrans);
-
-       server->client = nfs4_create_client(server, &timeparms, proto, data->authflavor);
-       if (IS_ERR((err = server->client)))
-               goto out_err;
-
-       sb->s_time_gran = 1;
-       sb->s_op = &nfs4_sops;
-       err = ERR_PTR(nfs_sb_init(sb, data->authflavor));
-       if (!IS_ERR(err))
-               return server;
-out_err:
-       return (struct nfs_server *)err;
-}
-
-static struct super_block *nfs_referral_nfs4_sb(struct file_system_type *fs_type,
-               int flags, const char *dev_name, void *raw_data)
-{
-       struct nfs_clone_mount *data = raw_data;
-       return nfs_clone_generic_sb(data, nfs4_referral_sb, nfs4_referral_server);
-}
-
-static struct file_system_type nfs_referral_nfs4_fs_type = {
-       .owner          = THIS_MODULE,
-       .name           = "nfs4",
-       .get_sb         = nfs_referral_nfs4_sb,
-       .kill_sb        = nfs4_kill_super,
-       .fs_flags       = FS_ODD_RENAME|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
-};
-
-/**
- * nfs_follow_referral - set up mountpoint when hitting a referral on moved error
- * @mnt_parent - mountpoint of parent directory
- * @dentry - parent directory
- * @fspath - fs path returned in fs_locations
- * @mntpath - mount path to new server
- * @hostname - hostname of new server
- * @addr - host addr of new server
- *
- */
-struct vfsmount *nfs_follow_referral(const struct vfsmount *mnt_parent,
-            const struct dentry *dentry, struct nfs4_fs_locations *locations)
-{
-       struct vfsmount *mnt = ERR_PTR(-ENOENT);
-       struct nfs_clone_mount mountdata = {
-               .sb = mnt_parent->mnt_sb,
-               .dentry = dentry,
-               .authflavor = NFS_SB(mnt_parent->mnt_sb)->client->cl_auth->au_flavor,
-       };
-       char *page, *page2;
-       char *path, *fs_path;
-       char *devname;
-       int loc, s;
-
-       if (locations == NULL || locations->nlocations <= 0)
-               goto out;
-
-       dprintk("%s: referral at %s/%s\n", __FUNCTION__,
-               dentry->d_parent->d_name.name, dentry->d_name.name);
-
-       /* Ensure fs path is a prefix of current dentry path */
-       page = (char *) __get_free_page(GFP_USER);
-       if (page == NULL)
-               goto out;
-       page2 = (char *) __get_free_page(GFP_USER);
-       if (page2 == NULL)
-               goto out;
-
-       path = nfs4_path(dentry, page, PAGE_SIZE);
-       if (IS_ERR(path))
-               goto out_free;
-
-       fs_path = nfs4_pathname_string(&locations->fs_path, page2, PAGE_SIZE);
-       if (IS_ERR(fs_path))
-               goto out_free;
-
-       if (strncmp(path, fs_path, strlen(fs_path)) != 0) {
-               dprintk("%s: path %s does not begin with fsroot %s\n", __FUNCTION__, path, fs_path);
-               goto out_free;
-       }
-
-       devname = nfs_devname(mnt_parent, dentry, page, PAGE_SIZE);
-       if (IS_ERR(devname)) {
-               mnt = (struct vfsmount *)devname;
-               goto out_free;
-       }
-
-       loc = 0;
-       while (loc < locations->nlocations && IS_ERR(mnt)) {
-               struct nfs4_fs_location *location = &locations->locations[loc];
-               char *mnt_path;
-
-               if (location == NULL || location->nservers <= 0 ||
-                   location->rootpath.ncomponents == 0) {
-                       loc++;
-                       continue;
-               }
-
-               mnt_path = nfs4_pathname_string(&location->rootpath, page2, PAGE_SIZE);
-               if (IS_ERR(mnt_path)) {
-                       loc++;
-                       continue;
-               }
-               mountdata.mnt_path = mnt_path;
-
-               s = 0;
-               while (s < location->nservers) {
-                       struct sockaddr_in addr = {};
-
-                       if (location->servers[s].len <= 0 ||
-                           valid_ipaddr4(location->servers[s].data) < 0) {
-                               s++;
-                               continue;
-                       }
-
-                       mountdata.hostname = location->servers[s].data;
-                       addr.sin_addr.s_addr = in_aton(mountdata.hostname);
-                       addr.sin_family = AF_INET;
-                       addr.sin_port = htons(NFS_PORT);
-                       mountdata.addr = &addr;
-
-                       mnt = vfs_kern_mount(&nfs_referral_nfs4_fs_type, 0, devname, &mountdata);
-                       if (!IS_ERR(mnt)) {
-                               break;
-                       }
-                       s++;
-               }
-               loc++;
-       }
-
-out_free:
-       free_page((unsigned long)page);
-       free_page((unsigned long)page2);
-out:
-       dprintk("%s: done\n", __FUNCTION__);
-       return mnt;
-}
-
-/*
- * nfs_do_refmount - handle crossing a referral on server
- * @dentry - dentry of referral
- * @nd - nameidata info
- *
- */
-struct vfsmount *nfs_do_refmount(const struct vfsmount *mnt_parent, struct dentry *dentry)
-{
-       struct vfsmount *mnt = ERR_PTR(-ENOENT);
-       struct dentry *parent;
-       struct nfs4_fs_locations *fs_locations = NULL;
-       struct page *page;
-       int err;
-
-       /* BUG_ON(IS_ROOT(dentry)); */
-       dprintk("%s: enter\n", __FUNCTION__);
-
-       page = alloc_page(GFP_KERNEL);
-       if (page == NULL)
-               goto out;
-
-       fs_locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
-       if (fs_locations == NULL)
-               goto out_free;
-
-       /* Get locations */
-       parent = dget_parent(dentry);
-       dprintk("%s: getting locations for %s/%s\n", __FUNCTION__, parent->d_name.name, dentry->d_name.name);
-       err = nfs4_proc_fs_locations(parent->d_inode, dentry, fs_locations, page);
-       dput(parent);
-       if (err != 0 || fs_locations->nlocations <= 0 ||
-           fs_locations->fs_path.ncomponents <= 0)
-               goto out_free;
-
-       mnt = nfs_follow_referral(mnt_parent, dentry, fs_locations);
-out_free:
-       __free_page(page);
-       kfree(fs_locations);
-out:
-       dprintk("%s: done\n", __FUNCTION__);
-       return mnt;
-}
-#else
-struct vfsmount *nfs_do_refmount(const struct vfsmount *mnt_parent, struct dentry *dentry)
-{
-       return ERR_PTR(-ENOENT);
-}
-#endif
-
-extern int nfs_init_nfspagecache(void);
-extern void nfs_destroy_nfspagecache(void);
-extern int nfs_init_readpagecache(void);
-extern void nfs_destroy_readpagecache(void);
-extern int nfs_init_writepagecache(void);
-extern void nfs_destroy_writepagecache(void);
-#ifdef CONFIG_NFS_DIRECTIO
-extern int nfs_init_directcache(void);
-extern void nfs_destroy_directcache(void);
-#endif
-
-static kmem_cache_t * nfs_inode_cachep;
-
-static struct inode *nfs_alloc_inode(struct super_block *sb)
+struct inode *nfs_alloc_inode(struct super_block *sb)
 {
        struct nfs_inode *nfsi;
        nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, SLAB_KERNEL);
@@ -2837,11 +1084,19 @@ static struct inode *nfs_alloc_inode(struct super_block *sb)
        return &nfsi->vfs_inode;
 }
 
-static void nfs_destroy_inode(struct inode *inode)
+void nfs_destroy_inode(struct inode *inode)
 {
        kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
 }
 
+#define nfs4_init_once(nfsi) \
+       do { \
+               INIT_LIST_HEAD(&(nfsi)->open_states); \
+               nfsi->delegation = NULL; \
+               nfsi->delegation_state = 0; \
+               init_rwsem(&nfsi->rwsem); \
+       } while(0)
+
 static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
 {
        struct nfs_inode *nfsi = (struct nfs_inode *) foo;
@@ -2862,7 +1117,7 @@ static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
        }
 }
  
-static int nfs_init_inodecache(void)
+static int __init nfs_init_inodecache(void)
 {
        nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
                                             sizeof(struct nfs_inode),
@@ -2875,7 +1130,7 @@ static int nfs_init_inodecache(void)
        return 0;
 }
 
-static void nfs_destroy_inodecache(void)
+static void __exit nfs_destroy_inodecache(void)
 {
        if (kmem_cache_destroy(nfs_inode_cachep))
                printk(KERN_INFO "nfs_inode_cache: not all structures were freed\n");
@@ -2904,29 +1159,22 @@ static int __init init_nfs_fs(void)
        if (err)
                goto out1;
 
-#ifdef CONFIG_NFS_DIRECTIO
        err = nfs_init_directcache();
        if (err)
                goto out0;
-#endif
 
 #ifdef CONFIG_PROC_FS
        rpc_proc_register(&nfs_rpcstat);
 #endif
-        err = register_filesystem(&nfs_fs_type);
-       if (err)
-               goto out;
-       if ((err = register_nfs4fs()) != 0)
+       if ((err = register_nfs_fs()) != 0)
                goto out;
        return 0;
 out:
 #ifdef CONFIG_PROC_FS
        rpc_proc_unregister("nfs");
 #endif
-#ifdef CONFIG_NFS_DIRECTIO
        nfs_destroy_directcache();
 out0:
-#endif
        nfs_destroy_writepagecache();
 out1:
        nfs_destroy_readpagecache();
@@ -2940,9 +1188,7 @@ out4:
 
 static void __exit exit_nfs_fs(void)
 {
-#ifdef CONFIG_NFS_DIRECTIO
        nfs_destroy_directcache();
-#endif
        nfs_destroy_writepagecache();
        nfs_destroy_readpagecache();
        nfs_destroy_inodecache();
@@ -2950,8 +1196,7 @@ static void __exit exit_nfs_fs(void)
 #ifdef CONFIG_PROC_FS
        rpc_proc_unregister("nfs");
 #endif
-       unregister_filesystem(&nfs_fs_type);
-       unregister_nfs4fs();
+       unregister_nfs_fs();
 }
 
 /* Not quite true; I just maintain it */
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
new file mode 100644 (file)
index 0000000..5e51c45
--- /dev/null
@@ -0,0 +1,179 @@
+/*
+ * NFS internal definitions
+ */
+
+#include <linux/mount.h>
+
+struct nfs_clone_mount {
+       const struct super_block *sb;
+       const struct dentry *dentry;
+       struct nfs_fh *fh;
+       struct nfs_fattr *fattr;
+       char *hostname;
+       char *mnt_path;
+       struct sockaddr_in *addr;
+       rpc_authflavor_t authflavor;
+};
+
+/* namespace-nfs4.c */
+#ifdef CONFIG_NFS_V4
+extern struct vfsmount *nfs_do_refmount(const struct vfsmount *mnt_parent, struct dentry *dentry);
+#else
+static inline
+struct vfsmount *nfs_do_refmount(const struct vfsmount *mnt_parent, struct dentry *dentry)
+{
+       return ERR_PTR(-ENOENT);
+}
+#endif
+
+/* callback_xdr.c */
+extern struct svc_version nfs4_callback_version1;
+
+/* pagelist.c */
+extern int __init nfs_init_nfspagecache(void);
+extern void __exit nfs_destroy_nfspagecache(void);
+extern int __init nfs_init_readpagecache(void);
+extern void __exit nfs_destroy_readpagecache(void);
+extern int __init nfs_init_writepagecache(void);
+extern void __exit nfs_destroy_writepagecache(void);
+
+#ifdef CONFIG_NFS_DIRECTIO
+extern int __init nfs_init_directcache(void);
+extern void __exit nfs_destroy_directcache(void);
+#else
+#define nfs_init_directcache() (0)
+#define nfs_destroy_directcache() do {} while(0)
+#endif
+
+/* nfs2xdr.c */
+extern struct rpc_procinfo nfs_procedures[];
+extern u32 * nfs_decode_dirent(u32 *, struct nfs_entry *, int);
+
+/* nfs3xdr.c */
+extern struct rpc_procinfo nfs3_procedures[];
+extern u32 *nfs3_decode_dirent(u32 *, struct nfs_entry *, int);
+
+/* nfs4xdr.c */
+extern int nfs_stat_to_errno(int);
+extern u32 *nfs4_decode_dirent(u32 *p, struct nfs_entry *entry, int plus);
+
+/* nfs4proc.c */
+extern struct rpc_procinfo nfs4_procedures[];
+
+extern int nfs4_proc_fs_locations(struct inode *dir, struct dentry *dentry,
+                                 struct nfs4_fs_locations *fs_locations,
+                                 struct page *page);
+
+/* inode.c */
+extern struct inode *nfs_alloc_inode(struct super_block *sb);
+extern void nfs_destroy_inode(struct inode *);
+extern int nfs_write_inode(struct inode *,int);
+extern void nfs_clear_inode(struct inode *);
+#ifdef CONFIG_NFS_V4
+extern void nfs4_clear_inode(struct inode *);
+#endif
+
+/* super.c */
+extern struct file_system_type nfs_referral_nfs4_fs_type;
+extern struct file_system_type clone_nfs_fs_type;
+#ifdef CONFIG_NFS_V4
+extern struct file_system_type clone_nfs4_fs_type;
+#endif
+#ifdef CONFIG_PROC_FS
+extern struct rpc_stat nfs_rpcstat;
+#endif
+extern int __init register_nfs_fs(void);
+extern void __exit unregister_nfs_fs(void);
+
+/* namespace.c */
+extern char *nfs_path(const char *base, const struct dentry *dentry,
+                     char *buffer, ssize_t buflen);
+
+/*
+ * Determine the mount path as a string
+ */
+static inline char *nfs4_path(const struct dentry *dentry, char *buffer, ssize_t buflen)
+{
+       return nfs_path(NFS_SB(dentry->d_sb)->mnt_path, dentry, buffer, buflen);
+}
+
+/*
+ * Determine the device name as a string
+ */
+static inline char *nfs_devname(const struct vfsmount *mnt_parent,
+                        const struct dentry *dentry,
+                        char *buffer, ssize_t buflen)
+{
+       return nfs_path(mnt_parent->mnt_devname, dentry, buffer, buflen);
+}
+
+/*
+ * Determine the actual block size (and log2 thereof)
+ */
+static inline
+unsigned long nfs_block_bits(unsigned long bsize, unsigned char *nrbitsp)
+{
+       /* make sure blocksize is a power of two */
+       if ((bsize & (bsize - 1)) || nrbitsp) {
+               unsigned char   nrbits;
+
+               for (nrbits = 31; nrbits && !(bsize & (1 << nrbits)); nrbits--)
+                       ;
+               bsize = 1 << nrbits;
+               if (nrbitsp)
+                       *nrbitsp = nrbits;
+       }
+
+       return bsize;
+}
+
+/*
+ * Calculate the number of 512byte blocks used.
+ */
+static inline unsigned long nfs_calc_block_size(u64 tsize)
+{
+       loff_t used = (tsize + 511) >> 9;
+       return (used > ULONG_MAX) ? ULONG_MAX : used;
+}
+
+/*
+ * Compute and set NFS server blocksize
+ */
+static inline
+unsigned long nfs_block_size(unsigned long bsize, unsigned char *nrbitsp)
+{
+       if (bsize < NFS_MIN_FILE_IO_SIZE)
+               bsize = NFS_DEF_FILE_IO_SIZE;
+       else if (bsize >= NFS_MAX_FILE_IO_SIZE)
+               bsize = NFS_MAX_FILE_IO_SIZE;
+
+       return nfs_block_bits(bsize, nrbitsp);
+}
+
+/*
+ * Determine the maximum file size for a superblock
+ */
+static inline
+void nfs_super_set_maxbytes(struct super_block *sb, __u64 maxfilesize)
+{
+       sb->s_maxbytes = (loff_t)maxfilesize;
+       if (sb->s_maxbytes > MAX_LFS_FILESIZE || sb->s_maxbytes <= 0)
+               sb->s_maxbytes = MAX_LFS_FILESIZE;
+}
+
+/*
+ * Check if the string represents a "valid" IPv4 address
+ */
+static inline int valid_ipaddr4(const char *buf)
+{
+       int rc, count, in[4];
+
+       rc = sscanf(buf, "%d.%d.%d.%d", &in[0], &in[1], &in[2], &in[3]);
+       if (rc != 4)
+               return -EINVAL;
+       for (count = 0; count < 4; count++) {
+               if (in[count] > 255)
+                       return -EINVAL;
+       }
+       return 0;
+}
index 8ca44b7..19b98ca 100644 (file)
 #include <linux/string.h>
 #include <linux/sunrpc/clnt.h>
 #include <linux/vfs.h>
+#include "internal.h"
 
 #define NFSDBG_FACILITY                NFSDBG_VFS
 
-LIST_HEAD(nfs_automount_list);
 static void nfs_expire_automounts(void *list);
+
+LIST_HEAD(nfs_automount_list);
 static DECLARE_WORK(nfs_automount_task, nfs_expire_automounts, &nfs_automount_list);
 int nfs_mountpoint_expiry_timeout = 500 * HZ;
 
 /*
+ * nfs_path - reconstruct the path given an arbitrary dentry
+ * @base - arbitrary string to prepend to the path
+ * @dentry - pointer to dentry
+ * @buffer - result buffer
+ * @buflen - length of buffer
+ *
+ * Helper function for constructing the path from the
+ * root dentry to an arbitrary hashed dentry.
+ *
+ * This is mainly for use in figuring out the path on the
+ * server side when automounting on top of an existing partition.
+ */
+char *nfs_path(const char *base, const struct dentry *dentry,
+              char *buffer, ssize_t buflen)
+{
+       char *end = buffer+buflen;
+       int namelen;
+
+       *--end = '\0';
+       buflen--;
+       spin_lock(&dcache_lock);
+       while (!IS_ROOT(dentry)) {
+               namelen = dentry->d_name.len;
+               buflen -= namelen + 1;
+               if (buflen < 0)
+                       goto Elong;
+               end -= namelen;
+               memcpy(end, dentry->d_name.name, namelen);
+               *--end = '/';
+               dentry = dentry->d_parent;
+       }
+       spin_unlock(&dcache_lock);
+       namelen = strlen(base);
+       /* Strip off excess slashes in base string */
+       while (namelen > 0 && base[namelen - 1] == '/')
+               namelen--;
+       buflen -= namelen;
+       if (buflen < 0)
+               goto Elong;
+       end -= namelen;
+       memcpy(end, base, namelen);
+       return end;
+Elong:
+       return ERR_PTR(-ENAMETOOLONG);
+}
+
+/*
  * nfs_follow_mountpoint - handle crossing a mountpoint on the server
  * @dentry - dentry of mountpoint
  * @nd - nameidata info
@@ -117,3 +166,64 @@ void nfs_release_automount_timer(void)
                flush_scheduled_work();
        }
 }
+
+/*
+ * Clone a mountpoint of the appropriate type
+ */
+static struct vfsmount *nfs_do_clone_mount(struct nfs_server *server, char *devname,
+                                          struct nfs_clone_mount *mountdata)
+{
+#ifdef CONFIG_NFS_V4
+       struct vfsmount *mnt = NULL;
+       switch (server->rpc_ops->version) {
+               case 2:
+               case 3:
+                       mnt = vfs_kern_mount(&clone_nfs_fs_type, 0, devname, mountdata);
+                       break;
+               case 4:
+                       mnt = vfs_kern_mount(&clone_nfs4_fs_type, 0, devname, mountdata);
+       }
+       return mnt;
+#else
+       return vfs_kern_mount(&clone_nfs_fs_type, 0, devname, mountdata);
+#endif
+}
+
+/**
+ * nfs_do_submount - set up mountpoint when crossing a filesystem boundary
+ * @mnt_parent - mountpoint of parent directory
+ * @dentry - parent directory
+ * @fh - filehandle for new root dentry
+ * @fattr - attributes for new root inode
+ *
+ */
+struct vfsmount *nfs_do_submount(const struct vfsmount *mnt_parent,
+               const struct dentry *dentry, struct nfs_fh *fh,
+               struct nfs_fattr *fattr)
+{
+       struct nfs_clone_mount mountdata = {
+               .sb = mnt_parent->mnt_sb,
+               .dentry = dentry,
+               .fh = fh,
+               .fattr = fattr,
+       };
+       struct vfsmount *mnt = ERR_PTR(-ENOMEM);
+       char *page = (char *) __get_free_page(GFP_USER);
+       char *devname;
+
+       dprintk("%s: submounting on %s/%s\n", __FUNCTION__,
+                       dentry->d_parent->d_name.name,
+                       dentry->d_name.name);
+       if (page == NULL)
+               goto out;
+       devname = nfs_devname(mnt_parent, dentry, page, PAGE_SIZE);
+       mnt = (struct vfsmount *)devname;
+       if (IS_ERR(devname))
+               goto free_page;
+       mnt = nfs_do_clone_mount(NFS_SB(mnt_parent->mnt_sb), devname, &mountdata);
+free_page:
+       free_page((unsigned long)page);
+out:
+       dprintk("%s: done\n", __FUNCTION__);
+       return mnt;
+}
index a7ed88f..4a006f8 100644 (file)
@@ -27,8 +27,6 @@
 #define NFSDBG_FACILITY                NFSDBG_XDR
 /* #define NFS_PARANOIA 1 */
 
-extern int                     nfs_stat_to_errno(int stat);
-
 /* Mapping from NFS error code to "errno" error code. */
 #define errno_NFSERR_IO                EIO
 
index cf186f0..7143b1f 100644 (file)
 #include <linux/nfs_mount.h>
 
 #include "iostat.h"
+#include "internal.h"
 
 #define NFSDBG_FACILITY                NFSDBG_PROC
 
-extern struct rpc_procinfo nfs3_procedures[];
-
 /* A wrapper to handle the EJUKEBOX error message */
 static int
 nfs3_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
@@ -809,8 +808,6 @@ nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
        return status;
 }
 
-extern u32 *nfs3_decode_dirent(u32 *, struct nfs_entry *, int);
-
 static int nfs3_read_done(struct rpc_task *task, struct nfs_read_data *data)
 {
        if (nfs3_async_handle_jukebox(task, data->inode))
index f70eee2..0250269 100644 (file)
 #include <linux/nfs3.h>
 #include <linux/nfs_fs.h>
 #include <linux/nfsacl.h>
+#include "internal.h"
 
 #define NFSDBG_FACILITY                NFSDBG_XDR
 
 /* Mapping from NFS error code to "errno" error code. */
 #define errno_NFSERR_IO                EIO
 
-extern int                     nfs_stat_to_errno(int);
-
 /*
  * Declare the space requirements for NFS arguments and replies as
  * number of 32bit-words
diff --git a/fs/nfs/nfs4namespace.c b/fs/nfs/nfs4namespace.c
new file mode 100644 (file)
index 0000000..ea38d27
--- /dev/null
@@ -0,0 +1,201 @@
+/*
+ * linux/fs/nfs/nfs4namespace.c
+ *
+ * Copyright (C) 2005 Trond Myklebust <Trond.Myklebust@netapp.com>
+ *
+ * NFSv4 namespace
+ */
+
+#include <linux/config.h>
+
+#include <linux/dcache.h>
+#include <linux/mount.h>
+#include <linux/namei.h>
+#include <linux/nfs_fs.h>
+#include <linux/string.h>
+#include <linux/sunrpc/clnt.h>
+#include <linux/vfs.h>
+#include <linux/inet.h>
+#include "internal.h"
+
+#define NFSDBG_FACILITY                NFSDBG_VFS
+
+/*
+ * Check if fs_root is valid
+ */
+static inline char *nfs4_pathname_string(struct nfs4_pathname *pathname,
+                                        char *buffer, ssize_t buflen)
+{
+       char *end = buffer + buflen;
+       int n;
+
+       *--end = '\0';
+       buflen--;
+
+       n = pathname->ncomponents;
+       while (--n >= 0) {
+               struct nfs4_string *component = &pathname->components[n];
+               buflen -= component->len + 1;
+               if (buflen < 0)
+                       goto Elong;
+               end -= component->len;
+               memcpy(end, component->data, component->len);
+               *--end = '/';
+       }
+       return end;
+Elong:
+       return ERR_PTR(-ENAMETOOLONG);
+}
+
+
+/**
+ * nfs_follow_referral - set up mountpoint when hitting a referral on moved error
+ * @mnt_parent - mountpoint of parent directory
+ * @dentry - parent directory
+ * @fspath - fs path returned in fs_locations
+ * @mntpath - mount path to new server
+ * @hostname - hostname of new server
+ * @addr - host addr of new server
+ *
+ */
+static struct vfsmount *nfs_follow_referral(const struct vfsmount *mnt_parent,
+                                           const struct dentry *dentry,
+                                           struct nfs4_fs_locations *locations)
+{
+       struct vfsmount *mnt = ERR_PTR(-ENOENT);
+       struct nfs_clone_mount mountdata = {
+               .sb = mnt_parent->mnt_sb,
+               .dentry = dentry,
+               .authflavor = NFS_SB(mnt_parent->mnt_sb)->client->cl_auth->au_flavor,
+       };
+       char *page, *page2;
+       char *path, *fs_path;
+       char *devname;
+       int loc, s;
+
+       if (locations == NULL || locations->nlocations <= 0)
+               goto out;
+
+       dprintk("%s: referral at %s/%s\n", __FUNCTION__,
+               dentry->d_parent->d_name.name, dentry->d_name.name);
+
+       /* Ensure fs path is a prefix of current dentry path */
+       page = (char *) __get_free_page(GFP_USER);
+       if (page == NULL)
+               goto out;
+       page2 = (char *) __get_free_page(GFP_USER);
+       if (page2 == NULL)
+               goto out;
+
+       path = nfs4_path(dentry, page, PAGE_SIZE);
+       if (IS_ERR(path))
+               goto out_free;
+
+       fs_path = nfs4_pathname_string(&locations->fs_path, page2, PAGE_SIZE);
+       if (IS_ERR(fs_path))
+               goto out_free;
+
+       if (strncmp(path, fs_path, strlen(fs_path)) != 0) {
+               dprintk("%s: path %s does not begin with fsroot %s\n", __FUNCTION__, path, fs_path);
+               goto out_free;
+       }
+
+       devname = nfs_devname(mnt_parent, dentry, page, PAGE_SIZE);
+       if (IS_ERR(devname)) {
+               mnt = (struct vfsmount *)devname;
+               goto out_free;
+       }
+
+       loc = 0;
+       while (loc < locations->nlocations && IS_ERR(mnt)) {
+               struct nfs4_fs_location *location = &locations->locations[loc];
+               char *mnt_path;
+
+               if (location == NULL || location->nservers <= 0 ||
+                   location->rootpath.ncomponents == 0) {
+                       loc++;
+                       continue;
+               }
+
+               mnt_path = nfs4_pathname_string(&location->rootpath, page2, PAGE_SIZE);
+               if (IS_ERR(mnt_path)) {
+                       loc++;
+                       continue;
+               }
+               mountdata.mnt_path = mnt_path;
+
+               s = 0;
+               while (s < location->nservers) {
+                       struct sockaddr_in addr = {};
+
+                       if (location->servers[s].len <= 0 ||
+                           valid_ipaddr4(location->servers[s].data) < 0) {
+                               s++;
+                               continue;
+                       }
+
+                       mountdata.hostname = location->servers[s].data;
+                       addr.sin_addr.s_addr = in_aton(mountdata.hostname);
+                       addr.sin_family = AF_INET;
+                       addr.sin_port = htons(NFS_PORT);
+                       mountdata.addr = &addr;
+
+                       mnt = vfs_kern_mount(&nfs_referral_nfs4_fs_type, 0, devname, &mountdata);
+                       if (!IS_ERR(mnt)) {
+                               break;
+                       }
+                       s++;
+               }
+               loc++;
+       }
+
+out_free:
+       free_page((unsigned long)page);
+       free_page((unsigned long)page2);
+out:
+       dprintk("%s: done\n", __FUNCTION__);
+       return mnt;
+}
+
+/*
+ * nfs_do_refmount - handle crossing a referral on server
+ * @dentry - dentry of referral
+ * @nd - nameidata info
+ *
+ */
+struct vfsmount *nfs_do_refmount(const struct vfsmount *mnt_parent, struct dentry *dentry)
+{
+       struct vfsmount *mnt = ERR_PTR(-ENOENT);
+       struct dentry *parent;
+       struct nfs4_fs_locations *fs_locations = NULL;
+       struct page *page;
+       int err;
+
+       /* BUG_ON(IS_ROOT(dentry)); */
+       dprintk("%s: enter\n", __FUNCTION__);
+
+       page = alloc_page(GFP_KERNEL);
+       if (page == NULL)
+               goto out;
+
+       fs_locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
+       if (fs_locations == NULL)
+               goto out_free;
+
+       /* Get locations */
+       parent = dget_parent(dentry);
+       dprintk("%s: getting locations for %s/%s\n", __FUNCTION__, parent->d_name.name, dentry->d_name.name);
+       err = nfs4_proc_fs_locations(parent->d_inode, dentry, fs_locations, page);
+       dput(parent);
+       if (err != 0 || fs_locations->nlocations <= 0 ||
+           fs_locations->fs_path.ncomponents <= 0)
+               goto out_free;
+
+       mnt = nfs_follow_referral(mnt_parent, dentry, fs_locations);
+out_free:
+       __free_page(page);
+       kfree(fs_locations);
+out:
+       dprintk("%s: done\n", __FUNCTION__);
+       return mnt;
+}
index 3300e35..b4916b0 100644 (file)
@@ -65,8 +65,6 @@ static int nfs4_async_handle_error(struct rpc_task *, const struct nfs_server *)
 static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry);
 static int nfs4_handle_exception(const struct nfs_server *server, int errorcode, struct nfs4_exception *exception);
 static int nfs4_wait_clnt_recover(struct rpc_clnt *clnt, struct nfs4_client *clp);
-extern u32 *nfs4_decode_dirent(u32 *p, struct nfs_entry *entry, int plus);
-extern struct rpc_procinfo nfs4_procedures[];
 
 /* Prevent leaks of NFSv4 errors into userland */
 int nfs4_map_errors(int err)
index 656481c..ef94296 100644 (file)
@@ -378,7 +378,7 @@ out:
        return res;
 }
 
-int nfs_init_nfspagecache(void)
+int __init nfs_init_nfspagecache(void)
 {
        nfs_page_cachep = kmem_cache_create("nfs_page",
                                            sizeof(struct nfs_page),
@@ -390,7 +390,7 @@ int nfs_init_nfspagecache(void)
        return 0;
 }
 
-void nfs_destroy_nfspagecache(void)
+void __exit nfs_destroy_nfspagecache(void)
 {
        if (kmem_cache_destroy(nfs_page_cachep))
                printk(KERN_INFO "nfs_page: not all structures were freed\n");
index 9dd85ca..b3899ea 100644 (file)
 #include <linux/nfs_page.h>
 #include <linux/lockd/bind.h>
 #include <linux/smp_lock.h>
+#include "internal.h"
 
 #define NFSDBG_FACILITY                NFSDBG_PROC
 
-extern struct rpc_procinfo nfs_procedures[];
-
 /*
  * Bare-bones access to getattr: this is for nfs_read_super.
  */
@@ -611,8 +610,6 @@ nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
        return 0;
 }
 
-extern u32 * nfs_decode_dirent(u32 *, struct nfs_entry *, int);
-
 static int nfs_read_done(struct rpc_task *task, struct nfs_read_data *data)
 {
        if (task->tk_status >= 0) {
index fd9018c..41c2ffe 100644 (file)
@@ -694,7 +694,7 @@ int nfs_readpages(struct file *filp, struct address_space *mapping,
        return ret;
 }
 
-int nfs_init_readpagecache(void)
+int __init nfs_init_readpagecache(void)
 {
        nfs_rdata_cachep = kmem_cache_create("nfs_read_data",
                                             sizeof(struct nfs_read_data),
@@ -711,7 +711,7 @@ int nfs_init_readpagecache(void)
        return 0;
 }
 
-void nfs_destroy_readpagecache(void)
+void __exit nfs_destroy_readpagecache(void)
 {
        mempool_destroy(nfs_rdata_mempool);
        if (kmem_cache_destroy(nfs_rdata_cachep))
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
new file mode 100644 (file)
index 0000000..4acd3ee
--- /dev/null
@@ -0,0 +1,1468 @@
+/*
+ *  linux/fs/nfs/super.c
+ *
+ *  Copyright (C) 1992  Rick Sladkey
+ *
+ *  nfs superblock handling functions
+ *
+ *  Modularised by Alan Cox <Alan.Cox@linux.org>, while hacking some
+ *  experimental NFS changes. Modularisation taken straight from SYS5 fs.
+ *
+ *  Change to nfs_read_super() to permit NFS mounts to multi-homed hosts.
+ *  J.S.Peatfield@damtp.cam.ac.uk
+ *
+ *  Split from inode.c by David Howells <dhowells@redhat.com>
+ *
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/init.h>
+
+#include <linux/time.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/string.h>
+#include <linux/stat.h>
+#include <linux/errno.h>
+#include <linux/unistd.h>
+#include <linux/sunrpc/clnt.h>
+#include <linux/sunrpc/stats.h>
+#include <linux/sunrpc/metrics.h>
+#include <linux/nfs_fs.h>
+#include <linux/nfs_mount.h>
+#include <linux/nfs4_mount.h>
+#include <linux/lockd/bind.h>
+#include <linux/smp_lock.h>
+#include <linux/seq_file.h>
+#include <linux/mount.h>
+#include <linux/nfs_idmap.h>
+#include <linux/vfs.h>
+#include <linux/inet.h>
+#include <linux/nfs_xdr.h>
+
+#include <asm/system.h>
+#include <asm/uaccess.h>
+
+#include "nfs4_fs.h"
+#include "callback.h"
+#include "delegation.h"
+#include "iostat.h"
+#include "internal.h"
+
+#define NFSDBG_FACILITY                NFSDBG_VFS
+
+/* Maximum number of readahead requests
+ * FIXME: this should really be a sysctl so that users may tune it to suit
+ *        their needs. People that do NFS over a slow network, might for
+ *        instance want to reduce it to something closer to 1 for improved
+ *        interactive response.
+ */
+#define NFS_MAX_READAHEAD      (RPC_DEF_SLOT_TABLE - 1)
+
+/*
+ * RPC cruft for NFS
+ */
+static struct rpc_version * nfs_version[] = {
+       NULL,
+       NULL,
+       &nfs_version2,
+#if defined(CONFIG_NFS_V3)
+       &nfs_version3,
+#elif defined(CONFIG_NFS_V4)
+       NULL,
+#endif
+#if defined(CONFIG_NFS_V4)
+       &nfs_version4,
+#endif
+};
+
+static struct rpc_program nfs_program = {
+       .name                   = "nfs",
+       .number                 = NFS_PROGRAM,
+       .nrvers                 = ARRAY_SIZE(nfs_version),
+       .version                = nfs_version,
+       .stats                  = &nfs_rpcstat,
+       .pipe_dir_name          = "/nfs",
+};
+
+struct rpc_stat nfs_rpcstat = {
+       .program                = &nfs_program
+};
+
+
+#ifdef CONFIG_NFS_V3_ACL
+static struct rpc_stat         nfsacl_rpcstat = { &nfsacl_program };
+static struct rpc_version *    nfsacl_version[] = {
+       [3]                     = &nfsacl_version3,
+};
+
+struct rpc_program             nfsacl_program = {
+       .name =                 "nfsacl",
+       .number =               NFS_ACL_PROGRAM,
+       .nrvers =               ARRAY_SIZE(nfsacl_version),
+       .version =              nfsacl_version,
+       .stats =                &nfsacl_rpcstat,
+};
+#endif  /* CONFIG_NFS_V3_ACL */
+
+static void nfs_umount_begin(struct vfsmount *, int);
+static int  nfs_statfs(struct super_block *, struct kstatfs *);
+static int  nfs_show_options(struct seq_file *, struct vfsmount *);
+static int  nfs_show_stats(struct seq_file *, struct vfsmount *);
+static struct super_block *nfs_get_sb(struct file_system_type *, int, const char *, void *);
+static struct super_block *nfs_clone_nfs_sb(struct file_system_type *fs_type,
+               int flags, const char *dev_name, void *raw_data);
+static void nfs_kill_super(struct super_block *);
+
+static struct file_system_type nfs_fs_type = {
+       .owner          = THIS_MODULE,
+       .name           = "nfs",
+       .get_sb         = nfs_get_sb,
+       .kill_sb        = nfs_kill_super,
+       .fs_flags       = FS_ODD_RENAME|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
+};
+
+struct file_system_type clone_nfs_fs_type = {
+       .owner          = THIS_MODULE,
+       .name           = "nfs",
+       .get_sb         = nfs_clone_nfs_sb,
+       .kill_sb        = nfs_kill_super,
+       .fs_flags       = FS_ODD_RENAME|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
+};
+
+static struct super_operations nfs_sops = {
+       .alloc_inode    = nfs_alloc_inode,
+       .destroy_inode  = nfs_destroy_inode,
+       .write_inode    = nfs_write_inode,
+       .statfs         = nfs_statfs,
+       .clear_inode    = nfs_clear_inode,
+       .umount_begin   = nfs_umount_begin,
+       .show_options   = nfs_show_options,
+       .show_stats     = nfs_show_stats,
+};
+
+#ifdef CONFIG_NFS_V4
+static struct super_block *nfs4_get_sb(struct file_system_type *fs_type,
+       int flags, const char *dev_name, void *raw_data);
+static struct super_block *nfs_clone_nfs4_sb(struct file_system_type *fs_type,
+               int flags, const char *dev_name, void *raw_data);
+static struct super_block *nfs_referral_nfs4_sb(struct file_system_type *fs_type,
+               int flags, const char *dev_name, void *raw_data);
+static void nfs4_kill_super(struct super_block *sb);
+
+static struct file_system_type nfs4_fs_type = {
+       .owner          = THIS_MODULE,
+       .name           = "nfs4",
+       .get_sb         = nfs4_get_sb,
+       .kill_sb        = nfs4_kill_super,
+       .fs_flags       = FS_ODD_RENAME|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
+};
+
+struct file_system_type clone_nfs4_fs_type = {
+       .owner          = THIS_MODULE,
+       .name           = "nfs4",
+       .get_sb         = nfs_clone_nfs4_sb,
+       .kill_sb        = nfs4_kill_super,
+       .fs_flags       = FS_ODD_RENAME|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
+};
+
+struct file_system_type nfs_referral_nfs4_fs_type = {
+       .owner          = THIS_MODULE,
+       .name           = "nfs4",
+       .get_sb         = nfs_referral_nfs4_sb,
+       .kill_sb        = nfs4_kill_super,
+       .fs_flags       = FS_ODD_RENAME|FS_REVAL_DOT|FS_BINARY_MOUNTDATA,
+};
+
+static struct super_operations nfs4_sops = {
+       .alloc_inode    = nfs_alloc_inode,
+       .destroy_inode  = nfs_destroy_inode,
+       .write_inode    = nfs_write_inode,
+       .statfs         = nfs_statfs,
+       .clear_inode    = nfs4_clear_inode,
+       .umount_begin   = nfs_umount_begin,
+       .show_options   = nfs_show_options,
+       .show_stats     = nfs_show_stats,
+};
+#endif
+
+static const int nfs_set_port_min = 0;
+static const int nfs_set_port_max = 65535;
+
+static int param_set_port(const char *val, struct kernel_param *kp)
+{
+       char *endp;
+       int num = simple_strtol(val, &endp, 0);
+       if (endp == val || *endp || num < nfs_set_port_min || num > nfs_set_port_max)
+               return -EINVAL;
+       *((int *)kp->arg) = num;
+       return 0;
+}
+
+module_param_call(callback_tcpport, param_set_port, param_get_int,
+                &nfs_callback_set_tcpport, 0644);
+
+static int param_set_idmap_timeout(const char *val, struct kernel_param *kp)
+{
+       char *endp;
+       int num = simple_strtol(val, &endp, 0);
+       int jif = num * HZ;
+       if (endp == val || *endp || num < 0 || jif < num)
+               return -EINVAL;
+       *((int *)kp->arg) = jif;
+       return 0;
+}
+
+module_param_call(idmap_cache_timeout, param_set_idmap_timeout, param_get_int,
+                &nfs_idmap_cache_timeout, 0644);
+
+/*
+ * Register the NFS filesystems
+ */
+int __init register_nfs_fs(void)
+{
+       int ret;
+
+        ret = register_filesystem(&nfs_fs_type);
+       if (ret < 0)
+               goto error_0;
+
+#ifdef CONFIG_NFS_V4
+       ret = nfs_register_sysctl();
+       if (ret < 0)
+               goto error_1;
+       ret = register_filesystem(&nfs4_fs_type);
+       if (ret < 0)
+               goto error_2;
+#endif
+       return 0;
+
+#ifdef CONFIG_NFS_V4
+error_2:
+       nfs_unregister_sysctl();
+error_1:
+       unregister_filesystem(&nfs_fs_type);
+#endif
+error_0:
+       return ret;
+}
+
+/*
+ * Unregister the NFS filesystems
+ */
+void __exit unregister_nfs_fs(void)
+{
+#ifdef CONFIG_NFS_V4
+       unregister_filesystem(&nfs4_fs_type);
+       nfs_unregister_sysctl();
+#endif
+       unregister_filesystem(&nfs_fs_type);
+}
+
+/*
+ * Deliver file system statistics to userspace
+ */
+static int nfs_statfs(struct super_block *sb, struct kstatfs *buf)
+{
+       struct nfs_server *server = NFS_SB(sb);
+       unsigned char blockbits;
+       unsigned long blockres;
+       struct nfs_fh *rootfh = NFS_FH(sb->s_root->d_inode);
+       struct nfs_fattr fattr;
+       struct nfs_fsstat res = {
+                       .fattr = &fattr,
+       };
+       int error;
+
+       lock_kernel();
+
+       error = server->rpc_ops->statfs(server, rootfh, &res);
+       buf->f_type = NFS_SUPER_MAGIC;
+       if (error < 0)
+               goto out_err;
+
+       /*
+        * Current versions of glibc do not correctly handle the
+        * case where f_frsize != f_bsize.  Eventually we want to
+        * report the value of wtmult in this field.
+        */
+       buf->f_frsize = sb->s_blocksize;
+
+       /*
+        * On most *nix systems, f_blocks, f_bfree, and f_bavail
+        * are reported in units of f_frsize.  Linux hasn't had
+        * an f_frsize field in its statfs struct until recently,
+        * thus historically Linux's sys_statfs reports these
+        * fields in units of f_bsize.
+        */
+       buf->f_bsize = sb->s_blocksize;
+       blockbits = sb->s_blocksize_bits;
+       blockres = (1 << blockbits) - 1;
+       buf->f_blocks = (res.tbytes + blockres) >> blockbits;
+       buf->f_bfree = (res.fbytes + blockres) >> blockbits;
+       buf->f_bavail = (res.abytes + blockres) >> blockbits;
+
+       buf->f_files = res.tfiles;
+       buf->f_ffree = res.afiles;
+
+       buf->f_namelen = server->namelen;
+ out:
+       unlock_kernel();
+       return 0;
+
+ out_err:
+       dprintk("%s: statfs error = %d\n", __FUNCTION__, -error);
+       buf->f_bsize = buf->f_blocks = buf->f_bfree = buf->f_bavail = -1;
+       goto out;
+
+}
+
+/*
+ * Describe the mount options in force on this server representation
+ */
+static void nfs_show_mount_options(struct seq_file *m, struct nfs_server *nfss, int showdefaults)
+{
+       static struct proc_nfs_info {
+               int flag;
+               char *str;
+               char *nostr;
+       } nfs_info[] = {
+               { NFS_MOUNT_SOFT, ",soft", ",hard" },
+               { NFS_MOUNT_INTR, ",intr", "" },
+               { NFS_MOUNT_NOCTO, ",nocto", "" },
+               { NFS_MOUNT_NOAC, ",noac", "" },
+               { NFS_MOUNT_NONLM, ",nolock", "" },
+               { NFS_MOUNT_NOACL, ",noacl", "" },
+               { 0, NULL, NULL }
+       };
+       struct proc_nfs_info *nfs_infop;
+       char buf[12];
+       char *proto;
+
+       seq_printf(m, ",vers=%d", nfss->rpc_ops->version);
+       seq_printf(m, ",rsize=%d", nfss->rsize);
+       seq_printf(m, ",wsize=%d", nfss->wsize);
+       if (nfss->acregmin != 3*HZ || showdefaults)
+               seq_printf(m, ",acregmin=%d", nfss->acregmin/HZ);
+       if (nfss->acregmax != 60*HZ || showdefaults)
+               seq_printf(m, ",acregmax=%d", nfss->acregmax/HZ);
+       if (nfss->acdirmin != 30*HZ || showdefaults)
+               seq_printf(m, ",acdirmin=%d", nfss->acdirmin/HZ);
+       if (nfss->acdirmax != 60*HZ || showdefaults)
+               seq_printf(m, ",acdirmax=%d", nfss->acdirmax/HZ);
+       for (nfs_infop = nfs_info; nfs_infop->flag; nfs_infop++) {
+               if (nfss->flags & nfs_infop->flag)
+                       seq_puts(m, nfs_infop->str);
+               else
+                       seq_puts(m, nfs_infop->nostr);
+       }
+       switch (nfss->client->cl_xprt->prot) {
+               case IPPROTO_TCP:
+                       proto = "tcp";
+                       break;
+               case IPPROTO_UDP:
+                       proto = "udp";
+                       break;
+               default:
+                       snprintf(buf, sizeof(buf), "%u", nfss->client->cl_xprt->prot);
+                       proto = buf;
+       }
+       seq_printf(m, ",proto=%s", proto);
+       seq_printf(m, ",timeo=%lu", 10U * nfss->retrans_timeo / HZ);
+       seq_printf(m, ",retrans=%u", nfss->retrans_count);
+}
+
+/*
+ * Describe the mount options on this VFS mountpoint
+ */
+static int nfs_show_options(struct seq_file *m, struct vfsmount *mnt)
+{
+       struct nfs_server *nfss = NFS_SB(mnt->mnt_sb);
+
+       nfs_show_mount_options(m, nfss, 0);
+
+       seq_puts(m, ",addr=");
+       seq_escape(m, nfss->hostname, " \t\n\\");
+
+       return 0;
+}
+
+/*
+ * Present statistical information for this VFS mountpoint
+ */
+static int nfs_show_stats(struct seq_file *m, struct vfsmount *mnt)
+{
+       int i, cpu;
+       struct nfs_server *nfss = NFS_SB(mnt->mnt_sb);
+       struct rpc_auth *auth = nfss->client->cl_auth;
+       struct nfs_iostats totals = { };
+
+       seq_printf(m, "statvers=%s", NFS_IOSTAT_VERS);
+
+       /*
+        * Display all mount option settings
+        */
+       seq_printf(m, "\n\topts:\t");
+       seq_puts(m, mnt->mnt_sb->s_flags & MS_RDONLY ? "ro" : "rw");
+       seq_puts(m, mnt->mnt_sb->s_flags & MS_SYNCHRONOUS ? ",sync" : "");
+       seq_puts(m, mnt->mnt_sb->s_flags & MS_NOATIME ? ",noatime" : "");
+       seq_puts(m, mnt->mnt_sb->s_flags & MS_NODIRATIME ? ",nodiratime" : "");
+       nfs_show_mount_options(m, nfss, 1);
+
+       seq_printf(m, "\n\tage:\t%lu", (jiffies - nfss->mount_time) / HZ);
+
+       seq_printf(m, "\n\tcaps:\t");
+       seq_printf(m, "caps=0x%x", nfss->caps);
+       seq_printf(m, ",wtmult=%d", nfss->wtmult);
+       seq_printf(m, ",dtsize=%d", nfss->dtsize);
+       seq_printf(m, ",bsize=%d", nfss->bsize);
+       seq_printf(m, ",namelen=%d", nfss->namelen);
+
+#ifdef CONFIG_NFS_V4
+       if (nfss->rpc_ops->version == 4) {
+               seq_printf(m, "\n\tnfsv4:\t");
+               seq_printf(m, "bm0=0x%x", nfss->attr_bitmask[0]);
+               seq_printf(m, ",bm1=0x%x", nfss->attr_bitmask[1]);
+               seq_printf(m, ",acl=0x%x", nfss->acl_bitmask);
+       }
+#endif
+
+       /*
+        * Display security flavor in effect for this mount
+        */
+       seq_printf(m, "\n\tsec:\tflavor=%d", auth->au_ops->au_flavor);
+       if (auth->au_flavor)
+               seq_printf(m, ",pseudoflavor=%d", auth->au_flavor);
+
+       /*
+        * Display superblock I/O counters
+        */
+       for_each_possible_cpu(cpu) {
+               struct nfs_iostats *stats;
+
+               preempt_disable();
+               stats = per_cpu_ptr(nfss->io_stats, cpu);
+
+               for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
+                       totals.events[i] += stats->events[i];
+               for (i = 0; i < __NFSIOS_BYTESMAX; i++)
+                       totals.bytes[i] += stats->bytes[i];
+
+               preempt_enable();
+       }
+
+       seq_printf(m, "\n\tevents:\t");
+       for (i = 0; i < __NFSIOS_COUNTSMAX; i++)
+               seq_printf(m, "%lu ", totals.events[i]);
+       seq_printf(m, "\n\tbytes:\t");
+       for (i = 0; i < __NFSIOS_BYTESMAX; i++)
+               seq_printf(m, "%Lu ", totals.bytes[i]);
+       seq_printf(m, "\n");
+
+       rpc_print_iostats(m, nfss->client);
+
+       return 0;
+}
+
+/*
+ * Begin unmount by attempting to remove all automounted mountpoints we added
+ * in response to traversals
+ */
+static void nfs_umount_begin(struct vfsmount *vfsmnt, int flags)
+{
+       struct nfs_server *server;
+       struct rpc_clnt *rpc;
+
+       shrink_submounts(vfsmnt, &nfs_automount_list);
+       if (!(flags & MNT_FORCE))
+               return;
+       /* -EIO all pending I/O */
+       server = NFS_SB(vfsmnt->mnt_sb);
+       rpc = server->client;
+       if (!IS_ERR(rpc))
+               rpc_killall_tasks(rpc);
+       rpc = server->client_acl;
+       if (!IS_ERR(rpc))
+               rpc_killall_tasks(rpc);
+}
+
+/*
+ * Obtain the root inode of the file system.
+ */
+static struct inode *
+nfs_get_root(struct super_block *sb, struct nfs_fh *rootfh, struct nfs_fsinfo *fsinfo)
+{
+       struct nfs_server       *server = NFS_SB(sb);
+       int                     error;
+
+       error = server->rpc_ops->getroot(server, rootfh, fsinfo);
+       if (error < 0) {
+               dprintk("nfs_get_root: getattr error = %d\n", -error);
+               return ERR_PTR(error);
+       }
+
+       server->fsid = fsinfo->fattr->fsid;
+       return nfs_fhget(sb, rootfh, fsinfo->fattr);
+}
+
+/*
+ * Do NFS version-independent mount processing, and sanity checking
+ */
+static int
+nfs_sb_init(struct super_block *sb, rpc_authflavor_t authflavor)
+{
+       struct nfs_server       *server;
+       struct inode            *root_inode;
+       struct nfs_fattr        fattr;
+       struct nfs_fsinfo       fsinfo = {
+                                       .fattr = &fattr,
+                               };
+       struct nfs_pathconf pathinfo = {
+                       .fattr = &fattr,
+       };
+       int no_root_error = 0;
+       unsigned long max_rpc_payload;
+
+       /* We probably want something more informative here */
+       snprintf(sb->s_id, sizeof(sb->s_id), "%x:%x", MAJOR(sb->s_dev), MINOR(sb->s_dev));
+
+       server = NFS_SB(sb);
+
+       sb->s_magic      = NFS_SUPER_MAGIC;
+
+       server->io_stats = nfs_alloc_iostats();
+       if (server->io_stats == NULL)
+               return -ENOMEM;
+
+       root_inode = nfs_get_root(sb, &server->fh, &fsinfo);
+       /* Did getting the root inode fail? */
+       if (IS_ERR(root_inode)) {
+               no_root_error = PTR_ERR(root_inode);
+               goto out_no_root;
+       }
+       sb->s_root = d_alloc_root(root_inode);
+       if (!sb->s_root) {
+               no_root_error = -ENOMEM;
+               goto out_no_root;
+       }
+       sb->s_root->d_op = server->rpc_ops->dentry_ops;
+
+       /* mount time stamp, in seconds */
+       server->mount_time = jiffies;
+
+       /* Get some general file system info */
+       if (server->namelen == 0 &&
+           server->rpc_ops->pathconf(server, &server->fh, &pathinfo) >= 0)
+               server->namelen = pathinfo.max_namelen;
+       /* Work out a lot of parameters */
+       if (server->rsize == 0)
+               server->rsize = nfs_block_size(fsinfo.rtpref, NULL);
+       if (server->wsize == 0)
+               server->wsize = nfs_block_size(fsinfo.wtpref, NULL);
+
+       if (fsinfo.rtmax >= 512 && server->rsize > fsinfo.rtmax)
+               server->rsize = nfs_block_size(fsinfo.rtmax, NULL);
+       if (fsinfo.wtmax >= 512 && server->wsize > fsinfo.wtmax)
+               server->wsize = nfs_block_size(fsinfo.wtmax, NULL);
+
+       max_rpc_payload = nfs_block_size(rpc_max_payload(server->client), NULL);
+       if (server->rsize > max_rpc_payload)
+               server->rsize = max_rpc_payload;
+       if (server->rsize > NFS_MAX_FILE_IO_SIZE)
+               server->rsize = NFS_MAX_FILE_IO_SIZE;
+       server->rpages = (server->rsize + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+
+       if (server->wsize > max_rpc_payload)
+               server->wsize = max_rpc_payload;
+       if (server->wsize > NFS_MAX_FILE_IO_SIZE)
+               server->wsize = NFS_MAX_FILE_IO_SIZE;
+       server->wpages = (server->wsize + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+
+       if (sb->s_blocksize == 0)
+               sb->s_blocksize = nfs_block_bits(server->wsize,
+                                                        &sb->s_blocksize_bits);
+       server->wtmult = nfs_block_bits(fsinfo.wtmult, NULL);
+
+       server->dtsize = nfs_block_size(fsinfo.dtpref, NULL);
+       if (server->dtsize > PAGE_CACHE_SIZE)
+               server->dtsize = PAGE_CACHE_SIZE;
+       if (server->dtsize > server->rsize)
+               server->dtsize = server->rsize;
+
+       if (server->flags & NFS_MOUNT_NOAC) {
+               server->acregmin = server->acregmax = 0;
+               server->acdirmin = server->acdirmax = 0;
+               sb->s_flags |= MS_SYNCHRONOUS;
+       }
+       server->backing_dev_info.ra_pages = server->rpages * NFS_MAX_READAHEAD;
+
+       nfs_super_set_maxbytes(sb, fsinfo.maxfilesize);
+
+       server->client->cl_intr = (server->flags & NFS_MOUNT_INTR) ? 1 : 0;
+       server->client->cl_softrtry = (server->flags & NFS_MOUNT_SOFT) ? 1 : 0;
+
+       /* We're airborne Set socket buffersize */
+       rpc_setbufsize(server->client, server->wsize + 100, server->rsize + 100);
+       return 0;
+       /* Yargs. It didn't work out. */
+out_no_root:
+       dprintk("nfs_sb_init: get root inode failed: errno %d\n", -no_root_error);
+       if (!IS_ERR(root_inode))
+               iput(root_inode);
+       return no_root_error;
+}
+
+/*
+ * Initialise the timeout values for a connection
+ */
+static void nfs_init_timeout_values(struct rpc_timeout *to, int proto, unsigned int timeo, unsigned int retrans)
+{
+       to->to_initval = timeo * HZ / 10;
+       to->to_retries = retrans;
+       if (!to->to_retries)
+               to->to_retries = 2;
+
+       switch (proto) {
+       case IPPROTO_TCP:
+               if (!to->to_initval)
+                       to->to_initval = 60 * HZ;
+               if (to->to_initval > NFS_MAX_TCP_TIMEOUT)
+                       to->to_initval = NFS_MAX_TCP_TIMEOUT;
+               to->to_increment = to->to_initval;
+               to->to_maxval = to->to_initval + (to->to_increment * to->to_retries);
+               to->to_exponential = 0;
+               break;
+       case IPPROTO_UDP:
+       default:
+               if (!to->to_initval)
+                       to->to_initval = 11 * HZ / 10;
+               if (to->to_initval > NFS_MAX_UDP_TIMEOUT)
+                       to->to_initval = NFS_MAX_UDP_TIMEOUT;
+               to->to_maxval = NFS_MAX_UDP_TIMEOUT;
+               to->to_exponential = 1;
+               break;
+       }
+}
+
+/*
+ * Create an RPC client handle.
+ */
+static struct rpc_clnt *
+nfs_create_client(struct nfs_server *server, const struct nfs_mount_data *data)
+{
+       struct rpc_timeout      timeparms;
+       struct rpc_xprt         *xprt = NULL;
+       struct rpc_clnt         *clnt = NULL;
+       int                     proto = (data->flags & NFS_MOUNT_TCP) ? IPPROTO_TCP : IPPROTO_UDP;
+
+       nfs_init_timeout_values(&timeparms, proto, data->timeo, data->retrans);
+
+       server->retrans_timeo = timeparms.to_initval;
+       server->retrans_count = timeparms.to_retries;
+
+       /* create transport and client */
+       xprt = xprt_create_proto(proto, &server->addr, &timeparms);
+       if (IS_ERR(xprt)) {
+               dprintk("%s: cannot create RPC transport. Error = %ld\n",
+                               __FUNCTION__, PTR_ERR(xprt));
+               return (struct rpc_clnt *)xprt;
+       }
+       clnt = rpc_create_client(xprt, server->hostname, &nfs_program,
+                                server->rpc_ops->version, data->pseudoflavor);
+       if (IS_ERR(clnt)) {
+               dprintk("%s: cannot create RPC client. Error = %ld\n",
+                               __FUNCTION__, PTR_ERR(xprt));
+               goto out_fail;
+       }
+
+       clnt->cl_intr     = 1;
+       clnt->cl_softrtry = 1;
+
+       return clnt;
+
+out_fail:
+       return clnt;
+}
+
+/*
+ * Clone a server record
+ */
+static struct nfs_server *nfs_clone_server(struct super_block *sb, struct nfs_clone_mount *data)
+{
+       struct nfs_server *server = NFS_SB(sb);
+       struct nfs_server *parent = NFS_SB(data->sb);
+       struct inode *root_inode;
+       struct nfs_fsinfo fsinfo;
+       void *err = ERR_PTR(-ENOMEM);
+
+       sb->s_op = data->sb->s_op;
+       sb->s_blocksize = data->sb->s_blocksize;
+       sb->s_blocksize_bits = data->sb->s_blocksize_bits;
+       sb->s_maxbytes = data->sb->s_maxbytes;
+
+       server->client_sys = server->client_acl = ERR_PTR(-EINVAL);
+       server->io_stats = nfs_alloc_iostats();
+       if (server->io_stats == NULL)
+               goto out;
+
+       server->client = rpc_clone_client(parent->client);
+       if (IS_ERR((err = server->client)))
+               goto out;
+
+       if (!IS_ERR(parent->client_sys)) {
+               server->client_sys = rpc_clone_client(parent->client_sys);
+               if (IS_ERR((err = server->client_sys)))
+                       goto out;
+       }
+       if (!IS_ERR(parent->client_acl)) {
+               server->client_acl = rpc_clone_client(parent->client_acl);
+               if (IS_ERR((err = server->client_acl)))
+                       goto out;
+       }
+       root_inode = nfs_fhget(sb, data->fh, data->fattr);
+       if (!root_inode)
+               goto out;
+       sb->s_root = d_alloc_root(root_inode);
+       if (!sb->s_root)
+               goto out_put_root;
+       fsinfo.fattr = data->fattr;
+       if (NFS_PROTO(root_inode)->fsinfo(server, data->fh, &fsinfo) == 0)
+               nfs_super_set_maxbytes(sb, fsinfo.maxfilesize);
+       sb->s_root->d_op = server->rpc_ops->dentry_ops;
+       sb->s_flags |= MS_ACTIVE;
+       return server;
+out_put_root:
+       iput(root_inode);
+out:
+       return err;
+}
+
+/*
+ * Copy an existing superblock and attach revised data
+ */
+static struct super_block *nfs_clone_generic_sb(struct nfs_clone_mount *data,
+               struct super_block *(*fill_sb)(struct nfs_server *, struct nfs_clone_mount *),
+               struct nfs_server *(*fill_server)(struct super_block *, struct nfs_clone_mount *))
+{
+       struct nfs_server *server;
+       struct nfs_server *parent = NFS_SB(data->sb);
+       struct super_block *sb = ERR_PTR(-EINVAL);
+       void *err = ERR_PTR(-ENOMEM);
+       char *hostname;
+       int len;
+
+       server = kmalloc(sizeof(struct nfs_server), GFP_KERNEL);
+       if (server == NULL)
+               goto out_err;
+       memcpy(server, parent, sizeof(*server));
+       hostname = (data->hostname != NULL) ? data->hostname : parent->hostname;
+       len = strlen(hostname) + 1;
+       server->hostname = kmalloc(len, GFP_KERNEL);
+       if (server->hostname == NULL)
+               goto free_server;
+       memcpy(server->hostname, hostname, len);
+       if (rpciod_up() != 0)
+               goto free_hostname;
+
+       sb = fill_sb(server, data);
+       if (IS_ERR((err = sb)) || sb->s_root)
+               goto kill_rpciod;
+
+       server = fill_server(sb, data);
+       if (IS_ERR((err = server)))
+               goto out_deactivate;
+       return sb;
+out_deactivate:
+       up_write(&sb->s_umount);
+       deactivate_super(sb);
+       return (struct super_block *)err;
+kill_rpciod:
+       rpciod_down();
+free_hostname:
+       kfree(server->hostname);
+free_server:
+       kfree(server);
+out_err:
+       return (struct super_block *)err;
+}
+
+/*
+ * Set up an NFS2/3 superblock
+ *
+ * The way this works is that the mount process passes a structure
+ * in the data argument which contains the server's IP address
+ * and the root file handle obtained from the server's mount
+ * daemon. We stash these away in the private superblock fields.
+ */
+static int
+nfs_fill_super(struct super_block *sb, struct nfs_mount_data *data, int silent)
+{
+       struct nfs_server       *server;
+       rpc_authflavor_t        authflavor;
+
+       server           = NFS_SB(sb);
+       sb->s_blocksize_bits = 0;
+       sb->s_blocksize = 0;
+       if (data->bsize)
+               sb->s_blocksize = nfs_block_size(data->bsize, &sb->s_blocksize_bits);
+       if (data->rsize)
+               server->rsize = nfs_block_size(data->rsize, NULL);
+       if (data->wsize)
+               server->wsize = nfs_block_size(data->wsize, NULL);
+       server->flags    = data->flags & NFS_MOUNT_FLAGMASK;
+
+       server->acregmin = data->acregmin*HZ;
+       server->acregmax = data->acregmax*HZ;
+       server->acdirmin = data->acdirmin*HZ;
+       server->acdirmax = data->acdirmax*HZ;
+
+       /* Start lockd here, before we might error out */
+       if (!(server->flags & NFS_MOUNT_NONLM))
+               lockd_up();
+
+       server->namelen  = data->namlen;
+       server->hostname = kmalloc(strlen(data->hostname) + 1, GFP_KERNEL);
+       if (!server->hostname)
+               return -ENOMEM;
+       strcpy(server->hostname, data->hostname);
+
+       /* Check NFS protocol revision and initialize RPC op vector
+        * and file handle pool. */
+#ifdef CONFIG_NFS_V3
+       if (server->flags & NFS_MOUNT_VER3) {
+               server->rpc_ops = &nfs_v3_clientops;
+               server->caps |= NFS_CAP_READDIRPLUS;
+       } else {
+               server->rpc_ops = &nfs_v2_clientops;
+       }
+#else
+       server->rpc_ops = &nfs_v2_clientops;
+#endif
+
+       /* Fill in pseudoflavor for mount version < 5 */
+       if (!(data->flags & NFS_MOUNT_SECFLAVOUR))
+               data->pseudoflavor = RPC_AUTH_UNIX;
+       authflavor = data->pseudoflavor;        /* save for sb_init() */
+       /* XXX maybe we want to add a server->pseudoflavor field */
+
+       /* Create RPC client handles */
+       server->client = nfs_create_client(server, data);
+       if (IS_ERR(server->client))
+               return PTR_ERR(server->client);
+       /* RFC 2623, sec 2.3.2 */
+       if (authflavor != RPC_AUTH_UNIX) {
+               struct rpc_auth *auth;
+
+               server->client_sys = rpc_clone_client(server->client);
+               if (IS_ERR(server->client_sys))
+                       return PTR_ERR(server->client_sys);
+               auth = rpcauth_create(RPC_AUTH_UNIX, server->client_sys);
+               if (IS_ERR(auth))
+                       return PTR_ERR(auth);
+       } else {
+               atomic_inc(&server->client->cl_count);
+               server->client_sys = server->client;
+       }
+       if (server->flags & NFS_MOUNT_VER3) {
+#ifdef CONFIG_NFS_V3_ACL
+               if (!(server->flags & NFS_MOUNT_NOACL)) {
+                       server->client_acl = rpc_bind_new_program(server->client, &nfsacl_program, 3);
+                       /* No errors! Assume that Sun nfsacls are supported */
+                       if (!IS_ERR(server->client_acl))
+                               server->caps |= NFS_CAP_ACLS;
+               }
+#else
+               server->flags &= ~NFS_MOUNT_NOACL;
+#endif /* CONFIG_NFS_V3_ACL */
+               /*
+                * The VFS shouldn't apply the umask to mode bits. We will
+                * do so ourselves when necessary.
+                */
+               sb->s_flags |= MS_POSIXACL;
+               if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)
+                       server->namelen = NFS3_MAXNAMLEN;
+               sb->s_time_gran = 1;
+       } else {
+               if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)
+                       server->namelen = NFS2_MAXNAMLEN;
+       }
+
+       sb->s_op = &nfs_sops;
+       return nfs_sb_init(sb, authflavor);
+}
+
+static int nfs_set_super(struct super_block *s, void *data)
+{
+       s->s_fs_info = data;
+       return set_anon_super(s, data);
+}
+
+static int nfs_compare_super(struct super_block *sb, void *data)
+{
+       struct nfs_server *server = data;
+       struct nfs_server *old = NFS_SB(sb);
+
+       if (old->addr.sin_addr.s_addr != server->addr.sin_addr.s_addr)
+               return 0;
+       if (old->addr.sin_port != server->addr.sin_port)
+               return 0;
+       return !nfs_compare_fh(&old->fh, &server->fh);
+}
+
+static struct super_block *nfs_get_sb(struct file_system_type *fs_type,
+       int flags, const char *dev_name, void *raw_data)
+{
+       int error;
+       struct nfs_server *server = NULL;
+       struct super_block *s;
+       struct nfs_fh *root;
+       struct nfs_mount_data *data = raw_data;
+
+       s = ERR_PTR(-EINVAL);
+       if (data == NULL) {
+               dprintk("%s: missing data argument\n", __FUNCTION__);
+               goto out_err;
+       }
+       if (data->version <= 0 || data->version > NFS_MOUNT_VERSION) {
+               dprintk("%s: bad mount version\n", __FUNCTION__);
+               goto out_err;
+       }
+       switch (data->version) {
+               case 1:
+                       data->namlen = 0;
+               case 2:
+                       data->bsize  = 0;
+               case 3:
+                       if (data->flags & NFS_MOUNT_VER3) {
+                               dprintk("%s: mount structure version %d does not support NFSv3\n",
+                                               __FUNCTION__,
+                                               data->version);
+                               goto out_err;
+                       }
+                       data->root.size = NFS2_FHSIZE;
+                       memcpy(data->root.data, data->old_root.data, NFS2_FHSIZE);
+               case 4:
+                       if (data->flags & NFS_MOUNT_SECFLAVOUR) {
+                               dprintk("%s: mount structure version %d does not support strong security\n",
+                                               __FUNCTION__,
+                                               data->version);
+                               goto out_err;
+                       }
+               case 5:
+                       memset(data->context, 0, sizeof(data->context));
+       }
+#ifndef CONFIG_NFS_V3
+       /* If NFSv3 is not compiled in, return -EPROTONOSUPPORT */
+       s = ERR_PTR(-EPROTONOSUPPORT);
+       if (data->flags & NFS_MOUNT_VER3) {
+               dprintk("%s: NFSv3 not compiled into kernel\n", __FUNCTION__);
+               goto out_err;
+       }
+#endif /* CONFIG_NFS_V3 */
+
+       s = ERR_PTR(-ENOMEM);
+       server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL);
+       if (!server)
+               goto out_err;
+       /* Zero out the NFS state stuff */
+       init_nfsv4_state(server);
+       server->client = server->client_sys = server->client_acl = ERR_PTR(-EINVAL);
+
+       root = &server->fh;
+       if (data->flags & NFS_MOUNT_VER3)
+               root->size = data->root.size;
+       else
+               root->size = NFS2_FHSIZE;
+       s = ERR_PTR(-EINVAL);
+       if (root->size > sizeof(root->data)) {
+               dprintk("%s: invalid root filehandle\n", __FUNCTION__);
+               goto out_err;
+       }
+       memcpy(root->data, data->root.data, root->size);
+
+       /* We now require that the mount process passes the remote address */
+       memcpy(&server->addr, &data->addr, sizeof(server->addr));
+       if (server->addr.sin_addr.s_addr == INADDR_ANY) {
+               dprintk("%s: mount program didn't pass remote address!\n",
+                               __FUNCTION__);
+               goto out_err;
+       }
+
+       /* Fire up rpciod if not yet running */
+       s = ERR_PTR(rpciod_up());
+       if (IS_ERR(s)) {
+               dprintk("%s: couldn't start rpciod! Error = %ld\n",
+                               __FUNCTION__, PTR_ERR(s));
+               goto out_err;
+       }
+
+       s = sget(fs_type, nfs_compare_super, nfs_set_super, server);
+       if (IS_ERR(s) || s->s_root)
+               goto out_rpciod_down;
+
+       s->s_flags = flags;
+
+       error = nfs_fill_super(s, data, flags & MS_SILENT ? 1 : 0);
+       if (error) {
+               up_write(&s->s_umount);
+               deactivate_super(s);
+               return ERR_PTR(error);
+       }
+       s->s_flags |= MS_ACTIVE;
+       return s;
+out_rpciod_down:
+       rpciod_down();
+out_err:
+       kfree(server);
+       return s;
+}
+
+static void nfs_kill_super(struct super_block *s)
+{
+       struct nfs_server *server = NFS_SB(s);
+
+       kill_anon_super(s);
+
+       if (!IS_ERR(server->client))
+               rpc_shutdown_client(server->client);
+       if (!IS_ERR(server->client_sys))
+               rpc_shutdown_client(server->client_sys);
+       if (!IS_ERR(server->client_acl))
+               rpc_shutdown_client(server->client_acl);
+
+       if (!(server->flags & NFS_MOUNT_NONLM))
+               lockd_down();   /* release rpc.lockd */
+
+       rpciod_down();          /* release rpciod */
+
+       nfs_free_iostats(server->io_stats);
+       kfree(server->hostname);
+       kfree(server);
+       nfs_release_automount_timer();
+}
+
+static struct super_block *nfs_clone_sb(struct nfs_server *server, struct nfs_clone_mount *data)
+{
+       struct super_block *sb;
+
+       server->fsid = data->fattr->fsid;
+       nfs_copy_fh(&server->fh, data->fh);
+       sb = sget(&nfs_fs_type, nfs_compare_super, nfs_set_super, server);
+       if (!IS_ERR(sb) && sb->s_root == NULL && !(server->flags & NFS_MOUNT_NONLM))
+               lockd_up();
+       return sb;
+}
+
+static struct super_block *nfs_clone_nfs_sb(struct file_system_type *fs_type,
+               int flags, const char *dev_name, void *raw_data)
+{
+       struct nfs_clone_mount *data = raw_data;
+       return nfs_clone_generic_sb(data, nfs_clone_sb, nfs_clone_server);
+}
+
+#ifdef CONFIG_NFS_V4
+static struct rpc_clnt *nfs4_create_client(struct nfs_server *server,
+       struct rpc_timeout *timeparms, int proto, rpc_authflavor_t flavor)
+{
+       struct nfs4_client *clp;
+       struct rpc_xprt *xprt = NULL;
+       struct rpc_clnt *clnt = NULL;
+       int err = -EIO;
+
+       clp = nfs4_get_client(&server->addr.sin_addr);
+       if (!clp) {
+               dprintk("%s: failed to create NFS4 client.\n", __FUNCTION__);
+               return ERR_PTR(err);
+       }
+
+       /* Now create transport and client */
+       down_write(&clp->cl_sem);
+       if (IS_ERR(clp->cl_rpcclient)) {
+               xprt = xprt_create_proto(proto, &server->addr, timeparms);
+               if (IS_ERR(xprt)) {
+                       up_write(&clp->cl_sem);
+                       err = PTR_ERR(xprt);
+                       dprintk("%s: cannot create RPC transport. Error = %d\n",
+                                       __FUNCTION__, err);
+                       goto out_fail;
+               }
+               /* Bind to a reserved port! */
+               xprt->resvport = 1;
+               clnt = rpc_create_client(xprt, server->hostname, &nfs_program,
+                               server->rpc_ops->version, flavor);
+               if (IS_ERR(clnt)) {
+                       up_write(&clp->cl_sem);
+                       err = PTR_ERR(clnt);
+                       dprintk("%s: cannot create RPC client. Error = %d\n",
+                                       __FUNCTION__, err);
+                       goto out_fail;
+               }
+               clnt->cl_intr     = 1;
+               clnt->cl_softrtry = 1;
+               clp->cl_rpcclient = clnt;
+               memcpy(clp->cl_ipaddr, server->ip_addr, sizeof(clp->cl_ipaddr));
+               nfs_idmap_new(clp);
+       }
+       list_add_tail(&server->nfs4_siblings, &clp->cl_superblocks);
+       clnt = rpc_clone_client(clp->cl_rpcclient);
+       if (!IS_ERR(clnt))
+               server->nfs4_state = clp;
+       up_write(&clp->cl_sem);
+       clp = NULL;
+
+       if (IS_ERR(clnt)) {
+               dprintk("%s: cannot create RPC client. Error = %d\n",
+                               __FUNCTION__, err);
+               return clnt;
+       }
+
+       if (server->nfs4_state->cl_idmap == NULL) {
+               dprintk("%s: failed to create idmapper.\n", __FUNCTION__);
+               return ERR_PTR(-ENOMEM);
+       }
+
+       if (clnt->cl_auth->au_flavor != flavor) {
+               struct rpc_auth *auth;
+
+               auth = rpcauth_create(flavor, clnt);
+               if (IS_ERR(auth)) {
+                       dprintk("%s: couldn't create credcache!\n", __FUNCTION__);
+                       return (struct rpc_clnt *)auth;
+               }
+       }
+       return clnt;
+
+ out_fail:
+       if (clp)
+               nfs4_put_client(clp);
+       return ERR_PTR(err);
+}
+
+/*
+ * Set up an NFS4 superblock
+ */
+static int nfs4_fill_super(struct super_block *sb, struct nfs4_mount_data *data, int silent)
+{
+       struct nfs_server *server;
+       struct rpc_timeout timeparms;
+       rpc_authflavor_t authflavour;
+       int err = -EIO;
+
+       sb->s_blocksize_bits = 0;
+       sb->s_blocksize = 0;
+       server = NFS_SB(sb);
+       if (data->rsize != 0)
+               server->rsize = nfs_block_size(data->rsize, NULL);
+       if (data->wsize != 0)
+               server->wsize = nfs_block_size(data->wsize, NULL);
+       server->flags = data->flags & NFS_MOUNT_FLAGMASK;
+       server->caps = NFS_CAP_ATOMIC_OPEN;
+
+       server->acregmin = data->acregmin*HZ;
+       server->acregmax = data->acregmax*HZ;
+       server->acdirmin = data->acdirmin*HZ;
+       server->acdirmax = data->acdirmax*HZ;
+
+       server->rpc_ops = &nfs_v4_clientops;
+
+       nfs_init_timeout_values(&timeparms, data->proto, data->timeo, data->retrans);
+
+       server->retrans_timeo = timeparms.to_initval;
+       server->retrans_count = timeparms.to_retries;
+
+       /* Now create transport and client */
+       authflavour = RPC_AUTH_UNIX;
+       if (data->auth_flavourlen != 0) {
+               if (data->auth_flavourlen != 1) {
+                       dprintk("%s: Invalid number of RPC auth flavours %d.\n",
+                                       __FUNCTION__, data->auth_flavourlen);
+                       err = -EINVAL;
+                       goto out_fail;
+               }
+               if (copy_from_user(&authflavour, data->auth_flavours, sizeof(authflavour))) {
+                       err = -EFAULT;
+                       goto out_fail;
+               }
+       }
+
+       server->client = nfs4_create_client(server, &timeparms, data->proto, authflavour);
+       if (IS_ERR(server->client)) {
+               err = PTR_ERR(server->client);
+                       dprintk("%s: cannot create RPC client. Error = %d\n",
+                                       __FUNCTION__, err);
+                       goto out_fail;
+       }
+
+       sb->s_time_gran = 1;
+
+       sb->s_op = &nfs4_sops;
+       err = nfs_sb_init(sb, authflavour);
+
+ out_fail:
+       return err;
+}
+
+static int nfs4_compare_super(struct super_block *sb, void *data)
+{
+       struct nfs_server *server = data;
+       struct nfs_server *old = NFS_SB(sb);
+
+       if (strcmp(server->hostname, old->hostname) != 0)
+               return 0;
+       if (strcmp(server->mnt_path, old->mnt_path) != 0)
+               return 0;
+       return 1;
+}
+
+static void *
+nfs_copy_user_string(char *dst, struct nfs_string *src, int maxlen)
+{
+       void *p = NULL;
+
+       if (!src->len)
+               return ERR_PTR(-EINVAL);
+       if (src->len < maxlen)
+               maxlen = src->len;
+       if (dst == NULL) {
+               p = dst = kmalloc(maxlen + 1, GFP_KERNEL);
+               if (p == NULL)
+                       return ERR_PTR(-ENOMEM);
+       }
+       if (copy_from_user(dst, src->data, maxlen)) {
+               kfree(p);
+               return ERR_PTR(-EFAULT);
+       }
+       dst[maxlen] = '\0';
+       return dst;
+}
+
+static struct super_block *nfs4_get_sb(struct file_system_type *fs_type,
+       int flags, const char *dev_name, void *raw_data)
+{
+       int error;
+       struct nfs_server *server;
+       struct super_block *s;
+       struct nfs4_mount_data *data = raw_data;
+       void *p;
+
+       if (data == NULL) {
+               dprintk("%s: missing data argument\n", __FUNCTION__);
+               return ERR_PTR(-EINVAL);
+       }
+       if (data->version <= 0 || data->version > NFS4_MOUNT_VERSION) {
+               dprintk("%s: bad mount version\n", __FUNCTION__);
+               return ERR_PTR(-EINVAL);
+       }
+
+       server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL);
+       if (!server)
+               return ERR_PTR(-ENOMEM);
+       /* Zero out the NFS state stuff */
+       init_nfsv4_state(server);
+       server->client = server->client_sys = server->client_acl = ERR_PTR(-EINVAL);
+
+       p = nfs_copy_user_string(NULL, &data->hostname, 256);
+       if (IS_ERR(p))
+               goto out_err;
+       server->hostname = p;
+
+       p = nfs_copy_user_string(NULL, &data->mnt_path, 1024);
+       if (IS_ERR(p))
+               goto out_err;
+       server->mnt_path = p;
+
+       p = nfs_copy_user_string(server->ip_addr, &data->client_addr,
+                       sizeof(server->ip_addr) - 1);
+       if (IS_ERR(p))
+               goto out_err;
+
+       /* We now require that the mount process passes the remote address */
+       if (data->host_addrlen != sizeof(server->addr)) {
+               s = ERR_PTR(-EINVAL);
+               goto out_free;
+       }
+       if (copy_from_user(&server->addr, data->host_addr, sizeof(server->addr))) {
+               s = ERR_PTR(-EFAULT);
+               goto out_free;
+       }
+       if (server->addr.sin_family != AF_INET ||
+           server->addr.sin_addr.s_addr == INADDR_ANY) {
+               dprintk("%s: mount program didn't pass remote IP address!\n",
+                               __FUNCTION__);
+               s = ERR_PTR(-EINVAL);
+               goto out_free;
+       }
+
+       /* Fire up rpciod if not yet running */
+       s = ERR_PTR(rpciod_up());
+       if (IS_ERR(s)) {
+               dprintk("%s: couldn't start rpciod! Error = %ld\n",
+                               __FUNCTION__, PTR_ERR(s));
+               goto out_free;
+       }
+
+       s = sget(fs_type, nfs4_compare_super, nfs_set_super, server);
+
+       if (IS_ERR(s) || s->s_root)
+               goto out_free;
+
+       s->s_flags = flags;
+
+       error = nfs4_fill_super(s, data, flags & MS_SILENT ? 1 : 0);
+       if (error) {
+               up_write(&s->s_umount);
+               deactivate_super(s);
+               return ERR_PTR(error);
+       }
+       s->s_flags |= MS_ACTIVE;
+       return s;
+out_err:
+       s = (struct super_block *)p;
+out_free:
+       kfree(server->mnt_path);
+       kfree(server->hostname);
+       kfree(server);
+       return s;
+}
+
+static void nfs4_kill_super(struct super_block *sb)
+{
+       struct nfs_server *server = NFS_SB(sb);
+
+       nfs_return_all_delegations(sb);
+       kill_anon_super(sb);
+
+       nfs4_renewd_prepare_shutdown(server);
+
+       if (server->client != NULL && !IS_ERR(server->client))
+               rpc_shutdown_client(server->client);
+
+       destroy_nfsv4_state(server);
+
+       rpciod_down();
+
+       nfs_free_iostats(server->io_stats);
+       kfree(server->hostname);
+       kfree(server);
+       nfs_release_automount_timer();
+}
+
+/*
+ * Constructs the SERVER-side path
+ */
+static inline char *nfs4_dup_path(const struct dentry *dentry)
+{
+       char *page = (char *) __get_free_page(GFP_USER);
+       char *path;
+
+       path = nfs4_path(dentry, page, PAGE_SIZE);
+       if (!IS_ERR(path)) {
+               int len = PAGE_SIZE + page - path;
+               char *tmp = path;
+
+               path = kmalloc(len, GFP_KERNEL);
+               if (path)
+                       memcpy(path, tmp, len);
+               else
+                       path = ERR_PTR(-ENOMEM);
+       }
+       free_page((unsigned long)page);
+       return path;
+}
+
+static struct super_block *nfs4_clone_sb(struct nfs_server *server, struct nfs_clone_mount *data)
+{
+       const struct dentry *dentry = data->dentry;
+       struct nfs4_client *clp = server->nfs4_state;
+       struct super_block *sb;
+
+       server->fsid = data->fattr->fsid;
+       nfs_copy_fh(&server->fh, data->fh);
+       server->mnt_path = nfs4_dup_path(dentry);
+       if (IS_ERR(server->mnt_path)) {
+               sb = (struct super_block *)server->mnt_path;
+               goto err;
+       }
+       sb = sget(&nfs4_fs_type, nfs4_compare_super, nfs_set_super, server);
+       if (IS_ERR(sb) || sb->s_root)
+               goto free_path;
+       nfs4_server_capabilities(server, &server->fh);
+
+       down_write(&clp->cl_sem);
+       atomic_inc(&clp->cl_count);
+       list_add_tail(&server->nfs4_siblings, &clp->cl_superblocks);
+       up_write(&clp->cl_sem);
+       return sb;
+free_path:
+       kfree(server->mnt_path);
+err:
+       server->mnt_path = NULL;
+       return sb;
+}
+
+static struct super_block *nfs_clone_nfs4_sb(struct file_system_type *fs_type,
+               int flags, const char *dev_name, void *raw_data)
+{
+       struct nfs_clone_mount *data = raw_data;
+       return nfs_clone_generic_sb(data, nfs4_clone_sb, nfs_clone_server);
+}
+
+static struct super_block *nfs4_referral_sb(struct nfs_server *server, struct nfs_clone_mount *data)
+{
+       struct super_block *sb = ERR_PTR(-ENOMEM);
+       int len;
+
+       len = strlen(data->mnt_path) + 1;
+       server->mnt_path = kmalloc(len, GFP_KERNEL);
+       if (server->mnt_path == NULL)
+               goto err;
+       memcpy(server->mnt_path, data->mnt_path, len);
+       memcpy(&server->addr, data->addr, sizeof(struct sockaddr_in));
+
+       sb = sget(&nfs4_fs_type, nfs4_compare_super, nfs_set_super, server);
+       if (IS_ERR(sb) || sb->s_root)
+               goto free_path;
+       return sb;
+free_path:
+       kfree(server->mnt_path);
+err:
+       server->mnt_path = NULL;
+       return sb;
+}
+
+static struct nfs_server *nfs4_referral_server(struct super_block *sb, struct nfs_clone_mount *data)
+{
+       struct nfs_server *server = NFS_SB(sb);
+       struct rpc_timeout timeparms;
+       int proto, timeo, retrans;
+       void *err;
+
+       proto = IPPROTO_TCP;
+       /* Since we are following a referral and there may be alternatives,
+          set the timeouts and retries to low values */
+       timeo = 2;
+       retrans = 1;
+       nfs_init_timeout_values(&timeparms, proto, timeo, retrans);
+
+       server->client = nfs4_create_client(server, &timeparms, proto, data->authflavor);
+       if (IS_ERR((err = server->client)))
+               goto out_err;
+
+       sb->s_time_gran = 1;
+       sb->s_op = &nfs4_sops;
+       err = ERR_PTR(nfs_sb_init(sb, data->authflavor));
+       if (!IS_ERR(err))
+               return server;
+out_err:
+       return (struct nfs_server *)err;
+}
+
+static struct super_block *nfs_referral_nfs4_sb(struct file_system_type *fs_type,
+               int flags, const char *dev_name, void *raw_data)
+{
+       struct nfs_clone_mount *data = raw_data;
+       return nfs_clone_generic_sb(data, nfs4_referral_sb, nfs4_referral_server);
+}
+
+#endif
index e03abbd..b383fdd 100644 (file)
@@ -1529,7 +1529,7 @@ int nfs_sync_inode_wait(struct inode *inode, unsigned long idx_start,
        return ret;
 }
 
-int nfs_init_writepagecache(void)
+int __init nfs_init_writepagecache(void)
 {
        nfs_wdata_cachep = kmem_cache_create("nfs_write_data",
                                             sizeof(struct nfs_write_data),
@@ -1551,7 +1551,7 @@ int nfs_init_writepagecache(void)
        return 0;
 }
 
-void nfs_destroy_writepagecache(void)
+void __exit nfs_destroy_writepagecache(void)
 {
        mempool_destroy(nfs_commit_mempool);
        mempool_destroy(nfs_wdata_mempool);