1 files changed, 727 insertions, 8 deletions

diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index c08cab935ad5..dafba608c0a0 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -48,6 +48,7 @@
 
 static DEFINE_SPINLOCK(nfs_client_lock);
 static LIST_HEAD(nfs_client_list);
+static LIST_HEAD(nfs_volume_list);
 static DECLARE_WAIT_QUEUE_HEAD(nfs_client_active_wq);
 
 /*
@@ -268,9 +269,9 @@ struct nfs_client *nfs_find_client(const struct sockaddr_in *addr, int nfsversio
  * Look up a client by IP address and protocol version
  * - creates a new record if one doesn't yet exist
  */
-struct nfs_client *nfs_get_client(const char *hostname,
-                                  const struct sockaddr_in *addr,
-                                  int nfsversion)
+static struct nfs_client *nfs_get_client(const char *hostname,
+                                         const struct sockaddr_in *addr,
+                                         int nfsversion)
 {
         struct nfs_client *clp, *new = NULL;
         int error;
@@ -340,6 +341,8 @@ found_client:
                 return ERR_PTR(error);
         }
 
+        BUG_ON(clp->cl_cons_state != NFS_CS_READY);
+
         dprintk("--> nfs_get_client() = %p [share]\n", clp);
         return clp;
 }
@@ -347,7 +350,7 @@ found_client:
 /*
  * Mark a server as ready or failed
  */
-void nfs_mark_client_ready(struct nfs_client *clp, int state)
+static void nfs_mark_client_ready(struct nfs_client *clp, int state)
 {
         clp->cl_cons_state = state;
         wake_up_all(&nfs_client_active_wq);
@@ -389,10 +392,10 @@ static void nfs_init_timeout_values(struct rpc_timeout *to, int proto,
 /*
  * Create an RPC client handle
  */
-int nfs_create_rpc_client(struct nfs_client *clp, int proto,
-                          unsigned int timeo,
-                          unsigned int retrans,
-                          rpc_authflavor_t flavor)
+static int nfs_create_rpc_client(struct nfs_client *clp, int proto,
+                                                unsigned int timeo,
+                                                unsigned int retrans,
+                                                rpc_authflavor_t flavor)
 {
         struct rpc_timeout      timeparms;
         struct rpc_xprt         *xprt = NULL;
@@ -429,3 +432,719 @@ int nfs_create_rpc_client(struct nfs_client *clp, int proto,
         clp->cl_rpcclient = clnt;
         return 0;
 }
+
+/*
+ * Version 2 or 3 client destruction
+ */
+static void nfs_destroy_server(struct nfs_server *server)
+{
+        if (!IS_ERR(server->client_acl))
+                rpc_shutdown_client(server->client_acl);
+
+        if (!(server->flags & NFS_MOUNT_NONLM))
+                lockd_down();   /* release rpc.lockd */
+}
+
+/*
+ * Version 2 or 3 lockd setup
+ */
+static int nfs_start_lockd(struct nfs_server *server)
+{
+        int error = 0;
+
+        if (server->nfs_client->cl_nfsversion > 3)
+                goto out;
+        if (server->flags & NFS_MOUNT_NONLM)
+                goto out;
+        error = lockd_up();
+        if (error < 0)
+                server->flags |= NFS_MOUNT_NONLM;
+        else
+                server->destroy = nfs_destroy_server;
+out:
+        return error;
+}
+
+/*
+ * Initialise an NFSv3 ACL client connection
+ */
+#ifdef CONFIG_NFS_V3_ACL
+static void nfs_init_server_aclclient(struct nfs_server *server)
+{
+        if (server->nfs_client->cl_nfsversion != 3)
+                goto out_noacl;
+        if (server->flags & NFS_MOUNT_NOACL)
+                goto out_noacl;
+
+        server->client_acl = rpc_bind_new_program(server->client, &nfsacl_program, 3);
+        if (IS_ERR(server->client_acl))
+                goto out_noacl;
+
+        /* No errors! Assume that Sun nfsacls are supported */
+        server->caps |= NFS_CAP_ACLS;
+        return;
+
+out_noacl:
+        server->caps &= ~NFS_CAP_ACLS;
+}
+#else
+static inline void nfs_init_server_aclclient(struct nfs_server *server)
+{
+        server->flags &= ~NFS_MOUNT_NOACL;
+        server->caps &= ~NFS_CAP_ACLS;
+}
+#endif
+
+/*
+ * Create a general RPC client
+ */
+static int nfs_init_server_rpcclient(struct nfs_server *server, rpc_authflavor_t pseudoflavour)
+{
+        struct nfs_client *clp = server->nfs_client;
+
+        server->client = rpc_clone_client(clp->cl_rpcclient);
+        if (IS_ERR(server->client)) {
+                dprintk("%s: couldn't create rpc_client!\n", __FUNCTION__);
+                return PTR_ERR(server->client);
+        }
+
+        if (pseudoflavour != clp->cl_rpcclient->cl_auth->au_flavor) {
+                struct rpc_auth *auth;
+
+                auth = rpcauth_create(pseudoflavour, server->client);
+                if (IS_ERR(auth)) {
+                        dprintk("%s: couldn't create credcache!\n", __FUNCTION__);
+                        return PTR_ERR(auth);
+                }
+        }
+        server->client->cl_softrtry = 0;
+        if (server->flags & NFS_MOUNT_SOFT)
+                server->client->cl_softrtry = 1;
+
+        server->client->cl_intr = 0;
+        if (server->flags & NFS4_MOUNT_INTR)
+                server->client->cl_intr = 1;
+
+        return 0;
+}
+
+/*
+ * Initialise an NFS2 or NFS3 client
+ */
+static int nfs_init_client(struct nfs_client *clp, const struct nfs_mount_data *data)
+{
+        int proto = (data->flags & NFS_MOUNT_TCP) ? IPPROTO_TCP : IPPROTO_UDP;
+        int error;
+
+        if (clp->cl_cons_state == NFS_CS_READY) {
+                /* the client is already initialised */
+                dprintk("<-- nfs_init_client() = 0 [already %p]\n", clp);
+                return 0;
+        }
+
+        /* Check NFS protocol revision and initialize RPC op vector */
+        clp->rpc_ops = &nfs_v2_clientops;
+#ifdef CONFIG_NFS_V3
+        if (clp->cl_nfsversion == 3)
+                clp->rpc_ops = &nfs_v3_clientops;
+#endif
+        /*
+         * Create a client RPC handle for doing FSSTAT with UNIX auth only
+         * - RFC 2623, sec 2.3.2
+         */
+        error = nfs_create_rpc_client(clp, proto, data->timeo, data->retrans,
+                        RPC_AUTH_UNIX);
+        if (error < 0)
+                goto error;
+        nfs_mark_client_ready(clp, NFS_CS_READY);
+        return 0;
+
+error:
+        nfs_mark_client_ready(clp, error);
+        dprintk("<-- nfs_init_client() = xerror %d\n", error);
+        return error;
+}
+
+/*
+ * Create a version 2 or 3 client
+ */
+static int nfs_init_server(struct nfs_server *server, const struct nfs_mount_data *data)
+{
+        struct nfs_client *clp;
+        int error, nfsvers = 2;
+
+        dprintk("--> nfs_init_server()\n");
+
+#ifdef CONFIG_NFS_V3
+        if (data->flags & NFS_MOUNT_VER3)
+                nfsvers = 3;
+#endif
+
+        /* Allocate or find a client reference we can use */
+        clp = nfs_get_client(data->hostname, &data->addr, nfsvers);
+        if (IS_ERR(clp)) {
+                dprintk("<-- nfs_init_server() = error %ld\n", PTR_ERR(clp));
+                return PTR_ERR(clp);
+        }
+
+        error = nfs_init_client(clp, data);
+        if (error < 0)
+                goto error;
+
+        server->nfs_client = clp;
+
+        /* Initialise the client representation from the mount data */
+        server->flags = data->flags & NFS_MOUNT_FLAGMASK;
+
+        if (data->rsize)
+                server->rsize = nfs_block_size(data->rsize, NULL);
+        if (data->wsize)
+                server->wsize = nfs_block_size(data->wsize, NULL);
+
+        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 */
+        error = nfs_start_lockd(server);
+        if (error < 0)
+                goto error;
+
+        error = nfs_init_server_rpcclient(server, data->pseudoflavor);
+        if (error < 0)
+                goto error;
+
+        server->namelen  = data->namlen;
+        /* Create a client RPC handle for the NFSv3 ACL management interface */
+        nfs_init_server_aclclient(server);
+        if (clp->cl_nfsversion == 3) {
+                if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)
+                        server->namelen = NFS3_MAXNAMLEN;
+                server->caps |= NFS_CAP_READDIRPLUS;
+        } else {
+                if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)
+                        server->namelen = NFS2_MAXNAMLEN;
+        }
+
+        dprintk("<-- nfs_init_server() = 0 [new %p]\n", clp);
+        return 0;
+
+error:
+        server->nfs_client = NULL;
+        nfs_put_client(clp);
+        dprintk("<-- nfs_init_server() = xerror %d\n", error);
+        return error;
+}
+
+/*
+ * Load up the server record from information gained in an fsinfo record
+ */
+static void nfs_server_set_fsinfo(struct nfs_server *server, struct nfs_fsinfo *fsinfo)
+{
+        unsigned long max_rpc_payload;
+
+        /* 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;
+        server->backing_dev_info.ra_pages = server->rpages * NFS_MAX_READAHEAD;
+
+        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;
+        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;
+        }
+
+        server->maxfilesize = fsinfo->maxfilesize;
+
+        /* We're airborne Set socket buffersize */
+        rpc_setbufsize(server->client, server->wsize + 100, server->rsize + 100);
+}
+
+/*
+ * Probe filesystem information, including the FSID on v2/v3
+ */
+static int nfs_probe_fsinfo(struct nfs_server *server, struct nfs_fh *mntfh, struct nfs_fattr *fattr)
+{
+        struct nfs_fsinfo fsinfo;
+        struct nfs_client *clp = server->nfs_client;
+        int error;
+
+        dprintk("--> nfs_probe_fsinfo()\n");
+
+        if (clp->rpc_ops->set_capabilities != NULL) {
+                error = clp->rpc_ops->set_capabilities(server, mntfh);
+                if (error < 0)
+                        goto out_error;
+        }
+
+        fsinfo.fattr = fattr;
+        nfs_fattr_init(fattr);
+        error = clp->rpc_ops->fsinfo(server, mntfh, &fsinfo);
+        if (error < 0)
+                goto out_error;
+
+        nfs_server_set_fsinfo(server, &fsinfo);
+
+        /* Get some general file system info */
+        if (server->namelen == 0) {
+                struct nfs_pathconf pathinfo;
+
+                pathinfo.fattr = fattr;
+                nfs_fattr_init(fattr);
+
+                if (clp->rpc_ops->pathconf(server, mntfh, &pathinfo) >= 0)
+                        server->namelen = pathinfo.max_namelen;
+        }
+
+        dprintk("<-- nfs_probe_fsinfo() = 0\n");
+        return 0;
+
+out_error:
+        dprintk("nfs_probe_fsinfo: error = %d\n", -error);
+        return error;
+}
+
+/*
+ * Copy useful information when duplicating a server record
+ */
+static void nfs_server_copy_userdata(struct nfs_server *target, struct nfs_server *source)
+{
+        target->flags = source->flags;
+        target->acregmin = source->acregmin;
+        target->acregmax = source->acregmax;
+        target->acdirmin = source->acdirmin;
+        target->acdirmax = source->acdirmax;
+        target->caps = source->caps;
+}
+
+/*
+ * Allocate and initialise a server record
+ */
+static struct nfs_server *nfs_alloc_server(void)
+{
+        struct nfs_server *server;
+
+        server = kzalloc(sizeof(struct nfs_server), GFP_KERNEL);
+        if (!server)
+                return NULL;
+
+        server->client = server->client_acl = ERR_PTR(-EINVAL);
+
+        /* Zero out the NFS state stuff */
+        INIT_LIST_HEAD(&server->client_link);
+        INIT_LIST_HEAD(&server->master_link);
+
+        server->io_stats = nfs_alloc_iostats();
+        if (!server->io_stats) {
+                kfree(server);
+                return NULL;
+        }
+
+        return server;
+}
+
+/*
+ * Free up a server record
+ */
+void nfs_free_server(struct nfs_server *server)
+{
+        dprintk("--> nfs_free_server()\n");
+
+        spin_lock(&nfs_client_lock);
+        list_del(&server->client_link);
+        list_del(&server->master_link);
+        spin_unlock(&nfs_client_lock);
+
+        if (server->destroy != NULL)
+                server->destroy(server);
+        if (!IS_ERR(server->client))
+                rpc_shutdown_client(server->client);
+
+        nfs_put_client(server->nfs_client);
+
+        nfs_free_iostats(server->io_stats);
+        kfree(server);
+        nfs_release_automount_timer();
+        dprintk("<-- nfs_free_server()\n");
+}
+
+/*
+ * Create a version 2 or 3 volume record
+ * - keyed on server and FSID
+ */
+struct nfs_server *nfs_create_server(const struct nfs_mount_data *data,
+                                     struct nfs_fh *mntfh)
+{
+        struct nfs_server *server;
+        struct nfs_fattr fattr;
+        int error;
+
+        server = nfs_alloc_server();
+        if (!server)
+                return ERR_PTR(-ENOMEM);
+
+        /* Get a client representation */
+        error = nfs_init_server(server, data);
+        if (error < 0)
+                goto error;
+
+        BUG_ON(!server->nfs_client);
+        BUG_ON(!server->nfs_client->rpc_ops);
+        BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
+
+        /* Probe the root fh to retrieve its FSID */
+        error = nfs_probe_fsinfo(server, mntfh, &fattr);
+        if (error < 0)
+                goto error;
+        if (!(fattr.valid & NFS_ATTR_FATTR)) {
+                error = server->nfs_client->rpc_ops->getattr(server, mntfh, &fattr);
+                if (error < 0) {
+                        dprintk("nfs_create_server: getattr error = %d\n", -error);
+                        goto error;
+                }
+        }
+        memcpy(&server->fsid, &fattr.fsid, sizeof(server->fsid));
+
+        dprintk("Server FSID: %llx:%llx\n", server->fsid.major, server->fsid.minor);
+
+        BUG_ON(!server->nfs_client);
+        BUG_ON(!server->nfs_client->rpc_ops);
+        BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
+
+        spin_lock(&nfs_client_lock);
+        list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
+        list_add_tail(&server->master_link, &nfs_volume_list);
+        spin_unlock(&nfs_client_lock);
+
+        server->mount_time = jiffies;
+        return server;
+
+error:
+        nfs_free_server(server);
+        return ERR_PTR(error);
+}
+
+#ifdef CONFIG_NFS_V4
+/*
+ * Initialise an NFS4 client record
+ */
+static int nfs4_init_client(struct nfs_client *clp,
+                int proto, int timeo, int retrans,
+                rpc_authflavor_t authflavour)
+{
+        int error;
+
+        if (clp->cl_cons_state == NFS_CS_READY) {
+                /* the client is initialised already */
+                dprintk("<-- nfs4_init_client() = 0 [already %p]\n", clp);
+                return 0;
+        }
+
+        /* Check NFS protocol revision and initialize RPC op vector */
+        clp->rpc_ops = &nfs_v4_clientops;
+
+        error = nfs_create_rpc_client(clp, proto, timeo, retrans, authflavour);
+        if (error < 0)
+                goto error;
+
+        error = nfs_idmap_new(clp);
+        if (error < 0) {
+                dprintk("%s: failed to create idmapper. Error = %d\n",
+                        __FUNCTION__, error);
+                __set_bit(NFS_CS_IDMAP, &clp->cl_res_state);
+                goto error;
+        }
+
+        nfs_mark_client_ready(clp, NFS_CS_READY);
+        return 0;
+
+error:
+        nfs_mark_client_ready(clp, error);
+        dprintk("<-- nfs4_init_client() = xerror %d\n", error);
+        return error;
+}
+
+/*
+ * Set up an NFS4 client
+ */
+static int nfs4_set_client(struct nfs_server *server,
+                const char *hostname, const struct sockaddr_in *addr,
+                rpc_authflavor_t authflavour,
+                int proto, int timeo, int retrans)
+{
+        struct nfs_client *clp;
+        int error;
+
+        dprintk("--> nfs4_set_client()\n");
+
+        /* Allocate or find a client reference we can use */
+        clp = nfs_get_client(hostname, addr, 4);
+        if (IS_ERR(clp)) {
+                error = PTR_ERR(clp);
+                goto error;
+        }
+        error = nfs4_init_client(clp, proto, timeo, retrans, authflavour);
+        if (error < 0)
+                goto error_put;
+
+        server->nfs_client = clp;
+        dprintk("<-- nfs4_set_client() = 0 [new %p]\n", clp);
+        return 0;
+
+error_put:
+        nfs_put_client(clp);
+error:
+        dprintk("<-- nfs4_set_client() = xerror %d\n", error);
+        return error;
+}
+
+/*
+ * Create a version 4 volume record
+ */
+static int nfs4_init_server(struct nfs_server *server,
+                const struct nfs4_mount_data *data, rpc_authflavor_t authflavour)
+{
+        int error;
+
+        dprintk("--> nfs4_init_server()\n");
+
+        /* Initialise the client representation from the mount data */
+        server->flags = data->flags & NFS_MOUNT_FLAGMASK;
+        server->caps |= NFS_CAP_ATOMIC_OPEN;
+
+        if (data->rsize)
+                server->rsize = nfs_block_size(data->rsize, NULL);
+        if (data->wsize)
+                server->wsize = nfs_block_size(data->wsize, NULL);
+
+        server->acregmin = data->acregmin * HZ;
+        server->acregmax = data->acregmax * HZ;
+        server->acdirmin = data->acdirmin * HZ;
+        server->acdirmax = data->acdirmax * HZ;
+
+        error = nfs_init_server_rpcclient(server, authflavour);
+
+        /* Done */
+        dprintk("<-- nfs4_init_server() = %d\n", error);
+        return error;
+}
+
+/*
+ * Create a version 4 volume record
+ * - keyed on server and FSID
+ */
+struct nfs_server *nfs4_create_server(const struct nfs4_mount_data *data,
+                                      const char *hostname,
+                                      const struct sockaddr_in *addr,
+                                      const char *mntpath,
+                                      const char *ip_addr,
+                                      rpc_authflavor_t authflavour,
+                                      struct nfs_fh *mntfh)
+{
+        struct nfs_fattr fattr;
+        struct nfs_server *server;
+        int error;
+
+        dprintk("--> nfs4_create_server()\n");
+
+        server = nfs_alloc_server();
+        if (!server)
+                return ERR_PTR(-ENOMEM);
+
+        /* Get a client record */
+        error = nfs4_set_client(server, hostname, addr, authflavour,
+                        data->proto, data->timeo, data->retrans);
+        if (error < 0)
+                goto error;
+
+        /* set up the general RPC client */
+        error = nfs4_init_server(server, data, authflavour);
+        if (error < 0)
+                goto error;
+
+        BUG_ON(!server->nfs_client);
+        BUG_ON(!server->nfs_client->rpc_ops);
+        BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
+
+        /* Probe the root fh to retrieve its FSID */
+        error = nfs4_path_walk(server, mntfh, mntpath);
+        if (error < 0)
+                goto error;
+
+        dprintk("Server FSID: %llx:%llx\n", server->fsid.major, server->fsid.minor);
+        dprintk("Mount FH: %d\n", mntfh->size);
+
+        error = nfs_probe_fsinfo(server, mntfh, &fattr);
+        if (error < 0)
+                goto error;
+
+        BUG_ON(!server->nfs_client);
+        BUG_ON(!server->nfs_client->rpc_ops);
+        BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
+
+        spin_lock(&nfs_client_lock);
+        list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
+        list_add_tail(&server->master_link, &nfs_volume_list);
+        spin_unlock(&nfs_client_lock);
+
+        server->mount_time = jiffies;
+        dprintk("<-- nfs4_create_server() = %p\n", server);
+        return server;
+
+error:
+        nfs_free_server(server);
+        dprintk("<-- nfs4_create_server() = error %d\n", error);
+        return ERR_PTR(error);
+}
+
+/*
+ * Create an NFS4 referral server record
+ */
+struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data,
+                                               struct nfs_fh *fh)
+{
+        struct nfs_client *parent_client;
+        struct nfs_server *server, *parent_server;
+        struct nfs_fattr fattr;
+        int error;
+
+        dprintk("--> nfs4_create_referral_server()\n");
+
+        server = nfs_alloc_server();
+        if (!server)
+                return ERR_PTR(-ENOMEM);
+
+        parent_server = NFS_SB(data->sb);
+        parent_client = parent_server->nfs_client;
+
+        /* Get a client representation.
+         * Note: NFSv4 always uses TCP, */
+        error = nfs4_set_client(server, data->hostname, data->addr,
+                        data->authflavor,
+                        parent_server->client->cl_xprt->prot,
+                        parent_client->retrans_timeo,
+                        parent_client->retrans_count);
+
+        /* Initialise the client representation from the parent server */
+        nfs_server_copy_userdata(server, parent_server);
+        server->caps |= NFS_CAP_ATOMIC_OPEN;
+
+        error = nfs_init_server_rpcclient(server, data->authflavor);
+        if (error < 0)
+                goto error;
+
+        BUG_ON(!server->nfs_client);
+        BUG_ON(!server->nfs_client->rpc_ops);
+        BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
+
+        /* probe the filesystem info for this server filesystem */
+        error = nfs_probe_fsinfo(server, fh, &fattr);
+        if (error < 0)
+                goto error;
+
+        dprintk("Referral FSID: %llx:%llx\n",
+                server->fsid.major, server->fsid.minor);
+
+        spin_lock(&nfs_client_lock);
+        list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
+        list_add_tail(&server->master_link, &nfs_volume_list);
+        spin_unlock(&nfs_client_lock);
+
+        server->mount_time = jiffies;
+
+        dprintk("<-- nfs_create_referral_server() = %p\n", server);
+        return server;
+
+error:
+        nfs_free_server(server);
+        dprintk("<-- nfs4_create_referral_server() = error %d\n", error);
+        return ERR_PTR(error);
+}
+
+#endif /* CONFIG_NFS_V4 */
+
+/*
+ * Clone an NFS2, NFS3 or NFS4 server record
+ */
+struct nfs_server *nfs_clone_server(struct nfs_server *source,
+                                    struct nfs_fh *fh,
+                                    struct nfs_fattr *fattr)
+{
+        struct nfs_server *server;
+        struct nfs_fattr fattr_fsinfo;
+        int error;
+
+        dprintk("--> nfs_clone_server(,%llx:%llx,)\n",
+                fattr->fsid.major, fattr->fsid.minor);
+
+        server = nfs_alloc_server();
+        if (!server)
+                return ERR_PTR(-ENOMEM);
+
+        /* Copy data from the source */
+        server->nfs_client = source->nfs_client;
+        atomic_inc(&server->nfs_client->cl_count);
+        nfs_server_copy_userdata(server, source);
+
+        server->fsid = fattr->fsid;
+
+        error = nfs_init_server_rpcclient(server, source->client->cl_auth->au_flavor);
+        if (error < 0)
+                goto out_free_server;
+        if (!IS_ERR(source->client_acl))
+                nfs_init_server_aclclient(server);
+
+        /* probe the filesystem info for this server filesystem */
+        error = nfs_probe_fsinfo(server, fh, &fattr_fsinfo);
+        if (error < 0)
+                goto out_free_server;
+
+        dprintk("Cloned FSID: %llx:%llx\n",
+                server->fsid.major, server->fsid.minor);
+
+        error = nfs_start_lockd(server);
+        if (error < 0)
+                goto out_free_server;
+
+        spin_lock(&nfs_client_lock);
+        list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
+        list_add_tail(&server->master_link, &nfs_volume_list);
+        spin_unlock(&nfs_client_lock);
+
+        server->mount_time = jiffies;
+
+        dprintk("<-- nfs_clone_server() = %p\n", server);
+        return server;
+
+out_free_server:
+        nfs_free_server(server);
+        dprintk("<-- nfs_clone_server() = error %d\n", error);
+        return ERR_PTR(error);
+}