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

Pull nfsd updates from Bruce Fields:
 "A relatively quiet cycle, with a mix of cleanup and smaller bugfixes"

* 'for-4.2' of git://linux-nfs.org/~bfields/linux: (24 commits)
  sunrpc: use sg_init_one() in krb5_rc4_setup_enc/seq_key()
  nfsd: wrap too long lines in nfsd4_encode_read
  nfsd: fput rd_file from XDR encode context
  nfsd: take struct file setup fully into nfs4_preprocess_stateid_op
  nfsd: refactor nfs4_preprocess_stateid_op
  nfsd: clean up raparams handling
  nfsd: use swap() in sort_pacl_range()
  rpcrdma: Merge svcrdma and xprtrdma modules into one
  svcrdma: Add a separate "max data segs macro for svcrdma
  svcrdma: Replace GFP_KERNEL in a loop with GFP_NOFAIL
  svcrdma: Keep rpcrdma_msg fields in network byte-order
  svcrdma: Fix byte-swapping in svc_rdma_sendto.c
  nfsd: Update callback sequnce id only CB_SEQUENCE success
  nfsd: Reset cb_status in nfsd4_cb_prepare() at retrying
  svcrdma: Remove svc_rdma_xdr_decode_deferred_req()
  SUNRPC: Move EXPORT_SYMBOL for svc_process
  uapi/nfs: Add NFSv4.1 ACL definitions
  nfsd: Remove dead declarations
  nfsd: work around a gcc-5.1 warning
  nfsd: Checking for acl support does not require fetching any acls
  ...

13 files changed, 129 insertions, 198 deletions

diff --git a/net/sunrpc/Kconfig b/net/sunrpc/Kconfig
index 9068e72aa73c..04ce2c0b660e 100644
--- a/net/sunrpc/Kconfig
+++ b/net/sunrpc/Kconfig
@@ -48,28 +48,16 @@ config SUNRPC_DEBUG
 
           If unsure, say Y.
 
-config SUNRPC_XPRT_RDMA_CLIENT
-        tristate "RPC over RDMA Client Support"
+config SUNRPC_XPRT_RDMA
+        tristate "RPC-over-RDMA transport"
         depends on SUNRPC && INFINIBAND && INFINIBAND_ADDR_TRANS
         default SUNRPC && INFINIBAND
         help
-          This option allows the NFS client to support an RDMA-enabled
-          transport.
+          This option allows the NFS client and server to use RDMA
+          transports (InfiniBand, iWARP, or RoCE).
 
-          To compile RPC client RDMA transport support as a module,
-          choose M here: the module will be called xprtrdma.
+          To compile this support as a module, choose M. The module
+          will be called rpcrdma.ko.
 
-          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.
+          If unsure, or you know there is no RDMA capability on your
+          hardware platform, say N.
diff --git a/net/sunrpc/Makefile b/net/sunrpc/Makefile
index 15e6f6c23c5d..936ad0a15371 100644
--- a/net/sunrpc/Makefile
+++ b/net/sunrpc/Makefile
@@ -5,8 +5,7 @@
 
 obj-$(CONFIG_SUNRPC) += sunrpc.o
 obj-$(CONFIG_SUNRPC_GSS) += auth_gss/
-
-obj-y += xprtrdma/
+obj-$(CONFIG_SUNRPC_XPRT_RDMA) += 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/auth_gss/gss_krb5_crypto.c b/net/sunrpc/auth_gss/gss_krb5_crypto.c
index b5408e8a37f2..fee3c15a4b52 100644
--- a/net/sunrpc/auth_gss/gss_krb5_crypto.c
+++ b/net/sunrpc/auth_gss/gss_krb5_crypto.c
@@ -881,9 +881,7 @@ krb5_rc4_setup_seq_key(struct krb5_ctx *kctx, struct crypto_blkcipher *cipher,
         if (err)
                 goto out_err;
 
-        sg_init_table(sg, 1);
-        sg_set_buf(sg, &zeroconstant, 4);
-
+        sg_init_one(sg, &zeroconstant, 4);
         err = crypto_hash_digest(&desc, sg, 4, Kseq);
         if (err)
                 goto out_err;
@@ -951,9 +949,7 @@ krb5_rc4_setup_enc_key(struct krb5_ctx *kctx, struct crypto_blkcipher *cipher,
         if (err)
                 goto out_err;
 
-        sg_init_table(sg, 1);
-        sg_set_buf(sg, zeroconstant, 4);
-
+        sg_init_one(sg, zeroconstant, 4);
         err = crypto_hash_digest(&desc, sg, 4, Kcrypt);
         if (err)
                 goto out_err;
diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c
index 78974e4d9ad2..852ae606b02a 100644
--- a/net/sunrpc/svc.c
+++ b/net/sunrpc/svc.c
@@ -1290,7 +1290,6 @@ err_bad:
         svc_putnl(resv, ntohl(rpc_stat));
         goto sendit;
 }
-EXPORT_SYMBOL_GPL(svc_process);
 
 /*
  * Process the RPC request.
@@ -1338,6 +1337,7 @@ out_drop:
         svc_drop(rqstp);
         return 0;
 }
+EXPORT_SYMBOL_GPL(svc_process);
 
 #if defined(CONFIG_SUNRPC_BACKCHANNEL)
 /*
diff --git a/net/sunrpc/xprtrdma/Makefile b/net/sunrpc/xprtrdma/Makefile
index 579f72bbcf4b..48913de240bd 100644
--- a/net/sunrpc/xprtrdma/Makefile
+++ b/net/sunrpc/xprtrdma/Makefile
@@ -1,9 +1,7 @@
-obj-$(CONFIG_SUNRPC_XPRT_RDMA_CLIENT) += xprtrdma.o
+obj-$(CONFIG_SUNRPC_XPRT_RDMA) += rpcrdma.o
 
-xprtrdma-y := transport.o rpc_rdma.o verbs.o \
-        fmr_ops.o frwr_ops.o physical_ops.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
+rpcrdma-y := transport.o rpc_rdma.o verbs.o \
+        fmr_ops.o frwr_ops.o physical_ops.o \
+        svc_rdma.o svc_rdma_transport.o \
+        svc_rdma_marshal.o svc_rdma_sendto.o svc_rdma_recvfrom.o \
+        module.o
diff --git a/net/sunrpc/xprtrdma/module.c b/net/sunrpc/xprtrdma/module.c
new file mode 100644
index 000000000000..560712bd9fa2
--- /dev/null
+++ b/net/sunrpc/xprtrdma/module.c
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2015 Oracle.  All rights reserved.
+ */
+
+/* rpcrdma.ko module initialization
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/sunrpc/svc_rdma.h>
+#include "xprt_rdma.h"
+
+#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
+# define RPCDBG_FACILITY        RPCDBG_TRANS
+#endif
+
+MODULE_AUTHOR("Open Grid Computing and Network Appliance, Inc.");
+MODULE_DESCRIPTION("RPC/RDMA Transport");
+MODULE_LICENSE("Dual BSD/GPL");
+MODULE_ALIAS("svcrdma");
+MODULE_ALIAS("xprtrdma");
+
+static void __exit rpc_rdma_cleanup(void)
+{
+        xprt_rdma_cleanup();
+        svc_rdma_cleanup();
+}
+
+static int __init rpc_rdma_init(void)
+{
+        int rc;
+
+        rc = svc_rdma_init();
+        if (rc)
+                goto out;
+
+        rc = xprt_rdma_init();
+        if (rc)
+                svc_rdma_cleanup();
+
+out:
+        return rc;
+}
+
+module_init(rpc_rdma_init);
+module_exit(rpc_rdma_cleanup);
diff --git a/net/sunrpc/xprtrdma/svc_rdma.c b/net/sunrpc/xprtrdma/svc_rdma.c
index c1b6270262c2..2cd252f023a5 100644
--- a/net/sunrpc/xprtrdma/svc_rdma.c
+++ b/net/sunrpc/xprtrdma/svc_rdma.c
@@ -38,8 +38,7 @@
  *
  * Author: Tom Tucker <tom@opengridcomputing.com>
  */
-#include <linux/module.h>
-#include <linux/init.h>
+
 #include <linux/slab.h>
 #include <linux/fs.h>
 #include <linux/sysctl.h>
@@ -295,8 +294,3 @@ int svc_rdma_init(void)
         destroy_workqueue(svc_rdma_wq);
         return -ENOMEM;
 }
-MODULE_AUTHOR("Tom Tucker <tom@opengridcomputing.com>");
-MODULE_DESCRIPTION("SVC RDMA Transport");
-MODULE_LICENSE("Dual BSD/GPL");
-module_init(svc_rdma_init);
-module_exit(svc_rdma_cleanup);
diff --git a/net/sunrpc/xprtrdma/svc_rdma_marshal.c b/net/sunrpc/xprtrdma/svc_rdma_marshal.c
index b681855cf970..e2fca7617242 100644
--- a/net/sunrpc/xprtrdma/svc_rdma_marshal.c
+++ b/net/sunrpc/xprtrdma/svc_rdma_marshal.c
@@ -50,12 +50,12 @@
 /*
  * Decodes a read chunk list. The expected format is as follows:
  *    descrim  : xdr_one
- *    position : u32 offset into XDR stream
- *    handle   : u32 RKEY
+ *    position : __be32 offset into XDR stream
+ *    handle   : __be32 RKEY
  *    . . .
  *  end-of-list: xdr_zero
  */
-static u32 *decode_read_list(u32 *va, u32 *vaend)
+static __be32 *decode_read_list(__be32 *va, __be32 *vaend)
 {
         struct rpcrdma_read_chunk *ch = (struct rpcrdma_read_chunk *)va;
 
@@ -67,20 +67,20 @@ static u32 *decode_read_list(u32 *va, u32 *vaend)
                 }
                 ch++;
         }
-        return (u32 *)&ch->rc_position;
+        return &ch->rc_position;
 }
 
 /*
  * Decodes a write chunk list. The expected format is as follows:
  *    descrim  : xdr_one
  *    nchunks  : <count>
- *       handle   : u32 RKEY              ---+
- *       length   : u32 <len of segment>     |
+ *       handle   : __be32 RKEY           ---+
+ *       length   : __be32 <len of segment>  |
  *       offset   : remove va                + <count>
  *       . . .                               |
  *                                        ---+
  */
-static u32 *decode_write_list(u32 *va, u32 *vaend)
+static __be32 *decode_write_list(__be32 *va, __be32 *vaend)
 {
         unsigned long start, end;
         int nchunks;
@@ -90,14 +90,14 @@ static u32 *decode_write_list(u32 *va, u32 *vaend)
 
         /* Check for not write-array */
         if (ary->wc_discrim == xdr_zero)
-                return (u32 *)&ary->wc_nchunks;
+                return &ary->wc_nchunks;
 
         if ((unsigned long)ary + sizeof(struct rpcrdma_write_array) >
             (unsigned long)vaend) {
                 dprintk("svcrdma: ary=%p, vaend=%p\n", ary, vaend);
                 return NULL;
         }
-        nchunks = ntohl(ary->wc_nchunks);
+        nchunks = be32_to_cpu(ary->wc_nchunks);
 
         start = (unsigned long)&ary->wc_array[0];
         end = (unsigned long)vaend;
@@ -112,10 +112,10 @@ static u32 *decode_write_list(u32 *va, u32 *vaend)
          * rs_length is the 2nd 4B field in wc_target and taking its
          * address skips the list terminator
          */
-        return (u32 *)&ary->wc_array[nchunks].wc_target.rs_length;
+        return &ary->wc_array[nchunks].wc_target.rs_length;
 }
 
-static u32 *decode_reply_array(u32 *va, u32 *vaend)
+static __be32 *decode_reply_array(__be32 *va, __be32 *vaend)
 {
         unsigned long start, end;
         int nchunks;
@@ -124,14 +124,14 @@ static u32 *decode_reply_array(u32 *va, u32 *vaend)
 
         /* Check for no reply-array */
         if (ary->wc_discrim == xdr_zero)
-                return (u32 *)&ary->wc_nchunks;
+                return &ary->wc_nchunks;
 
         if ((unsigned long)ary + sizeof(struct rpcrdma_write_array) >
             (unsigned long)vaend) {
                 dprintk("svcrdma: ary=%p, vaend=%p\n", ary, vaend);
                 return NULL;
         }
-        nchunks = ntohl(ary->wc_nchunks);
+        nchunks = be32_to_cpu(ary->wc_nchunks);
 
         start = (unsigned long)&ary->wc_array[0];
         end = (unsigned long)vaend;
@@ -142,15 +142,14 @@ static u32 *decode_reply_array(u32 *va, u32 *vaend)
                         ary, nchunks, vaend);
                 return NULL;
         }
-        return (u32 *)&ary->wc_array[nchunks];
+        return (__be32 *)&ary->wc_array[nchunks];
 }
 
 int svc_rdma_xdr_decode_req(struct rpcrdma_msg **rdma_req,
                             struct svc_rqst *rqstp)
 {
         struct rpcrdma_msg *rmsgp = NULL;
-        u32 *va;
-        u32 *vaend;
+        __be32 *va, *vaend;
         u32 hdr_len;
 
         rmsgp = (struct rpcrdma_msg *)rqstp->rq_arg.head[0].iov_base;
@@ -162,22 +161,17 @@ int svc_rdma_xdr_decode_req(struct rpcrdma_msg **rdma_req,
                 return -EINVAL;
         }
 
-        /* Decode the header */
-        rmsgp->rm_xid = ntohl(rmsgp->rm_xid);
-        rmsgp->rm_vers = ntohl(rmsgp->rm_vers);
-        rmsgp->rm_credit = ntohl(rmsgp->rm_credit);
-        rmsgp->rm_type = ntohl(rmsgp->rm_type);
-
-        if (rmsgp->rm_vers != RPCRDMA_VERSION)
+        if (rmsgp->rm_vers != rpcrdma_version)
                 return -ENOSYS;
 
         /* Pull in the extra for the padded case and bump our pointer */
-        if (rmsgp->rm_type == RDMA_MSGP) {
+        if (rmsgp->rm_type == rdma_msgp) {
                 int hdrlen;
+
                 rmsgp->rm_body.rm_padded.rm_align =
-                        ntohl(rmsgp->rm_body.rm_padded.rm_align);
+                        be32_to_cpu(rmsgp->rm_body.rm_padded.rm_align);
                 rmsgp->rm_body.rm_padded.rm_thresh =
-                        ntohl(rmsgp->rm_body.rm_padded.rm_thresh);
+                        be32_to_cpu(rmsgp->rm_body.rm_padded.rm_thresh);
 
                 va = &rmsgp->rm_body.rm_padded.rm_pempty[4];
                 rqstp->rq_arg.head[0].iov_base = va;
@@ -192,7 +186,7 @@ int svc_rdma_xdr_decode_req(struct rpcrdma_msg **rdma_req,
          * chunk list and a reply chunk list.
          */
         va = &rmsgp->rm_body.rm_chunks[0];
-        vaend = (u32 *)((unsigned long)rmsgp + rqstp->rq_arg.len);
+        vaend = (__be32 *)((unsigned long)rmsgp + rqstp->rq_arg.len);
         va = decode_read_list(va, vaend);
         if (!va)
                 return -EINVAL;
@@ -211,76 +205,20 @@ int svc_rdma_xdr_decode_req(struct rpcrdma_msg **rdma_req,
         return hdr_len;
 }
 
-int svc_rdma_xdr_decode_deferred_req(struct svc_rqst *rqstp)
-{
-        struct rpcrdma_msg *rmsgp = NULL;
-        struct rpcrdma_read_chunk *ch;
-        struct rpcrdma_write_array *ary;
-        u32 *va;
-        u32 hdrlen;
-
-        dprintk("svcrdma: processing deferred RDMA header on rqstp=%p\n",
-                rqstp);
-        rmsgp = (struct rpcrdma_msg *)rqstp->rq_arg.head[0].iov_base;
-
-        /* Pull in the extra for the padded case and bump our pointer */
-        if (rmsgp->rm_type == RDMA_MSGP) {
-                va = &rmsgp->rm_body.rm_padded.rm_pempty[4];
-                rqstp->rq_arg.head[0].iov_base = va;
-                hdrlen = (u32)((unsigned long)va - (unsigned long)rmsgp);
-                rqstp->rq_arg.head[0].iov_len -= hdrlen;
-                return hdrlen;
-        }
-
-        /*
-         * Skip all chunks to find RPC msg. These were previously processed
-         */
-        va = &rmsgp->rm_body.rm_chunks[0];
-
-        /* Skip read-list */
-        for (ch = (struct rpcrdma_read_chunk *)va;
-             ch->rc_discrim != xdr_zero; ch++);
-        va = (u32 *)&ch->rc_position;
-
-        /* Skip write-list */
-        ary = (struct rpcrdma_write_array *)va;
-        if (ary->wc_discrim == xdr_zero)
-                va = (u32 *)&ary->wc_nchunks;
-        else
-                /*
-                 * rs_length is the 2nd 4B field in wc_target and taking its
-                 * address skips the list terminator
-                 */
-                va = (u32 *)&ary->wc_array[ary->wc_nchunks].wc_target.rs_length;
-
-        /* Skip reply-array */
-        ary = (struct rpcrdma_write_array *)va;
-        if (ary->wc_discrim == xdr_zero)
-                va = (u32 *)&ary->wc_nchunks;
-        else
-                va = (u32 *)&ary->wc_array[ary->wc_nchunks];
-
-        rqstp->rq_arg.head[0].iov_base = va;
-        hdrlen = (unsigned long)va - (unsigned long)rmsgp;
-        rqstp->rq_arg.head[0].iov_len -= hdrlen;
-
-        return hdrlen;
-}
-
 int svc_rdma_xdr_encode_error(struct svcxprt_rdma *xprt,
                               struct rpcrdma_msg *rmsgp,
-                              enum rpcrdma_errcode err, u32 *va)
+                              enum rpcrdma_errcode err, __be32 *va)
 {
-        u32 *startp = va;
+        __be32 *startp = va;
 
-        *va++ = htonl(rmsgp->rm_xid);
-        *va++ = htonl(rmsgp->rm_vers);
-        *va++ = htonl(xprt->sc_max_requests);
-        *va++ = htonl(RDMA_ERROR);
-        *va++ = htonl(err);
+        *va++ = rmsgp->rm_xid;
+        *va++ = rmsgp->rm_vers;
+        *va++ = cpu_to_be32(xprt->sc_max_requests);
+        *va++ = rdma_error;
+        *va++ = cpu_to_be32(err);
         if (err == ERR_VERS) {
-                *va++ = htonl(RPCRDMA_VERSION);
-                *va++ = htonl(RPCRDMA_VERSION);
+                *va++ = rpcrdma_version;
+                *va++ = rpcrdma_version;
         }
 
         return (int)((unsigned long)va - (unsigned long)startp);
@@ -297,7 +235,7 @@ int svc_rdma_xdr_get_reply_hdr_len(struct rpcrdma_msg *rmsgp)
                 &rmsgp->rm_body.rm_chunks[1];
         if (wr_ary->wc_discrim)
                 wr_ary = (struct rpcrdma_write_array *)
-                        &wr_ary->wc_array[ntohl(wr_ary->wc_nchunks)].
+                        &wr_ary->wc_array[be32_to_cpu(wr_ary->wc_nchunks)].
                         wc_target.rs_length;
         else
                 wr_ary = (struct rpcrdma_write_array *)
@@ -306,7 +244,7 @@ int svc_rdma_xdr_get_reply_hdr_len(struct rpcrdma_msg *rmsgp)
         /* skip reply array */
         if (wr_ary->wc_discrim)
                 wr_ary = (struct rpcrdma_write_array *)
-                        &wr_ary->wc_array[ntohl(wr_ary->wc_nchunks)];
+                        &wr_ary->wc_array[be32_to_cpu(wr_ary->wc_nchunks)];
         else
                 wr_ary = (struct rpcrdma_write_array *)
                         &wr_ary->wc_nchunks;
@@ -325,7 +263,7 @@ void svc_rdma_xdr_encode_write_list(struct rpcrdma_msg *rmsgp, int chunks)
         ary = (struct rpcrdma_write_array *)
                 &rmsgp->rm_body.rm_chunks[1];
         ary->wc_discrim = xdr_one;
-        ary->wc_nchunks = htonl(chunks);
+        ary->wc_nchunks = cpu_to_be32(chunks);
 
         /* write-list terminator */
         ary->wc_array[chunks].wc_target.rs_handle = xdr_zero;
@@ -338,7 +276,7 @@ void svc_rdma_xdr_encode_reply_array(struct rpcrdma_write_array *ary,
                                  int chunks)
 {
         ary->wc_discrim = xdr_one;
-        ary->wc_nchunks = htonl(chunks);
+        ary->wc_nchunks = cpu_to_be32(chunks);
 }
 
 void svc_rdma_xdr_encode_array_chunk(struct rpcrdma_write_array *ary,
@@ -350,7 +288,7 @@ void svc_rdma_xdr_encode_array_chunk(struct rpcrdma_write_array *ary,
         struct rpcrdma_segment *seg = &ary->wc_array[chunk_no].wc_target;
         seg->rs_handle = rs_handle;
         seg->rs_offset = rs_offset;
-        seg->rs_length = htonl(write_len);
+        seg->rs_length = cpu_to_be32(write_len);
 }
 
 void svc_rdma_xdr_encode_reply_header(struct svcxprt_rdma *xprt,
@@ -358,10 +296,10 @@ void svc_rdma_xdr_encode_reply_header(struct svcxprt_rdma *xprt,
                                   struct rpcrdma_msg *rdma_resp,
                                   enum rpcrdma_proc rdma_type)
 {
-        rdma_resp->rm_xid = htonl(rdma_argp->rm_xid);
-        rdma_resp->rm_vers = htonl(rdma_argp->rm_vers);
-        rdma_resp->rm_credit = htonl(xprt->sc_max_requests);
-        rdma_resp->rm_type = htonl(rdma_type);
+        rdma_resp->rm_xid = rdma_argp->rm_xid;
+        rdma_resp->rm_vers = rdma_argp->rm_vers;
+        rdma_resp->rm_credit = cpu_to_be32(xprt->sc_max_requests);
+        rdma_resp->rm_type = cpu_to_be32(rdma_type);
 
         /* Encode <nul> chunks lists */
         rdma_resp->rm_body.rm_chunks[0] = xdr_zero;
diff --git a/net/sunrpc/xprtrdma/svc_rdma_recvfrom.c b/net/sunrpc/xprtrdma/svc_rdma_recvfrom.c
index 86b44164172b..2e1348bde325 100644
--- a/net/sunrpc/xprtrdma/svc_rdma_recvfrom.c
+++ b/net/sunrpc/xprtrdma/svc_rdma_recvfrom.c
@@ -85,7 +85,7 @@ static void rdma_build_arg_xdr(struct svc_rqst *rqstp,
 
         /* RDMA_NOMSG: RDMA READ data should land just after RDMA RECV data */
         rmsgp = (struct rpcrdma_msg *)rqstp->rq_arg.head[0].iov_base;
-        if (be32_to_cpu(rmsgp->rm_type) == RDMA_NOMSG)
+        if (rmsgp->rm_type == rdma_nomsg)
                 rqstp->rq_arg.pages = &rqstp->rq_pages[0];
         else
                 rqstp->rq_arg.pages = &rqstp->rq_pages[1];
diff --git a/net/sunrpc/xprtrdma/svc_rdma_sendto.c b/net/sunrpc/xprtrdma/svc_rdma_sendto.c
index 7de33d1af9b6..d25cd430f9ff 100644
--- a/net/sunrpc/xprtrdma/svc_rdma_sendto.c
+++ b/net/sunrpc/xprtrdma/svc_rdma_sendto.c
@@ -240,6 +240,7 @@ static int send_write_chunks(struct svcxprt_rdma *xprt,
         u32 xdr_off;
         int chunk_off;
         int chunk_no;
+        int nchunks;
         struct rpcrdma_write_array *arg_ary;
         struct rpcrdma_write_array *res_ary;
         int ret;
@@ -251,14 +252,15 @@ static int send_write_chunks(struct svcxprt_rdma *xprt,
                 &rdma_resp->rm_body.rm_chunks[1];
 
         /* Write chunks start at the pagelist */
+        nchunks = be32_to_cpu(arg_ary->wc_nchunks);
         for (xdr_off = rqstp->rq_res.head[0].iov_len, chunk_no = 0;
-             xfer_len && chunk_no < arg_ary->wc_nchunks;
+             xfer_len && chunk_no < nchunks;
              chunk_no++) {
                 struct rpcrdma_segment *arg_ch;
                 u64 rs_offset;
 
                 arg_ch = &arg_ary->wc_array[chunk_no].wc_target;
-                write_len = min(xfer_len, ntohl(arg_ch->rs_length));
+                write_len = min(xfer_len, be32_to_cpu(arg_ch->rs_length));
 
                 /* Prepare the response chunk given the length actually
                  * written */
@@ -270,7 +272,7 @@ static int send_write_chunks(struct svcxprt_rdma *xprt,
                 chunk_off = 0;
                 while (write_len) {
                         ret = send_write(xprt, rqstp,
-                                         ntohl(arg_ch->rs_handle),
+                                         be32_to_cpu(arg_ch->rs_handle),
                                          rs_offset + chunk_off,
                                          xdr_off,
                                          write_len,
@@ -318,13 +320,13 @@ static int send_reply_chunks(struct svcxprt_rdma *xprt,
                 &rdma_resp->rm_body.rm_chunks[2];
 
         /* xdr offset starts at RPC message */
-        nchunks = ntohl(arg_ary->wc_nchunks);
+        nchunks = be32_to_cpu(arg_ary->wc_nchunks);
         for (xdr_off = 0, chunk_no = 0;
              xfer_len && chunk_no < nchunks;
              chunk_no++) {
                 u64 rs_offset;
                 ch = &arg_ary->wc_array[chunk_no].wc_target;
-                write_len = min(xfer_len, htonl(ch->rs_length));
+                write_len = min(xfer_len, be32_to_cpu(ch->rs_length));
 
                 /* Prepare the reply chunk given the length actually
                  * written */
@@ -335,7 +337,7 @@ static int send_reply_chunks(struct svcxprt_rdma *xprt,
                 chunk_off = 0;
                 while (write_len) {
                         ret = send_write(xprt, rqstp,
-                                         ntohl(ch->rs_handle),
+                                         be32_to_cpu(ch->rs_handle),
                                          rs_offset + chunk_off,
                                          xdr_off,
                                          write_len,
@@ -515,7 +517,7 @@ int svc_rdma_sendto(struct svc_rqst *rqstp)
         inline_bytes = rqstp->rq_res.len;
 
         /* Create the RDMA response header */
-        res_page = svc_rdma_get_page();
+        res_page = alloc_page(GFP_KERNEL | __GFP_NOFAIL);
         rdma_resp = page_address(res_page);
         reply_ary = svc_rdma_get_reply_array(rdma_argp);
         if (reply_ary)
diff --git a/net/sunrpc/xprtrdma/svc_rdma_transport.c b/net/sunrpc/xprtrdma/svc_rdma_transport.c
index f4cfa764d76f..6b36279e4288 100644
--- a/net/sunrpc/xprtrdma/svc_rdma_transport.c
+++ b/net/sunrpc/xprtrdma/svc_rdma_transport.c
@@ -91,7 +91,7 @@ struct svc_xprt_class svc_rdma_class = {
         .xcl_name = "rdma",
         .xcl_owner = THIS_MODULE,
         .xcl_ops = &svc_rdma_ops,
-        .xcl_max_payload = RPCSVC_MAXPAYLOAD_RDMA,
+        .xcl_max_payload = RPCRDMA_MAXPAYLOAD,
         .xcl_ident = XPRT_TRANSPORT_RDMA,
 };
 
@@ -99,12 +99,8 @@ struct svc_rdma_op_ctxt *svc_rdma_get_context(struct svcxprt_rdma *xprt)
 {
         struct svc_rdma_op_ctxt *ctxt;
 
-        while (1) {
-                ctxt = kmem_cache_alloc(svc_rdma_ctxt_cachep, GFP_KERNEL);
-                if (ctxt)
-                        break;
-                schedule_timeout_uninterruptible(msecs_to_jiffies(500));
-        }
+        ctxt = kmem_cache_alloc(svc_rdma_ctxt_cachep,
+                                GFP_KERNEL | __GFP_NOFAIL);
         ctxt->xprt = xprt;
         INIT_LIST_HEAD(&ctxt->dto_q);
         ctxt->count = 0;
@@ -156,12 +152,8 @@ void svc_rdma_put_context(struct svc_rdma_op_ctxt *ctxt, int free_pages)
 struct svc_rdma_req_map *svc_rdma_get_req_map(void)
 {
         struct svc_rdma_req_map *map;
-        while (1) {
-                map = kmem_cache_alloc(svc_rdma_map_cachep, GFP_KERNEL);
-                if (map)
-                        break;
-                schedule_timeout_uninterruptible(msecs_to_jiffies(500));
-        }
+        map = kmem_cache_alloc(svc_rdma_map_cachep,
+                               GFP_KERNEL | __GFP_NOFAIL);
         map->count = 0;
         return map;
 }
@@ -493,18 +485,6 @@ static struct svcxprt_rdma *rdma_create_xprt(struct svc_serv *serv,
         return cma_xprt;
 }
 
-struct page *svc_rdma_get_page(void)
-{
-        struct page *page;
-
-        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 1s\n");
-                schedule_timeout_uninterruptible(msecs_to_jiffies(1000));
-        }
-        return page;
-}
-
 int svc_rdma_post_recv(struct svcxprt_rdma *xprt)
 {
         struct ib_recv_wr recv_wr, *bad_recv_wr;
@@ -523,7 +503,7 @@ int svc_rdma_post_recv(struct svcxprt_rdma *xprt)
                         pr_err("svcrdma: Too many sges (%d)\n", sge_no);
                         goto err_put_ctxt;
                 }
-                page = svc_rdma_get_page();
+                page = alloc_page(GFP_KERNEL | __GFP_NOFAIL);
                 ctxt->pages[sge_no] = page;
                 pa = ib_dma_map_page(xprt->sc_cm_id->device,
                                      page, 0, PAGE_SIZE,
@@ -1318,11 +1298,11 @@ void svc_rdma_send_error(struct svcxprt_rdma *xprt, struct rpcrdma_msg *rmsgp,
         struct ib_send_wr err_wr;
         struct page *p;
         struct svc_rdma_op_ctxt *ctxt;
-        u32 *va;
+        __be32 *va;
         int length;
         int ret;
 
-        p = svc_rdma_get_page();
+        p = alloc_page(GFP_KERNEL | __GFP_NOFAIL);
         va = page_address(p);
 
         /* XDR encode error */
diff --git a/net/sunrpc/xprtrdma/transport.c b/net/sunrpc/xprtrdma/transport.c
index 54f23b1be986..436da2caec95 100644
--- a/net/sunrpc/xprtrdma/transport.c
+++ b/net/sunrpc/xprtrdma/transport.c
@@ -48,7 +48,6 @@
  */
 
 #include <linux/module.h>
-#include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/seq_file.h>
 #include <linux/sunrpc/addr.h>
@@ -59,11 +58,6 @@
 # define RPCDBG_FACILITY        RPCDBG_TRANS
 #endif
 
-MODULE_LICENSE("Dual BSD/GPL");
-
-MODULE_DESCRIPTION("RPC/RDMA Transport for Linux kernel NFS");
-MODULE_AUTHOR("Network Appliance, Inc.");
-
 /*
  * tunables
  */
@@ -711,7 +705,7 @@ static struct xprt_class xprt_rdma = {
         .setup                  = xprt_setup_rdma,
 };
 
-static void __exit xprt_rdma_cleanup(void)
+void xprt_rdma_cleanup(void)
 {
         int rc;
 
@@ -728,7 +722,7 @@ static void __exit xprt_rdma_cleanup(void)
                         __func__, rc);
 }
 
-static int __init xprt_rdma_init(void)
+int xprt_rdma_init(void)
 {
         int rc;
 
@@ -753,6 +747,3 @@ static int __init xprt_rdma_init(void)
 #endif
         return 0;
 }
-
-module_init(xprt_rdma_init);
-module_exit(xprt_rdma_cleanup);
diff --git a/net/sunrpc/xprtrdma/xprt_rdma.h b/net/sunrpc/xprtrdma/xprt_rdma.h
index 78e0b8beaa36..58163b88738c 100644
--- a/net/sunrpc/xprtrdma/xprt_rdma.h
+++ b/net/sunrpc/xprtrdma/xprt_rdma.h
@@ -480,6 +480,11 @@ void rpcrdma_reply_handler(struct rpcrdma_rep *);
  */
 int rpcrdma_marshal_req(struct rpc_rqst *);
 
+/* RPC/RDMA module init - xprtrdma/transport.c
+ */
+int xprt_rdma_init(void);
+void xprt_rdma_cleanup(void);
+
 /* Temporary NFS request map cache. Created in svc_rdma.c  */
 extern struct kmem_cache *svc_rdma_map_cachep;
 /* WR context cache. Created in svc_rdma.c  */
@@ -487,10 +492,4 @@ extern struct kmem_cache *svc_rdma_ctxt_cachep;
 /* Workqueue created in svc_rdma.c */
 extern struct workqueue_struct *svc_rdma_wq;
 
-#if RPCSVC_MAXPAYLOAD < (RPCRDMA_MAX_DATA_SEGS << PAGE_SHIFT)
-#define RPCSVC_MAXPAYLOAD_RDMA RPCSVC_MAXPAYLOAD
-#else
-#define RPCSVC_MAXPAYLOAD_RDMA (RPCRDMA_MAX_DATA_SEGS << PAGE_SHIFT)
-#endif
-
 #endif                          /* _LINUX_SUNRPC_XPRT_RDMA_H */