xprtrdma: Use gathered Send for large inline messages

[uclinux-h8/linux.git] / net / sunrpc / xprtrdma / transport.c

diff --git a/net/sunrpc/xprtrdma/transport.c b/net/sunrpc/xprtrdma/transport.c
index ecdc3ad..6a358ab 100644 (file)
--- a/net/sunrpc/xprtrdma/transport.c
+++ b/net/sunrpc/xprtrdma/transport.c
@@ -484,13 +484,13 @@ static bool
 rpcrdma_get_rdmabuf(struct rpcrdma_xprt *r_xprt, struct rpcrdma_req *req,
                    gfp_t flags)
 {
-       size_t size = r_xprt->rx_data.inline_wsize;
+       size_t size = RPCRDMA_HDRBUF_SIZE;
        struct rpcrdma_regbuf *rb;
 
        if (req->rl_rdmabuf)
                return true;
 
-       rb = rpcrdma_alloc_regbuf(&r_xprt->rx_ia, size, flags);
+       rb = rpcrdma_alloc_regbuf(size, DMA_TO_DEVICE, flags);
        if (IS_ERR(rb))
                return false;
 
@@ -499,30 +499,21 @@ rpcrdma_get_rdmabuf(struct rpcrdma_xprt *r_xprt, struct rpcrdma_req *req,
        return true;
 }
 
-/* RPC/RDMA marshaling may choose to send payload bearing ops inline,
- * if the resulting Call message is smaller than the inline threshold.
- * The value of the "rq_callsize" argument accounts for RPC header
- * requirements, but not for the data payload in these cases.
- *
- * See rpcrdma_inline_pullup.
- */
 static bool
 rpcrdma_get_sendbuf(struct rpcrdma_xprt *r_xprt, struct rpcrdma_req *req,
                    size_t size, gfp_t flags)
 {
        struct rpcrdma_regbuf *rb;
-       size_t min_size;
 
        if (req->rl_sendbuf && rdmab_length(req->rl_sendbuf) >= size)
                return true;
 
-       min_size = max_t(size_t, size, r_xprt->rx_data.inline_wsize);
-       rb = rpcrdma_alloc_regbuf(&r_xprt->rx_ia, min_size, flags);
+       rb = rpcrdma_alloc_regbuf(size, DMA_TO_DEVICE, flags);
        if (IS_ERR(rb))
                return false;
 
-       rpcrdma_free_regbuf(&r_xprt->rx_ia, req->rl_sendbuf);
-       r_xprt->rx_stats.hardway_register_count += min_size;
+       rpcrdma_free_regbuf(req->rl_sendbuf);
+       r_xprt->rx_stats.hardway_register_count += size;
        req->rl_sendbuf = rb;
        return true;
 }
@@ -547,11 +538,11 @@ rpcrdma_get_recvbuf(struct rpcrdma_xprt *r_xprt, struct rpcrdma_req *req,
        if (req->rl_recvbuf && rdmab_length(req->rl_recvbuf) >= size)
                return true;
 
-       rb = rpcrdma_alloc_regbuf(&r_xprt->rx_ia, size, flags);
+       rb = rpcrdma_alloc_regbuf(size, DMA_NONE, flags);
        if (IS_ERR(rb))
                return false;
 
-       rpcrdma_free_regbuf(&r_xprt->rx_ia, req->rl_recvbuf);
+       rpcrdma_free_regbuf(req->rl_recvbuf);
        r_xprt->rx_stats.hardway_register_count += size;
        req->rl_recvbuf = rb;
        return true;
@@ -623,14 +614,15 @@ xprt_rdma_free(struct rpc_task *task)
        struct rpc_rqst *rqst = task->tk_rqstp;
        struct rpcrdma_xprt *r_xprt = rpcx_to_rdmax(rqst->rq_xprt);
        struct rpcrdma_req *req = rpcr_to_rdmar(rqst);
+       struct rpcrdma_ia *ia = &r_xprt->rx_ia;
 
        if (req->rl_backchannel)
                return;
 
        dprintk("RPC:       %s: called on 0x%p\n", __func__, req->rl_reply);
 
-       r_xprt->rx_ia.ri_ops->ro_unmap_safe(r_xprt, req,
-                                           !RPC_IS_ASYNC(task));
+       ia->ri_ops->ro_unmap_safe(r_xprt, req, !RPC_IS_ASYNC(task));
+       rpcrdma_unmap_sges(ia, req);
        rpcrdma_buffer_put(req);
 }
 
@@ -730,10 +722,11 @@ void xprt_rdma_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
                   r_xprt->rx_stats.failed_marshal_count,
                   r_xprt->rx_stats.bad_reply_count,
                   r_xprt->rx_stats.nomsg_call_count);
-       seq_printf(seq, "%lu %lu %lu\n",
+       seq_printf(seq, "%lu %lu %lu %lu\n",
                   r_xprt->rx_stats.mrs_recovered,
                   r_xprt->rx_stats.mrs_orphaned,
-                  r_xprt->rx_stats.mrs_allocated);
+                  r_xprt->rx_stats.mrs_allocated,
+                  r_xprt->rx_stats.local_inv_needed);
 }
 
 static int