Merge tag 'nfs-for-3.4-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs

Pull NFS client updates for Linux 3.4 from Trond Myklebust:
 "New features include:
   - Add NFS client support for containers.

     This should enable most of the necessary functionality, including
     lockd support, and support for rpc.statd, NFSv4 idmapper and
     RPCSEC_GSS upcalls into the correct network namespace from which
     the mount system call was issued.

   - NFSv4 idmapper scalability improvements

     Base the idmapper cache on the keyring interface to allow
     concurrent access to idmapper entries.  Start the process of
     migrating users from the single-threaded daemon-based approach to
     the multi-threaded request-key based approach.

   - NFSv4.1 implementation id.

     Allows the NFSv4.1 client and server to mutually identify each
     other for logging and debugging purposes.

   - Support the 'vers=4.1' mount option for mounting NFSv4.1 instead of
     having to use the more counterintuitive 'vers=4,minorversion=1'.

   - SUNRPC tracepoints.

     Start the process of adding tracepoints in order to improve
     debugging of the RPC layer.

   - pNFS object layout support for autologin.

  Important bugfixes include:

   - Fix a bug in rpc_wake_up/rpc_wake_up_status that caused them to
     fail to wake up all tasks when applied to priority waitqueues.

   - Ensure that we handle read delegations correctly, when we try to
     truncate a file.

   - A number of fixes for NFSv4 state manager loops (mostly to do with
     delegation recovery)."

* tag 'nfs-for-3.4-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs: (224 commits)
  NFS: fix sb->s_id in nfs debug prints
  xprtrdma: Remove assumption that each segment is <= PAGE_SIZE
  xprtrdma: The transport should not bug-check when a dup reply is received
  pnfs-obj: autologin: Add support for protocol autologin
  NFS: Remove nfs4_setup_sequence from generic rename code
  NFS: Remove nfs4_setup_sequence from generic unlink code
  NFS: Remove nfs4_setup_sequence from generic read code
  NFS: Remove nfs4_setup_sequence from generic write code
  NFS: Fix more NFS debug related build warnings
  SUNRPC/LOCKD: Fix build warnings when CONFIG_SUNRPC_DEBUG is undefined
  nfs: non void functions must return a value
  SUNRPC: Kill compiler warning when RPC_DEBUG is unset
  SUNRPC/NFS: Add Kbuild dependencies for NFS_DEBUG/RPC_DEBUG
  NFS: Use cond_resched_lock() to reduce latencies in the commit scans
  NFSv4: It is not safe to dereference lsp->ls_state in release_lockowner
  NFS: ncommit count is being double decremented
  SUNRPC: We must not use list_for_each_entry_safe() in rpc_wake_up()
  Try using machine credentials for RENEW calls
  NFSv4.1: Fix a few issues in filelayout_commit_pagelist
  NFSv4.1: Clean ups and bugfixes for the pNFS read/writeback/commit code
  ...

5 files changed, 276 insertions, 116 deletions

diff --git a/net/sunrpc/auth_gss/auth_gss.c b/net/sunrpc/auth_gss/auth_gss.c
index affa631ac1ab..d3ad81f8da5b 100644
--- a/net/sunrpc/auth_gss/auth_gss.c
+++ b/net/sunrpc/auth_gss/auth_gss.c
@@ -81,7 +81,7 @@ struct gss_auth {
          * mechanism (for example, "krb5") and exists for
          * backwards-compatibility with older gssd's.
          */
-        struct dentry *dentry[2];
+        struct rpc_pipe *pipe[2];
 };
 
 /* pipe_version >= 0 if and only if someone has a pipe open. */
@@ -112,7 +112,7 @@ gss_put_ctx(struct gss_cl_ctx *ctx)
 /* gss_cred_set_ctx:
  * called by gss_upcall_callback and gss_create_upcall in order
  * to set the gss context. The actual exchange of an old context
- * and a new one is protected by the inode->i_lock.
+ * and a new one is protected by the pipe->lock.
  */
 static void
 gss_cred_set_ctx(struct rpc_cred *cred, struct gss_cl_ctx *ctx)
@@ -251,7 +251,7 @@ struct gss_upcall_msg {
         struct rpc_pipe_msg msg;
         struct list_head list;
         struct gss_auth *auth;
-        struct rpc_inode *inode;
+        struct rpc_pipe *pipe;
         struct rpc_wait_queue rpc_waitqueue;
         wait_queue_head_t waitqueue;
         struct gss_cl_ctx *ctx;
@@ -294,10 +294,10 @@ gss_release_msg(struct gss_upcall_msg *gss_msg)
 }
 
 static struct gss_upcall_msg *
-__gss_find_upcall(struct rpc_inode *rpci, uid_t uid)
+__gss_find_upcall(struct rpc_pipe *pipe, uid_t uid)
 {
         struct gss_upcall_msg *pos;
-        list_for_each_entry(pos, &rpci->in_downcall, list) {
+        list_for_each_entry(pos, &pipe->in_downcall, list) {
                 if (pos->uid != uid)
                         continue;
                 atomic_inc(&pos->count);
@@ -315,18 +315,17 @@ __gss_find_upcall(struct rpc_inode *rpci, uid_t uid)
 static inline struct gss_upcall_msg *
 gss_add_msg(struct gss_upcall_msg *gss_msg)
 {
-        struct rpc_inode *rpci = gss_msg->inode;
-        struct inode *inode = &rpci->vfs_inode;
+        struct rpc_pipe *pipe = gss_msg->pipe;
         struct gss_upcall_msg *old;
 
-        spin_lock(&inode->i_lock);
-        old = __gss_find_upcall(rpci, gss_msg->uid);
+        spin_lock(&pipe->lock);
+        old = __gss_find_upcall(pipe, gss_msg->uid);
         if (old == NULL) {
                 atomic_inc(&gss_msg->count);
-                list_add(&gss_msg->list, &rpci->in_downcall);
+                list_add(&gss_msg->list, &pipe->in_downcall);
         } else
                 gss_msg = old;
-        spin_unlock(&inode->i_lock);
+        spin_unlock(&pipe->lock);
         return gss_msg;
 }
 
@@ -342,14 +341,14 @@ __gss_unhash_msg(struct gss_upcall_msg *gss_msg)
 static void
 gss_unhash_msg(struct gss_upcall_msg *gss_msg)
 {
-        struct inode *inode = &gss_msg->inode->vfs_inode;
+        struct rpc_pipe *pipe = gss_msg->pipe;
 
         if (list_empty(&gss_msg->list))
                 return;
-        spin_lock(&inode->i_lock);
+        spin_lock(&pipe->lock);
         if (!list_empty(&gss_msg->list))
                 __gss_unhash_msg(gss_msg);
-        spin_unlock(&inode->i_lock);
+        spin_unlock(&pipe->lock);
 }
 
 static void
@@ -376,11 +375,11 @@ gss_upcall_callback(struct rpc_task *task)
         struct gss_cred *gss_cred = container_of(task->tk_rqstp->rq_cred,
                         struct gss_cred, gc_base);
         struct gss_upcall_msg *gss_msg = gss_cred->gc_upcall;
-        struct inode *inode = &gss_msg->inode->vfs_inode;
+        struct rpc_pipe *pipe = gss_msg->pipe;
 
-        spin_lock(&inode->i_lock);
+        spin_lock(&pipe->lock);
         gss_handle_downcall_result(gss_cred, gss_msg);
-        spin_unlock(&inode->i_lock);
+        spin_unlock(&pipe->lock);
         task->tk_status = gss_msg->msg.errno;
         gss_release_msg(gss_msg);
 }
@@ -450,7 +449,7 @@ gss_alloc_msg(struct gss_auth *gss_auth, struct rpc_clnt *clnt,
                 kfree(gss_msg);
                 return ERR_PTR(vers);
         }
-        gss_msg->inode = RPC_I(gss_auth->dentry[vers]->d_inode);
+        gss_msg->pipe = gss_auth->pipe[vers];
         INIT_LIST_HEAD(&gss_msg->list);
         rpc_init_wait_queue(&gss_msg->rpc_waitqueue, "RPCSEC_GSS upcall waitq");
         init_waitqueue_head(&gss_msg->waitqueue);
@@ -474,8 +473,7 @@ gss_setup_upcall(struct rpc_clnt *clnt, struct gss_auth *gss_auth, struct rpc_cr
                 return gss_new;
         gss_msg = gss_add_msg(gss_new);
         if (gss_msg == gss_new) {
-                struct inode *inode = &gss_new->inode->vfs_inode;
-                int res = rpc_queue_upcall(inode, &gss_new->msg);
+                int res = rpc_queue_upcall(gss_new->pipe, &gss_new->msg);
                 if (res) {
                         gss_unhash_msg(gss_new);
                         gss_msg = ERR_PTR(res);
@@ -506,7 +504,7 @@ gss_refresh_upcall(struct rpc_task *task)
         struct gss_cred *gss_cred = container_of(cred,
                         struct gss_cred, gc_base);
         struct gss_upcall_msg *gss_msg;
-        struct inode *inode;
+        struct rpc_pipe *pipe;
         int err = 0;
 
         dprintk("RPC: %5u gss_refresh_upcall for uid %u\n", task->tk_pid,
@@ -524,8 +522,8 @@ gss_refresh_upcall(struct rpc_task *task)
                 err = PTR_ERR(gss_msg);
                 goto out;
         }
-        inode = &gss_msg->inode->vfs_inode;
-        spin_lock(&inode->i_lock);
+        pipe = gss_msg->pipe;
+        spin_lock(&pipe->lock);
         if (gss_cred->gc_upcall != NULL)
                 rpc_sleep_on(&gss_cred->gc_upcall->rpc_waitqueue, task, NULL);
         else if (gss_msg->ctx == NULL && gss_msg->msg.errno >= 0) {
@@ -538,7 +536,7 @@ gss_refresh_upcall(struct rpc_task *task)
                 gss_handle_downcall_result(gss_cred, gss_msg);
                 err = gss_msg->msg.errno;
         }
-        spin_unlock(&inode->i_lock);
+        spin_unlock(&pipe->lock);
         gss_release_msg(gss_msg);
 out:
         dprintk("RPC: %5u gss_refresh_upcall for uid %u result %d\n",
@@ -549,7 +547,7 @@ out:
 static inline int
 gss_create_upcall(struct gss_auth *gss_auth, struct gss_cred *gss_cred)
 {
-        struct inode *inode;
+        struct rpc_pipe *pipe;
         struct rpc_cred *cred = &gss_cred->gc_base;
         struct gss_upcall_msg *gss_msg;
         DEFINE_WAIT(wait);
@@ -573,14 +571,14 @@ retry:
                 err = PTR_ERR(gss_msg);
                 goto out;
         }
-        inode = &gss_msg->inode->vfs_inode;
+        pipe = gss_msg->pipe;
         for (;;) {
                 prepare_to_wait(&gss_msg->waitqueue, &wait, TASK_KILLABLE);
-                spin_lock(&inode->i_lock);
+                spin_lock(&pipe->lock);
                 if (gss_msg->ctx != NULL || gss_msg->msg.errno < 0) {
                         break;
                 }
-                spin_unlock(&inode->i_lock);
+                spin_unlock(&pipe->lock);
                 if (fatal_signal_pending(current)) {
                         err = -ERESTARTSYS;
                         goto out_intr;
@@ -591,7 +589,7 @@ retry:
                 gss_cred_set_ctx(cred, gss_msg->ctx);
         else
                 err = gss_msg->msg.errno;
-        spin_unlock(&inode->i_lock);
+        spin_unlock(&pipe->lock);
 out_intr:
         finish_wait(&gss_msg->waitqueue, &wait);
         gss_release_msg(gss_msg);
@@ -609,7 +607,7 @@ gss_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
         const void *p, *end;
         void *buf;
         struct gss_upcall_msg *gss_msg;
-        struct inode *inode = filp->f_path.dentry->d_inode;
+        struct rpc_pipe *pipe = RPC_I(filp->f_dentry->d_inode)->pipe;
         struct gss_cl_ctx *ctx;
         uid_t uid;
         ssize_t err = -EFBIG;
@@ -639,14 +637,14 @@ gss_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
 
         err = -ENOENT;
         /* Find a matching upcall */
-        spin_lock(&inode->i_lock);
-        gss_msg = __gss_find_upcall(RPC_I(inode), uid);
+        spin_lock(&pipe->lock);
+        gss_msg = __gss_find_upcall(pipe, uid);
         if (gss_msg == NULL) {
-                spin_unlock(&inode->i_lock);
+                spin_unlock(&pipe->lock);
                 goto err_put_ctx;
         }
         list_del_init(&gss_msg->list);
-        spin_unlock(&inode->i_lock);
+        spin_unlock(&pipe->lock);
 
         p = gss_fill_context(p, end, ctx, gss_msg->auth->mech);
         if (IS_ERR(p)) {
@@ -674,9 +672,9 @@ gss_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
         err = mlen;
 
 err_release_msg:
-        spin_lock(&inode->i_lock);
+        spin_lock(&pipe->lock);
         __gss_unhash_msg(gss_msg);
-        spin_unlock(&inode->i_lock);
+        spin_unlock(&pipe->lock);
         gss_release_msg(gss_msg);
 err_put_ctx:
         gss_put_ctx(ctx);
@@ -722,23 +720,23 @@ static int gss_pipe_open_v1(struct inode *inode)
 static void
 gss_pipe_release(struct inode *inode)
 {
-        struct rpc_inode *rpci = RPC_I(inode);
+        struct rpc_pipe *pipe = RPC_I(inode)->pipe;
         struct gss_upcall_msg *gss_msg;
 
 restart:
-        spin_lock(&inode->i_lock);
-        list_for_each_entry(gss_msg, &rpci->in_downcall, list) {
+        spin_lock(&pipe->lock);
+        list_for_each_entry(gss_msg, &pipe->in_downcall, list) {
 
                 if (!list_empty(&gss_msg->msg.list))
                         continue;
                 gss_msg->msg.errno = -EPIPE;
                 atomic_inc(&gss_msg->count);
                 __gss_unhash_msg(gss_msg);
-                spin_unlock(&inode->i_lock);
+                spin_unlock(&pipe->lock);
                 gss_release_msg(gss_msg);
                 goto restart;
         }
-        spin_unlock(&inode->i_lock);
+        spin_unlock(&pipe->lock);
 
         put_pipe_version();
 }
@@ -759,6 +757,75 @@ gss_pipe_destroy_msg(struct rpc_pipe_msg *msg)
         }
 }
 
+static void gss_pipes_dentries_destroy(struct rpc_auth *auth)
+{
+        struct gss_auth *gss_auth;
+
+        gss_auth = container_of(auth, struct gss_auth, rpc_auth);
+        if (gss_auth->pipe[0]->dentry)
+                rpc_unlink(gss_auth->pipe[0]->dentry);
+        if (gss_auth->pipe[1]->dentry)
+                rpc_unlink(gss_auth->pipe[1]->dentry);
+}
+
+static int gss_pipes_dentries_create(struct rpc_auth *auth)
+{
+        int err;
+        struct gss_auth *gss_auth;
+        struct rpc_clnt *clnt;
+
+        gss_auth = container_of(auth, struct gss_auth, rpc_auth);
+        clnt = gss_auth->client;
+
+        gss_auth->pipe[1]->dentry = rpc_mkpipe_dentry(clnt->cl_dentry,
+                                                      "gssd",
+                                                      clnt, gss_auth->pipe[1]);
+        if (IS_ERR(gss_auth->pipe[1]->dentry))
+                return PTR_ERR(gss_auth->pipe[1]->dentry);
+        gss_auth->pipe[0]->dentry = rpc_mkpipe_dentry(clnt->cl_dentry,
+                                                      gss_auth->mech->gm_name,
+                                                      clnt, gss_auth->pipe[0]);
+        if (IS_ERR(gss_auth->pipe[0]->dentry)) {
+                err = PTR_ERR(gss_auth->pipe[0]->dentry);
+                goto err_unlink_pipe_1;
+        }
+        return 0;
+
+err_unlink_pipe_1:
+        rpc_unlink(gss_auth->pipe[1]->dentry);
+        return err;
+}
+
+static void gss_pipes_dentries_destroy_net(struct rpc_clnt *clnt,
+                                           struct rpc_auth *auth)
+{
+        struct net *net = rpc_net_ns(clnt);
+        struct super_block *sb;
+
+        sb = rpc_get_sb_net(net);
+        if (sb) {
+                if (clnt->cl_dentry)
+                        gss_pipes_dentries_destroy(auth);
+                rpc_put_sb_net(net);
+        }
+}
+
+static int gss_pipes_dentries_create_net(struct rpc_clnt *clnt,
+                                         struct rpc_auth *auth)
+{
+        struct net *net = rpc_net_ns(clnt);
+        struct super_block *sb;
+        int err = 0;
+
+        sb = rpc_get_sb_net(net);
+        if (sb) {
+                if (clnt->cl_dentry)
+                        err = gss_pipes_dentries_create(auth);
+                rpc_put_sb_net(net);
+        }
+        return err;
+}
+
 /*
  * NOTE: we have the opportunity to use different
  * parameters based on the input flavor (which must be a pseudoflavor)
@@ -801,32 +868,33 @@ gss_create(struct rpc_clnt *clnt, rpc_authflavor_t flavor)
          * that we supported only the old pipe.  So we instead create
          * the new pipe first.
          */
-        gss_auth->dentry[1] = rpc_mkpipe(clnt->cl_path.dentry,
-                                         "gssd",
-                                         clnt, &gss_upcall_ops_v1,
-                                         RPC_PIPE_WAIT_FOR_OPEN);
-        if (IS_ERR(gss_auth->dentry[1])) {
-                err = PTR_ERR(gss_auth->dentry[1]);
+        gss_auth->pipe[1] = rpc_mkpipe_data(&gss_upcall_ops_v1,
+                                            RPC_PIPE_WAIT_FOR_OPEN);
+        if (IS_ERR(gss_auth->pipe[1])) {
+                err = PTR_ERR(gss_auth->pipe[1]);
                 goto err_put_mech;
         }
 
-        gss_auth->dentry[0] = rpc_mkpipe(clnt->cl_path.dentry,
-                                         gss_auth->mech->gm_name,
-                                         clnt, &gss_upcall_ops_v0,
-                                         RPC_PIPE_WAIT_FOR_OPEN);
-        if (IS_ERR(gss_auth->dentry[0])) {
-                err = PTR_ERR(gss_auth->dentry[0]);
-                goto err_unlink_pipe_1;
+        gss_auth->pipe[0] = rpc_mkpipe_data(&gss_upcall_ops_v0,
+                                            RPC_PIPE_WAIT_FOR_OPEN);
+        if (IS_ERR(gss_auth->pipe[0])) {
+                err = PTR_ERR(gss_auth->pipe[0]);
+                goto err_destroy_pipe_1;
         }
+        err = gss_pipes_dentries_create_net(clnt, auth);
+        if (err)
+                goto err_destroy_pipe_0;
         err = rpcauth_init_credcache(auth);
         if (err)
-                goto err_unlink_pipe_0;
+                goto err_unlink_pipes;
 
         return auth;
-err_unlink_pipe_0:
-        rpc_unlink(gss_auth->dentry[0]);
-err_unlink_pipe_1:
-        rpc_unlink(gss_auth->dentry[1]);
+err_unlink_pipes:
+        gss_pipes_dentries_destroy_net(clnt, auth);
+err_destroy_pipe_0:
+        rpc_destroy_pipe_data(gss_auth->pipe[0]);
+err_destroy_pipe_1:
+        rpc_destroy_pipe_data(gss_auth->pipe[1]);
 err_put_mech:
         gss_mech_put(gss_auth->mech);
 err_free:
@@ -839,8 +907,9 @@ out_dec:
 static void
 gss_free(struct gss_auth *gss_auth)
 {
-        rpc_unlink(gss_auth->dentry[1]);
-        rpc_unlink(gss_auth->dentry[0]);
+        gss_pipes_dentries_destroy_net(gss_auth->client, &gss_auth->rpc_auth);
+        rpc_destroy_pipe_data(gss_auth->pipe[0]);
+        rpc_destroy_pipe_data(gss_auth->pipe[1]);
         gss_mech_put(gss_auth->mech);
 
         kfree(gss_auth);
@@ -1547,7 +1616,9 @@ static const struct rpc_authops authgss_ops = {
         .create         = gss_create,
         .destroy        = gss_destroy,
         .lookup_cred    = gss_lookup_cred,
-        .crcreate       = gss_create_cred
+        .crcreate       = gss_create_cred,
+        .pipes_create   = gss_pipes_dentries_create,
+        .pipes_destroy  = gss_pipes_dentries_destroy,
 };
 
 static const struct rpc_credops gss_credops = {
@@ -1591,6 +1662,21 @@ static const struct rpc_pipe_ops gss_upcall_ops_v1 = {
         .release_pipe   = gss_pipe_release,
 };
 
+static __net_init int rpcsec_gss_init_net(struct net *net)
+{
+        return gss_svc_init_net(net);
+}
+
+static __net_exit void rpcsec_gss_exit_net(struct net *net)
+{
+        gss_svc_shutdown_net(net);
+}
+
+static struct pernet_operations rpcsec_gss_net_ops = {
+        .init = rpcsec_gss_init_net,
+        .exit = rpcsec_gss_exit_net,
+};
+
 /*
  * Initialize RPCSEC_GSS module
  */
@@ -1604,8 +1690,13 @@ static int __init init_rpcsec_gss(void)
         err = gss_svc_init();
         if (err)
                 goto out_unregister;
+        err = register_pernet_subsys(&rpcsec_gss_net_ops);
+        if (err)
+                goto out_svc_exit;
         rpc_init_wait_queue(&pipe_version_rpc_waitqueue, "gss pipe version");
         return 0;
+out_svc_exit:
+        gss_svc_shutdown();
 out_unregister:
         rpcauth_unregister(&authgss_ops);
 out:
@@ -1614,6 +1705,7 @@ out:
 
 static void __exit exit_rpcsec_gss(void)
 {
+        unregister_pernet_subsys(&rpcsec_gss_net_ops);
         gss_svc_shutdown();
         rpcauth_unregister(&authgss_ops);
         rcu_barrier(); /* Wait for completion of call_rcu()'s */
diff --git a/net/sunrpc/auth_gss/gss_krb5_crypto.c b/net/sunrpc/auth_gss/gss_krb5_crypto.c
index 9576f35ab701..0f43e894bc0a 100644
--- a/net/sunrpc/auth_gss/gss_krb5_crypto.c
+++ b/net/sunrpc/auth_gss/gss_krb5_crypto.c
@@ -600,11 +600,14 @@ gss_krb5_cts_crypt(struct crypto_blkcipher *cipher, struct xdr_buf *buf,
         u32 ret;
         struct scatterlist sg[1];
         struct blkcipher_desc desc = { .tfm = cipher, .info = iv };
-        u8 data[crypto_blkcipher_blocksize(cipher) * 2];
+        u8 data[GSS_KRB5_MAX_BLOCKSIZE * 2];
         struct page **save_pages;
         u32 len = buf->len - offset;
 
-        BUG_ON(len > crypto_blkcipher_blocksize(cipher) * 2);
+        if (len > ARRAY_SIZE(data)) {
+                WARN_ON(0);
+                return -ENOMEM;
+        }
 
         /*
          * For encryption, we want to read from the cleartext
diff --git a/net/sunrpc/auth_gss/gss_krb5_mech.c b/net/sunrpc/auth_gss/gss_krb5_mech.c
index 8c67890de427..8eff8c32d1b9 100644
--- a/net/sunrpc/auth_gss/gss_krb5_mech.c
+++ b/net/sunrpc/auth_gss/gss_krb5_mech.c
@@ -344,7 +344,7 @@ out_err:
         return PTR_ERR(p);
 }
 
-struct crypto_blkcipher *
+static struct crypto_blkcipher *
 context_v2_alloc_cipher(struct krb5_ctx *ctx, const char *cname, u8 *key)
 {
         struct crypto_blkcipher *cp;
diff --git a/net/sunrpc/auth_gss/gss_krb5_seal.c b/net/sunrpc/auth_gss/gss_krb5_seal.c
index d7941eab7796..62ae3273186c 100644
--- a/net/sunrpc/auth_gss/gss_krb5_seal.c
+++ b/net/sunrpc/auth_gss/gss_krb5_seal.c
@@ -159,7 +159,7 @@ gss_get_mic_v1(struct krb5_ctx *ctx, struct xdr_buf *text,
         return (ctx->endtime < now) ? GSS_S_CONTEXT_EXPIRED : GSS_S_COMPLETE;
 }
 
-u32
+static u32
 gss_get_mic_v2(struct krb5_ctx *ctx, struct xdr_buf *text,
                 struct xdr_netobj *token)
 {
diff --git a/net/sunrpc/auth_gss/svcauth_gss.c b/net/sunrpc/auth_gss/svcauth_gss.c
index 8d0f7d3c71c8..1600cfb1618c 100644
--- a/net/sunrpc/auth_gss/svcauth_gss.c
+++ b/net/sunrpc/auth_gss/svcauth_gss.c
@@ -48,6 +48,8 @@
 #include <linux/sunrpc/svcauth_gss.h>
 #include <linux/sunrpc/cache.h>
 
+#include "../netns.h"
+
 #ifdef RPC_DEBUG
 # define RPCDBG_FACILITY        RPCDBG_AUTH
 #endif
@@ -75,10 +77,8 @@ struct rsi {
         int                     major_status, minor_status;
 };
 
-static struct cache_head *rsi_table[RSI_HASHMAX];
-static struct cache_detail rsi_cache;
-static struct rsi *rsi_update(struct rsi *new, struct rsi *old);
-static struct rsi *rsi_lookup(struct rsi *item);
+static struct rsi *rsi_update(struct cache_detail *cd, struct rsi *new, struct rsi *old);
+static struct rsi *rsi_lookup(struct cache_detail *cd, struct rsi *item);
 
 static void rsi_free(struct rsi *rsii)
 {
@@ -216,7 +216,7 @@ static int rsi_parse(struct cache_detail *cd,
         if (dup_to_netobj(&rsii.in_token, buf, len))
                 goto out;
 
-        rsip = rsi_lookup(&rsii);
+        rsip = rsi_lookup(cd, &rsii);
         if (!rsip)
                 goto out;
 
@@ -258,21 +258,20 @@ static int rsi_parse(struct cache_detail *cd,
         if (dup_to_netobj(&rsii.out_token, buf, len))
                 goto out;
         rsii.h.expiry_time = expiry;
-        rsip = rsi_update(&rsii, rsip);
+        rsip = rsi_update(cd, &rsii, rsip);
         status = 0;
 out:
         rsi_free(&rsii);
         if (rsip)
-                cache_put(&rsip->h, &rsi_cache);
+                cache_put(&rsip->h, cd);
         else
                 status = -ENOMEM;
         return status;
 }
 
-static struct cache_detail rsi_cache = {
+static struct cache_detail rsi_cache_template = {
         .owner          = THIS_MODULE,
         .hash_size      = RSI_HASHMAX,
-        .hash_table     = rsi_table,
         .name           = "auth.rpcsec.init",
         .cache_put      = rsi_put,
         .cache_upcall   = rsi_upcall,
@@ -283,24 +282,24 @@ static struct cache_detail rsi_cache = {
         .alloc          = rsi_alloc,
 };
 
-static struct rsi *rsi_lookup(struct rsi *item)
+static struct rsi *rsi_lookup(struct cache_detail *cd, struct rsi *item)
 {
         struct cache_head *ch;
         int hash = rsi_hash(item);
 
-        ch = sunrpc_cache_lookup(&rsi_cache, &item->h, hash);
+        ch = sunrpc_cache_lookup(cd, &item->h, hash);
         if (ch)
                 return container_of(ch, struct rsi, h);
         else
                 return NULL;
 }
 
-static struct rsi *rsi_update(struct rsi *new, struct rsi *old)
+static struct rsi *rsi_update(struct cache_detail *cd, struct rsi *new, struct rsi *old)
 {
         struct cache_head *ch;
         int hash = rsi_hash(new);
 
-        ch = sunrpc_cache_update(&rsi_cache, &new->h,
+        ch = sunrpc_cache_update(cd, &new->h,
                                  &old->h, hash);
         if (ch)
                 return container_of(ch, struct rsi, h);
@@ -339,10 +338,8 @@ struct rsc {
         char                    *client_name;
 };
 
-static struct cache_head *rsc_table[RSC_HASHMAX];
-static struct cache_detail rsc_cache;
-static struct rsc *rsc_update(struct rsc *new, struct rsc *old);
-static struct rsc *rsc_lookup(struct rsc *item);
+static struct rsc *rsc_update(struct cache_detail *cd, struct rsc *new, struct rsc *old);
+static struct rsc *rsc_lookup(struct cache_detail *cd, struct rsc *item);
 
 static void rsc_free(struct rsc *rsci)
 {
@@ -444,7 +441,7 @@ static int rsc_parse(struct cache_detail *cd,
         if (expiry == 0)
                 goto out;
 
-        rscp = rsc_lookup(&rsci);
+        rscp = rsc_lookup(cd, &rsci);
         if (!rscp)
                 goto out;
 
@@ -506,22 +503,21 @@ static int rsc_parse(struct cache_detail *cd,
 
         }
         rsci.h.expiry_time = expiry;
-        rscp = rsc_update(&rsci, rscp);
+        rscp = rsc_update(cd, &rsci, rscp);
         status = 0;
 out:
         gss_mech_put(gm);
         rsc_free(&rsci);
         if (rscp)
-                cache_put(&rscp->h, &rsc_cache);
+                cache_put(&rscp->h, cd);
         else
                 status = -ENOMEM;
         return status;
 }
 
-static struct cache_detail rsc_cache = {
+static struct cache_detail rsc_cache_template = {
         .owner          = THIS_MODULE,
         .hash_size      = RSC_HASHMAX,
-        .hash_table     = rsc_table,
         .name           = "auth.rpcsec.context",
         .cache_put      = rsc_put,
         .cache_parse    = rsc_parse,
@@ -531,24 +527,24 @@ static struct cache_detail rsc_cache = {
         .alloc          = rsc_alloc,
 };
 
-static struct rsc *rsc_lookup(struct rsc *item)
+static struct rsc *rsc_lookup(struct cache_detail *cd, struct rsc *item)
 {
         struct cache_head *ch;
         int hash = rsc_hash(item);
 
-        ch = sunrpc_cache_lookup(&rsc_cache, &item->h, hash);
+        ch = sunrpc_cache_lookup(cd, &item->h, hash);
         if (ch)
                 return container_of(ch, struct rsc, h);
         else
                 return NULL;
 }
 
-static struct rsc *rsc_update(struct rsc *new, struct rsc *old)
+static struct rsc *rsc_update(struct cache_detail *cd, struct rsc *new, struct rsc *old)
 {
         struct cache_head *ch;
         int hash = rsc_hash(new);
 
-        ch = sunrpc_cache_update(&rsc_cache, &new->h,
+        ch = sunrpc_cache_update(cd, &new->h,
                                  &old->h, hash);
         if (ch)
                 return container_of(ch, struct rsc, h);
@@ -558,7 +554,7 @@ static struct rsc *rsc_update(struct rsc *new, struct rsc *old)
 
 
 static struct rsc *
-gss_svc_searchbyctx(struct xdr_netobj *handle)
+gss_svc_searchbyctx(struct cache_detail *cd, struct xdr_netobj *handle)
 {
         struct rsc rsci;
         struct rsc *found;
@@ -566,11 +562,11 @@ gss_svc_searchbyctx(struct xdr_netobj *handle)
         memset(&rsci, 0, sizeof(rsci));
         if (dup_to_netobj(&rsci.handle, handle->data, handle->len))
                 return NULL;
-        found = rsc_lookup(&rsci);
+        found = rsc_lookup(cd, &rsci);
         rsc_free(&rsci);
         if (!found)
                 return NULL;
-        if (cache_check(&rsc_cache, &found->h, NULL))
+        if (cache_check(cd, &found->h, NULL))
                 return NULL;
         return found;
 }
@@ -968,20 +964,20 @@ svcauth_gss_set_client(struct svc_rqst *rqstp)
 }
 
 static inline int
-gss_write_init_verf(struct svc_rqst *rqstp, struct rsi *rsip)
+gss_write_init_verf(struct cache_detail *cd, struct svc_rqst *rqstp, struct rsi *rsip)
 {
         struct rsc *rsci;
         int        rc;
 
         if (rsip->major_status != GSS_S_COMPLETE)
                 return gss_write_null_verf(rqstp);
-        rsci = gss_svc_searchbyctx(&rsip->out_handle);
+        rsci = gss_svc_searchbyctx(cd, &rsip->out_handle);
         if (rsci == NULL) {
                 rsip->major_status = GSS_S_NO_CONTEXT;
                 return gss_write_null_verf(rqstp);
         }
         rc = gss_write_verf(rqstp, rsci->mechctx, GSS_SEQ_WIN);
-        cache_put(&rsci->h, &rsc_cache);
+        cache_put(&rsci->h, cd);
         return rc;
 }
 
@@ -1000,6 +996,7 @@ static int svcauth_gss_handle_init(struct svc_rqst *rqstp,
         struct xdr_netobj tmpobj;
         struct rsi *rsip, rsikey;
         int ret;
+        struct sunrpc_net *sn = net_generic(rqstp->rq_xprt->xpt_net, sunrpc_net_id);
 
         /* Read the verifier; should be NULL: */
         *authp = rpc_autherr_badverf;
@@ -1028,17 +1025,17 @@ static int svcauth_gss_handle_init(struct svc_rqst *rqstp,
         }
 
         /* Perform upcall, or find upcall result: */
-        rsip = rsi_lookup(&rsikey);
+        rsip = rsi_lookup(sn->rsi_cache, &rsikey);
         rsi_free(&rsikey);
         if (!rsip)
                 return SVC_CLOSE;
-        if (cache_check(&rsi_cache, &rsip->h, &rqstp->rq_chandle) < 0)
+        if (cache_check(sn->rsi_cache, &rsip->h, &rqstp->rq_chandle) < 0)
                 /* No upcall result: */
                 return SVC_CLOSE;
 
         ret = SVC_CLOSE;
         /* Got an answer to the upcall; use it: */
-        if (gss_write_init_verf(rqstp, rsip))
+        if (gss_write_init_verf(sn->rsc_cache, rqstp, rsip))
                 goto out;
         if (resv->iov_len + 4 > PAGE_SIZE)
                 goto out;
@@ -1055,7 +1052,7 @@ static int svcauth_gss_handle_init(struct svc_rqst *rqstp,
 
         ret = SVC_COMPLETE;
 out:
-        cache_put(&rsip->h, &rsi_cache);
+        cache_put(&rsip->h, sn->rsi_cache);
         return ret;
 }
 
@@ -1079,6 +1076,7 @@ svcauth_gss_accept(struct svc_rqst *rqstp, __be32 *authp)
         __be32          *rpcstart;
         __be32          *reject_stat = resv->iov_base + resv->iov_len;
         int             ret;
+        struct sunrpc_net *sn = net_generic(rqstp->rq_xprt->xpt_net, sunrpc_net_id);
 
         dprintk("RPC:       svcauth_gss: argv->iov_len = %zd\n",
                         argv->iov_len);
@@ -1129,7 +1127,7 @@ svcauth_gss_accept(struct svc_rqst *rqstp, __be32 *authp)
         case RPC_GSS_PROC_DESTROY:
                 /* Look up the context, and check the verifier: */
                 *authp = rpcsec_gsserr_credproblem;
-                rsci = gss_svc_searchbyctx(&gc->gc_ctx);
+                rsci = gss_svc_searchbyctx(sn->rsc_cache, &gc->gc_ctx);
                 if (!rsci)
                         goto auth_err;
                 switch (gss_verify_header(rqstp, rsci, rpcstart, gc, authp)) {
@@ -1209,7 +1207,7 @@ drop:
         ret = SVC_DROP;
 out:
         if (rsci)
-                cache_put(&rsci->h, &rsc_cache);
+                cache_put(&rsci->h, sn->rsc_cache);
         return ret;
 }
 
@@ -1362,6 +1360,7 @@ svcauth_gss_release(struct svc_rqst *rqstp)
         struct rpc_gss_wire_cred *gc = &gsd->clcred;
         struct xdr_buf *resbuf = &rqstp->rq_res;
         int stat = -EINVAL;
+        struct sunrpc_net *sn = net_generic(rqstp->rq_xprt->xpt_net, sunrpc_net_id);
 
         if (gc->gc_proc != RPC_GSS_PROC_DATA)
                 goto out;
@@ -1404,7 +1403,7 @@ out_err:
                 put_group_info(rqstp->rq_cred.cr_group_info);
         rqstp->rq_cred.cr_group_info = NULL;
         if (gsd->rsci)
-                cache_put(&gsd->rsci->h, &rsc_cache);
+                cache_put(&gsd->rsci->h, sn->rsc_cache);
         gsd->rsci = NULL;
 
         return stat;
@@ -1429,30 +1428,96 @@ static struct auth_ops svcauthops_gss = {
         .set_client     = svcauth_gss_set_client,
 };
 
+static int rsi_cache_create_net(struct net *net)
+{
+        struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
+        struct cache_detail *cd;
+        int err;
+
+        cd = cache_create_net(&rsi_cache_template, net);
+        if (IS_ERR(cd))
+                return PTR_ERR(cd);
+        err = cache_register_net(cd, net);
+        if (err) {
+                cache_destroy_net(cd, net);
+                return err;
+        }
+        sn->rsi_cache = cd;
+        return 0;
+}
+
+static void rsi_cache_destroy_net(struct net *net)
+{
+        struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
+        struct cache_detail *cd = sn->rsi_cache;
+
+        sn->rsi_cache = NULL;
+        cache_purge(cd);
+        cache_unregister_net(cd, net);
+        cache_destroy_net(cd, net);
+}
+
+static int rsc_cache_create_net(struct net *net)
+{
+        struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
+        struct cache_detail *cd;
+        int err;
+
+        cd = cache_create_net(&rsc_cache_template, net);
+        if (IS_ERR(cd))
+                return PTR_ERR(cd);
+        err = cache_register_net(cd, net);
+        if (err) {
+                cache_destroy_net(cd, net);
+                return err;
+        }
+        sn->rsc_cache = cd;
+        return 0;
+}
+
+static void rsc_cache_destroy_net(struct net *net)
+{
+        struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
+        struct cache_detail *cd = sn->rsc_cache;
+
+        sn->rsc_cache = NULL;
+        cache_purge(cd);
+        cache_unregister_net(cd, net);
+        cache_destroy_net(cd, net);
+}
+
 int
-gss_svc_init(void)
+gss_svc_init_net(struct net *net)
 {
-        int rv = svc_auth_register(RPC_AUTH_GSS, &svcauthops_gss);
+        int rv;
+
+        rv = rsc_cache_create_net(net);
         if (rv)
                 return rv;
-        rv = cache_register(&rsc_cache);
+        rv = rsi_cache_create_net(net);
         if (rv)
                 goto out1;
-        rv = cache_register(&rsi_cache);
-        if (rv)
-                goto out2;
         return 0;
-out2:
-        cache_unregister(&rsc_cache);
 out1:
-        svc_auth_unregister(RPC_AUTH_GSS);
+        rsc_cache_destroy_net(net);
         return rv;
 }
 
 void
+gss_svc_shutdown_net(struct net *net)
+{
+        rsi_cache_destroy_net(net);
+        rsc_cache_destroy_net(net);
+}
+
+int
+gss_svc_init(void)
+{
+        return svc_auth_register(RPC_AUTH_GSS, &svcauthops_gss);
+}
+
+void
 gss_svc_shutdown(void)
 {
-        cache_unregister(&rsc_cache);
-        cache_unregister(&rsi_cache);
         svc_auth_unregister(RPC_AUTH_GSS);
 }