Merge branch 'for-3.15' of git://linux-nfs.org/~bfields/linux

Pull nfsd updates from Bruce Fields:
 "Highlights:
   - server-side nfs/rdma fixes from Jeff Layton and Tom Tucker
   - xdr fixes (a larger xdr rewrite has been posted but I decided it
     would be better to queue it up for 3.16).
   - miscellaneous fixes and cleanup from all over (thanks especially to
     Kinglong Mee)"

* 'for-3.15' of git://linux-nfs.org/~bfields/linux: (36 commits)
  nfsd4: don't create unnecessary mask acl
  nfsd: revert v2 half of "nfsd: don't return high mode bits"
  nfsd4: fix memory leak in nfsd4_encode_fattr()
  nfsd: check passed socket's net matches NFSd superblock's one
  SUNRPC: Clear xpt_bc_xprt if xs_setup_bc_tcp failed
  NFSD/SUNRPC: Check rpc_xprt out of xs_setup_bc_tcp
  SUNRPC: New helper for creating client with rpc_xprt
  NFSD: Free backchannel xprt in bc_destroy
  NFSD: Clear wcc data between compound ops
  nfsd: Don't return NFS4ERR_STALE_STATEID for NFSv4.1+
  nfsd4: fix nfs4err_resource in 4.1 case
  nfsd4: fix setclientid encode size
  nfsd4: remove redundant check from nfsd4_check_resp_size
  nfsd4: use more generous NFS4_ACL_MAX
  nfsd4: minor nfsd4_replay_cache_entry cleanup
  nfsd4: nfsd4_replay_cache_entry should be static
  nfsd4: update comments with obsolete function name
  rpc: Allow xdr_buf_subsegment to operate in-place
  NFSD: Using free_conn free connection
  SUNRPC: fix memory leak of peer addresses in XPRT
  ...

11 files changed, 119 insertions, 86 deletions

diff --git a/net/sunrpc/Kconfig b/net/sunrpc/Kconfig
index 241b54f30204..0754d0f466d2 100644
--- a/net/sunrpc/Kconfig
+++ b/net/sunrpc/Kconfig
@@ -9,19 +9,6 @@ config SUNRPC_BACKCHANNEL
         bool
         depends on SUNRPC
 
-config SUNRPC_XPRT_RDMA
-        tristate
-        depends on SUNRPC && INFINIBAND && INFINIBAND_ADDR_TRANS
-        default SUNRPC && INFINIBAND
-        help
-          This option allows the NFS client and server to support
-          an RDMA-enabled transport.
-
-          To compile RPC client RDMA transport support as a module,
-          choose M here: the module will be called xprtrdma.
-
-          If unsure, say N.
-
 config SUNRPC_SWAP
         bool
         depends on SUNRPC
@@ -57,3 +44,29 @@ config SUNRPC_DEBUG
           but makes troubleshooting NFS issues significantly harder.
 
           If unsure, say Y.
+
+config SUNRPC_XPRT_RDMA_CLIENT
+        tristate "RPC over RDMA Client Support"
+        depends on SUNRPC && INFINIBAND && INFINIBAND_ADDR_TRANS
+        default SUNRPC && INFINIBAND
+        help
+          This option allows the NFS client to support an RDMA-enabled
+          transport.
+
+          To compile RPC client RDMA transport support as a module,
+          choose M here: the module will be called xprtrdma.
+
+          If unsure, say N.
+
+config SUNRPC_XPRT_RDMA_SERVER
+        tristate "RPC over RDMA Server Support"
+        depends on SUNRPC && INFINIBAND && INFINIBAND_ADDR_TRANS
+        default SUNRPC && INFINIBAND
+        help
+          This option allows the NFS server to support an RDMA-enabled
+          transport.
+
+          To compile RPC server RDMA transport support as a module,
+          choose M here: the module will be called svcrdma.
+
+          If unsure, say N.
diff --git a/net/sunrpc/Makefile b/net/sunrpc/Makefile
index 8209a0411bca..e5a7a1cac8f3 100644
--- a/net/sunrpc/Makefile
+++ b/net/sunrpc/Makefile
@@ -5,7 +5,8 @@
 
 obj-$(CONFIG_SUNRPC) += sunrpc.o
 obj-$(CONFIG_SUNRPC_GSS) += auth_gss/
-obj-$(CONFIG_SUNRPC_XPRT_RDMA) += xprtrdma/
+
+obj-y += xprtrdma/
 
 sunrpc-y := clnt.o xprt.o socklib.o xprtsock.o sched.o \
             auth.o auth_null.o auth_unix.o auth_generic.o \
diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c
index f400445d1a44..2e6ab10734f6 100644
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@ -438,6 +438,38 @@ out_no_rpciod:
         return ERR_PTR(err);
 }
 
+struct rpc_clnt *rpc_create_xprt(struct rpc_create_args *args,
+                                        struct rpc_xprt *xprt)
+{
+        struct rpc_clnt *clnt = NULL;
+
+        clnt = rpc_new_client(args, xprt, NULL);
+        if (IS_ERR(clnt))
+                return clnt;
+
+        if (!(args->flags & RPC_CLNT_CREATE_NOPING)) {
+                int err = rpc_ping(clnt);
+                if (err != 0) {
+                        rpc_shutdown_client(clnt);
+                        return ERR_PTR(err);
+                }
+        }
+
+        clnt->cl_softrtry = 1;
+        if (args->flags & RPC_CLNT_CREATE_HARDRTRY)
+                clnt->cl_softrtry = 0;
+
+        if (args->flags & RPC_CLNT_CREATE_AUTOBIND)
+                clnt->cl_autobind = 1;
+        if (args->flags & RPC_CLNT_CREATE_DISCRTRY)
+                clnt->cl_discrtry = 1;
+        if (!(args->flags & RPC_CLNT_CREATE_QUIET))
+                clnt->cl_chatty = 1;
+
+        return clnt;
+}
+EXPORT_SYMBOL_GPL(rpc_create_xprt);
+
 /**
  * rpc_create - create an RPC client and transport with one call
  * @args: rpc_clnt create argument structure
@@ -451,7 +483,6 @@ out_no_rpciod:
 struct rpc_clnt *rpc_create(struct rpc_create_args *args)
 {
         struct rpc_xprt *xprt;
-        struct rpc_clnt *clnt;
         struct xprt_create xprtargs = {
                 .net = args->net,
                 .ident = args->protocol,
@@ -515,30 +546,7 @@ struct rpc_clnt *rpc_create(struct rpc_create_args *args)
         if (args->flags & RPC_CLNT_CREATE_NONPRIVPORT)
                 xprt->resvport = 0;
 
-        clnt = rpc_new_client(args, xprt, NULL);
-        if (IS_ERR(clnt))
-                return clnt;
-
-        if (!(args->flags & RPC_CLNT_CREATE_NOPING)) {
-                int err = rpc_ping(clnt);
-                if (err != 0) {
-                        rpc_shutdown_client(clnt);
-                        return ERR_PTR(err);
-                }
-        }
-
-        clnt->cl_softrtry = 1;
-        if (args->flags & RPC_CLNT_CREATE_HARDRTRY)
-                clnt->cl_softrtry = 0;
-
-        if (args->flags & RPC_CLNT_CREATE_AUTOBIND)
-                clnt->cl_autobind = 1;
-        if (args->flags & RPC_CLNT_CREATE_DISCRTRY)
-                clnt->cl_discrtry = 1;
-        if (!(args->flags & RPC_CLNT_CREATE_QUIET))
-                clnt->cl_chatty = 1;
-
-        return clnt;
+        return rpc_create_xprt(args, xprt);
 }
 EXPORT_SYMBOL_GPL(rpc_create);
 
diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index b6e59f0a9475..d06cb8752dcd 100644
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -1397,6 +1397,22 @@ static struct svc_sock *svc_setup_socket(struct svc_serv *serv,
         return svsk;
 }
 
+bool svc_alien_sock(struct net *net, int fd)
+{
+        int err;
+        struct socket *sock = sockfd_lookup(fd, &err);
+        bool ret = false;
+
+        if (!sock)
+                goto out;
+        if (sock_net(sock->sk) != net)
+                ret = true;
+        sockfd_put(sock);
+out:
+        return ret;
+}
+EXPORT_SYMBOL_GPL(svc_alien_sock);
+
 /**
  * svc_addsock - add a listener socket to an RPC service
  * @serv: pointer to RPC service to which to add a new listener
diff --git a/net/sunrpc/xdr.c b/net/sunrpc/xdr.c
index 1504bb11e4f3..dd97ba3c4456 100644
--- a/net/sunrpc/xdr.c
+++ b/net/sunrpc/xdr.c
@@ -833,8 +833,20 @@ xdr_buf_from_iov(struct kvec *iov, struct xdr_buf *buf)
 }
 EXPORT_SYMBOL_GPL(xdr_buf_from_iov);
 
-/* Sets subbuf to the portion of buf of length len beginning base bytes
- * from the start of buf. Returns -1 if base of length are out of bounds. */
+/**
+ * xdr_buf_subsegment - set subbuf to a portion of buf
+ * @buf: an xdr buffer
+ * @subbuf: the result buffer
+ * @base: beginning of range in bytes
+ * @len: length of range in bytes
+ *
+ * sets @subbuf to an xdr buffer representing the portion of @buf of
+ * length @len starting at offset @base.
+ *
+ * @buf and @subbuf may be pointers to the same struct xdr_buf.
+ *
+ * Returns -1 if base of length are out of bounds.
+ */
 int
 xdr_buf_subsegment(struct xdr_buf *buf, struct xdr_buf *subbuf,
                         unsigned int base, unsigned int len)
@@ -847,9 +859,8 @@ xdr_buf_subsegment(struct xdr_buf *buf, struct xdr_buf *subbuf,
                 len -= subbuf->head[0].iov_len;
                 base = 0;
         } else {
-                subbuf->head[0].iov_base = NULL;
-                subbuf->head[0].iov_len = 0;
                 base -= buf->head[0].iov_len;
+                subbuf->head[0].iov_len = 0;
         }
 
         if (base < buf->page_len) {
@@ -871,9 +882,8 @@ xdr_buf_subsegment(struct xdr_buf *buf, struct xdr_buf *subbuf,
                 len -= subbuf->tail[0].iov_len;
                 base = 0;
         } else {
-                subbuf->tail[0].iov_base = NULL;
-                subbuf->tail[0].iov_len = 0;
                 base -= buf->tail[0].iov_len;
+                subbuf->tail[0].iov_len = 0;
         }
 
         if (base || len)
diff --git a/net/sunrpc/xprt.c b/net/sunrpc/xprt.c
index 7d4df99f761f..d173f79947c6 100644
--- a/net/sunrpc/xprt.c
+++ b/net/sunrpc/xprt.c
@@ -1383,15 +1383,3 @@ void xprt_put(struct rpc_xprt *xprt)
         if (atomic_dec_and_test(&xprt->count))
                 xprt_destroy(xprt);
 }
-
-/**
- * xprt_get - return a reference to an RPC transport.
- * @xprt: pointer to the transport
- *
- */
-struct rpc_xprt *xprt_get(struct rpc_xprt *xprt)
-{
-        if (atomic_inc_not_zero(&xprt->count))
-                return xprt;
-        return NULL;
-}
diff --git a/net/sunrpc/xprtrdma/Makefile b/net/sunrpc/xprtrdma/Makefile
index 5a8f268bdd30..da5136fd5694 100644
--- a/net/sunrpc/xprtrdma/Makefile
+++ b/net/sunrpc/xprtrdma/Makefile
@@ -1,8 +1,8 @@
-obj-$(CONFIG_SUNRPC_XPRT_RDMA) += xprtrdma.o
+obj-$(CONFIG_SUNRPC_XPRT_RDMA_CLIENT) += xprtrdma.o
 
 xprtrdma-y := transport.o rpc_rdma.o verbs.o
 
-obj-$(CONFIG_SUNRPC_XPRT_RDMA) += svcrdma.o
+obj-$(CONFIG_SUNRPC_XPRT_RDMA_SERVER) += svcrdma.o
 
 svcrdma-y := svc_rdma.o svc_rdma_transport.o \
         svc_rdma_marshal.o svc_rdma_sendto.o svc_rdma_recvfrom.o
diff --git a/net/sunrpc/xprtrdma/svc_rdma_recvfrom.c b/net/sunrpc/xprtrdma/svc_rdma_recvfrom.c
index 0ce75524ed21..8d904e4eef15 100644
--- a/net/sunrpc/xprtrdma/svc_rdma_recvfrom.c
+++ b/net/sunrpc/xprtrdma/svc_rdma_recvfrom.c
@@ -90,6 +90,7 @@ static void rdma_build_arg_xdr(struct svc_rqst *rqstp,
                 sge_no++;
         }
         rqstp->rq_respages = &rqstp->rq_pages[sge_no];
+        rqstp->rq_next_page = rqstp->rq_respages + 1;
 
         /* We should never run out of SGE because the limit is defined to
          * support the max allowed RPC data length
@@ -169,6 +170,7 @@ static int map_read_chunks(struct svcxprt_rdma *xprt,
                  */
                 head->arg.pages[page_no] = rqstp->rq_arg.pages[page_no];
                 rqstp->rq_respages = &rqstp->rq_arg.pages[page_no+1];
+                rqstp->rq_next_page = rqstp->rq_respages + 1;
 
                 byte_count -= sge_bytes;
                 ch_bytes -= sge_bytes;
@@ -276,6 +278,7 @@ static int fast_reg_read_chunks(struct svcxprt_rdma *xprt,
 
         /* rq_respages points one past arg pages */
         rqstp->rq_respages = &rqstp->rq_arg.pages[page_no];
+        rqstp->rq_next_page = rqstp->rq_respages + 1;
 
         /* Create the reply and chunk maps */
         offset = 0;
@@ -520,13 +523,6 @@ next_sge:
         for (ch_no = 0; &rqstp->rq_pages[ch_no] < rqstp->rq_respages; ch_no++)
                 rqstp->rq_pages[ch_no] = NULL;
 
-        /*
-         * Detach res pages. If svc_release sees any it will attempt to
-         * put them.
-         */
-        while (rqstp->rq_next_page != rqstp->rq_respages)
-                *(--rqstp->rq_next_page) = NULL;
-
         return err;
 }
 
@@ -550,7 +546,7 @@ static int rdma_read_complete(struct svc_rqst *rqstp,
 
         /* rq_respages starts after the last arg page */
         rqstp->rq_respages = &rqstp->rq_arg.pages[page_no];
-        rqstp->rq_next_page = &rqstp->rq_arg.pages[page_no];
+        rqstp->rq_next_page = rqstp->rq_respages + 1;
 
         /* Rebuild rq_arg head and tail. */
         rqstp->rq_arg.head[0] = head->arg.head[0];
diff --git a/net/sunrpc/xprtrdma/svc_rdma_sendto.c b/net/sunrpc/xprtrdma/svc_rdma_sendto.c
index c1d124dc772b..7e024a51617e 100644
--- a/net/sunrpc/xprtrdma/svc_rdma_sendto.c
+++ b/net/sunrpc/xprtrdma/svc_rdma_sendto.c
@@ -265,6 +265,7 @@ static dma_addr_t dma_map_xdr(struct svcxprt_rdma *xprt,
                 xdr_off -= xdr->head[0].iov_len;
                 if (xdr_off < xdr->page_len) {
                         /* This offset is in the page list */
+                        xdr_off += xdr->page_base;
                         page = xdr->pages[xdr_off >> PAGE_SHIFT];
                         xdr_off &= ~PAGE_MASK;
                 } else {
@@ -625,6 +626,7 @@ static int send_reply(struct svcxprt_rdma *rdma,
                 if (page_no+1 >= sge_no)
                         ctxt->sge[page_no+1].length = 0;
         }
+        rqstp->rq_next_page = rqstp->rq_respages + 1;
         BUG_ON(sge_no > rdma->sc_max_sge);
         memset(&send_wr, 0, sizeof send_wr);
         ctxt->wr_op = IB_WR_SEND;
diff --git a/net/sunrpc/xprtrdma/svc_rdma_transport.c b/net/sunrpc/xprtrdma/svc_rdma_transport.c
index 62e4f9bcc387..25688fa2207f 100644
--- a/net/sunrpc/xprtrdma/svc_rdma_transport.c
+++ b/net/sunrpc/xprtrdma/svc_rdma_transport.c
@@ -477,8 +477,7 @@ struct page *svc_rdma_get_page(void)
 
         while ((page = alloc_page(GFP_KERNEL)) == NULL) {
                 /* If we can't get memory, wait a bit and try again */
-                printk(KERN_INFO "svcrdma: out of memory...retrying in 1000 "
-                       "jiffies.\n");
+                printk(KERN_INFO "svcrdma: out of memory...retrying in 1s\n");
                 schedule_timeout_uninterruptible(msecs_to_jiffies(1000));
         }
         return page;
diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
index 966763d735e9..6735e1d1e9bb 100644
--- a/net/sunrpc/xprtsock.c
+++ b/net/sunrpc/xprtsock.c
@@ -909,6 +909,12 @@ static void xs_tcp_close(struct rpc_xprt *xprt)
                 xs_tcp_shutdown(xprt);
 }
 
+static void xs_xprt_free(struct rpc_xprt *xprt)
+{
+        xs_free_peer_addresses(xprt);
+        xprt_free(xprt);
+}
+
 /**
  * xs_destroy - prepare to shutdown a transport
  * @xprt: doomed transport
@@ -919,8 +925,7 @@ static void xs_destroy(struct rpc_xprt *xprt)
         dprintk("RPC:       xs_destroy xprt %p\n", xprt);
 
         xs_close(xprt);
-        xs_free_peer_addresses(xprt);
-        xprt_free(xprt);
+        xs_xprt_free(xprt);
         module_put(THIS_MODULE);
 }
 
@@ -2532,6 +2537,10 @@ static void bc_close(struct rpc_xprt *xprt)
 
 static void bc_destroy(struct rpc_xprt *xprt)
 {
+        dprintk("RPC:       bc_destroy xprt %p\n", xprt);
+
+        xs_xprt_free(xprt);
+        module_put(THIS_MODULE);
 }
 
 static struct rpc_xprt_ops xs_local_ops = {
@@ -2732,7 +2741,7 @@ static struct rpc_xprt *xs_setup_local(struct xprt_create *args)
                 return xprt;
         ret = ERR_PTR(-EINVAL);
 out_err:
-        xprt_free(xprt);
+        xs_xprt_free(xprt);
         return ret;
 }
 
@@ -2810,7 +2819,7 @@ static struct rpc_xprt *xs_setup_udp(struct xprt_create *args)
                 return xprt;
         ret = ERR_PTR(-EINVAL);
 out_err:
-        xprt_free(xprt);
+        xs_xprt_free(xprt);
         return ret;
 }
 
@@ -2885,12 +2894,11 @@ static struct rpc_xprt *xs_setup_tcp(struct xprt_create *args)
                                 xprt->address_strings[RPC_DISPLAY_ADDR],
                                 xprt->address_strings[RPC_DISPLAY_PROTO]);
 
-
         if (try_module_get(THIS_MODULE))
                 return xprt;
         ret = ERR_PTR(-EINVAL);
 out_err:
-        xprt_free(xprt);
+        xs_xprt_free(xprt);
         return ret;
 }
 
@@ -2907,15 +2915,6 @@ static struct rpc_xprt *xs_setup_bc_tcp(struct xprt_create *args)
         struct svc_sock *bc_sock;
         struct rpc_xprt *ret;
 
-        if (args->bc_xprt->xpt_bc_xprt) {
-                /*
-                 * This server connection already has a backchannel
-                 * transport; we can't create a new one, as we wouldn't
-                 * be able to match replies based on xid any more.  So,
-                 * reuse the already-existing one:
-                 */
-                 return args->bc_xprt->xpt_bc_xprt;
-        }
         xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries,
                         xprt_tcp_slot_table_entries);
         if (IS_ERR(xprt))
@@ -2973,13 +2972,14 @@ static struct rpc_xprt *xs_setup_bc_tcp(struct xprt_create *args)
          */
         xprt_set_connected(xprt);
 
-
         if (try_module_get(THIS_MODULE))
                 return xprt;
+
+        args->bc_xprt->xpt_bc_xprt = NULL;
         xprt_put(xprt);
         ret = ERR_PTR(-EINVAL);
 out_err:
-        xprt_free(xprt);
+        xs_xprt_free(xprt);
         return ret;
 }