Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6] / net / sunrpc / xprtrdma / svc_rdma_recvfrom.c
1 /*
2  * Copyright (c) 2005-2006 Network Appliance, Inc. All rights reserved.
3  *
4  * This software is available to you under a choice of one of two
5  * licenses.  You may choose to be licensed under the terms of the GNU
6  * General Public License (GPL) Version 2, available from the file
7  * COPYING in the main directory of this source tree, or the BSD-type
8  * license below:
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  *
14  *      Redistributions of source code must retain the above copyright
15  *      notice, this list of conditions and the following disclaimer.
16  *
17  *      Redistributions in binary form must reproduce the above
18  *      copyright notice, this list of conditions and the following
19  *      disclaimer in the documentation and/or other materials provided
20  *      with the distribution.
21  *
22  *      Neither the name of the Network Appliance, Inc. nor the names of
23  *      its contributors may be used to endorse or promote products
24  *      derived from this software without specific prior written
25  *      permission.
26  *
27  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
28  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
29  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
30  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
31  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
32  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
33  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
34  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
35  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
36  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
37  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38  *
39  * Author: Tom Tucker <tom@opengridcomputing.com>
40  */
41
42 #include <linux/sunrpc/debug.h>
43 #include <linux/sunrpc/rpc_rdma.h>
44 #include <linux/spinlock.h>
45 #include <asm/unaligned.h>
46 #include <rdma/ib_verbs.h>
47 #include <rdma/rdma_cm.h>
48 #include <linux/sunrpc/svc_rdma.h>
49
50 #define RPCDBG_FACILITY RPCDBG_SVCXPRT
51
52 /*
53  * Replace the pages in the rq_argpages array with the pages from the SGE in
54  * the RDMA_RECV completion. The SGL should contain full pages up until the
55  * last one.
56  */
57 static void rdma_build_arg_xdr(struct svc_rqst *rqstp,
58                                struct svc_rdma_op_ctxt *ctxt,
59                                u32 byte_count)
60 {
61         struct page *page;
62         u32 bc;
63         int sge_no;
64
65         /* Swap the page in the SGE with the page in argpages */
66         page = ctxt->pages[0];
67         put_page(rqstp->rq_pages[0]);
68         rqstp->rq_pages[0] = page;
69
70         /* Set up the XDR head */
71         rqstp->rq_arg.head[0].iov_base = page_address(page);
72         rqstp->rq_arg.head[0].iov_len = min(byte_count, ctxt->sge[0].length);
73         rqstp->rq_arg.len = byte_count;
74         rqstp->rq_arg.buflen = byte_count;
75
76         /* Compute bytes past head in the SGL */
77         bc = byte_count - rqstp->rq_arg.head[0].iov_len;
78
79         /* If data remains, store it in the pagelist */
80         rqstp->rq_arg.page_len = bc;
81         rqstp->rq_arg.page_base = 0;
82         rqstp->rq_arg.pages = &rqstp->rq_pages[1];
83         sge_no = 1;
84         while (bc && sge_no < ctxt->count) {
85                 page = ctxt->pages[sge_no];
86                 put_page(rqstp->rq_pages[sge_no]);
87                 rqstp->rq_pages[sge_no] = page;
88                 bc -= min(bc, ctxt->sge[sge_no].length);
89                 rqstp->rq_arg.buflen += ctxt->sge[sge_no].length;
90                 sge_no++;
91         }
92         rqstp->rq_respages = &rqstp->rq_pages[sge_no];
93
94         /* We should never run out of SGE because the limit is defined to
95          * support the max allowed RPC data length
96          */
97         BUG_ON(bc && (sge_no == ctxt->count));
98         BUG_ON((rqstp->rq_arg.head[0].iov_len + rqstp->rq_arg.page_len)
99                != byte_count);
100         BUG_ON(rqstp->rq_arg.len != byte_count);
101
102         /* If not all pages were used from the SGL, free the remaining ones */
103         bc = sge_no;
104         while (sge_no < ctxt->count) {
105                 page = ctxt->pages[sge_no++];
106                 put_page(page);
107         }
108         ctxt->count = bc;
109
110         /* Set up tail */
111         rqstp->rq_arg.tail[0].iov_base = NULL;
112         rqstp->rq_arg.tail[0].iov_len = 0;
113 }
114
115 /* Encode a read-chunk-list as an array of IB SGE
116  *
117  * Assumptions:
118  * - chunk[0]->position points to pages[0] at an offset of 0
119  * - pages[] is not physically or virtually contigous and consists of
120  *   PAGE_SIZE elements.
121  *
122  * Output:
123  * - sge array pointing into pages[] array.
124  * - chunk_sge array specifying sge index and count for each
125  *   chunk in the read list
126  *
127  */
128 static int rdma_rcl_to_sge(struct svcxprt_rdma *xprt,
129                            struct svc_rqst *rqstp,
130                            struct svc_rdma_op_ctxt *head,
131                            struct rpcrdma_msg *rmsgp,
132                            struct svc_rdma_req_map *rpl_map,
133                            struct svc_rdma_req_map *chl_map,
134                            int ch_count,
135                            int byte_count)
136 {
137         int sge_no;
138         int sge_bytes;
139         int page_off;
140         int page_no;
141         int ch_bytes;
142         int ch_no;
143         struct rpcrdma_read_chunk *ch;
144
145         sge_no = 0;
146         page_no = 0;
147         page_off = 0;
148         ch = (struct rpcrdma_read_chunk *)&rmsgp->rm_body.rm_chunks[0];
149         ch_no = 0;
150         ch_bytes = ch->rc_target.rs_length;
151         head->arg.head[0] = rqstp->rq_arg.head[0];
152         head->arg.tail[0] = rqstp->rq_arg.tail[0];
153         head->arg.pages = &head->pages[head->count];
154         head->hdr_count = head->count; /* save count of hdr pages */
155         head->arg.page_base = 0;
156         head->arg.page_len = ch_bytes;
157         head->arg.len = rqstp->rq_arg.len + ch_bytes;
158         head->arg.buflen = rqstp->rq_arg.buflen + ch_bytes;
159         head->count++;
160         chl_map->ch[0].start = 0;
161         while (byte_count) {
162                 rpl_map->sge[sge_no].iov_base =
163                         page_address(rqstp->rq_arg.pages[page_no]) + page_off;
164                 sge_bytes = min_t(int, PAGE_SIZE-page_off, ch_bytes);
165                 rpl_map->sge[sge_no].iov_len = sge_bytes;
166                 /*
167                  * Don't bump head->count here because the same page
168                  * may be used by multiple SGE.
169                  */
170                 head->arg.pages[page_no] = rqstp->rq_arg.pages[page_no];
171                 rqstp->rq_respages = &rqstp->rq_arg.pages[page_no+1];
172
173                 byte_count -= sge_bytes;
174                 ch_bytes -= sge_bytes;
175                 sge_no++;
176                 /*
177                  * If all bytes for this chunk have been mapped to an
178                  * SGE, move to the next SGE
179                  */
180                 if (ch_bytes == 0) {
181                         chl_map->ch[ch_no].count =
182                                 sge_no - chl_map->ch[ch_no].start;
183                         ch_no++;
184                         ch++;
185                         chl_map->ch[ch_no].start = sge_no;
186                         ch_bytes = ch->rc_target.rs_length;
187                         /* If bytes remaining account for next chunk */
188                         if (byte_count) {
189                                 head->arg.page_len += ch_bytes;
190                                 head->arg.len += ch_bytes;
191                                 head->arg.buflen += ch_bytes;
192                         }
193                 }
194                 /*
195                  * If this SGE consumed all of the page, move to the
196                  * next page
197                  */
198                 if ((sge_bytes + page_off) == PAGE_SIZE) {
199                         page_no++;
200                         page_off = 0;
201                         /*
202                          * If there are still bytes left to map, bump
203                          * the page count
204                          */
205                         if (byte_count)
206                                 head->count++;
207                 } else
208                         page_off += sge_bytes;
209         }
210         BUG_ON(byte_count != 0);
211         return sge_no;
212 }
213
214 static void rdma_set_ctxt_sge(struct svcxprt_rdma *xprt,
215                               struct svc_rdma_op_ctxt *ctxt,
216                               struct kvec *vec,
217                               u64 *sgl_offset,
218                               int count)
219 {
220         int i;
221
222         ctxt->count = count;
223         ctxt->direction = DMA_FROM_DEVICE;
224         for (i = 0; i < count; i++) {
225                 atomic_inc(&xprt->sc_dma_used);
226                 ctxt->sge[i].addr =
227                         ib_dma_map_single(xprt->sc_cm_id->device,
228                                           vec[i].iov_base, vec[i].iov_len,
229                                           DMA_FROM_DEVICE);
230                 ctxt->sge[i].length = vec[i].iov_len;
231                 ctxt->sge[i].lkey = xprt->sc_phys_mr->lkey;
232                 *sgl_offset = *sgl_offset + vec[i].iov_len;
233         }
234 }
235
236 static int rdma_read_max_sge(struct svcxprt_rdma *xprt, int sge_count)
237 {
238         if ((RDMA_TRANSPORT_IWARP ==
239              rdma_node_get_transport(xprt->sc_cm_id->
240                                      device->node_type))
241             && sge_count > 1)
242                 return 1;
243         else
244                 return min_t(int, sge_count, xprt->sc_max_sge);
245 }
246
247 /*
248  * Use RDMA_READ to read data from the advertised client buffer into the
249  * XDR stream starting at rq_arg.head[0].iov_base.
250  * Each chunk in the array
251  * contains the following fields:
252  * discrim      - '1', This isn't used for data placement
253  * position     - The xdr stream offset (the same for every chunk)
254  * handle       - RMR for client memory region
255  * length       - data transfer length
256  * offset       - 64 bit tagged offset in remote memory region
257  *
258  * On our side, we need to read into a pagelist. The first page immediately
259  * follows the RPC header.
260  *
261  * This function returns:
262  * 0 - No error and no read-list found.
263  *
264  * 1 - Successful read-list processing. The data is not yet in
265  * the pagelist and therefore the RPC request must be deferred. The
266  * I/O completion will enqueue the transport again and
267  * svc_rdma_recvfrom will complete the request.
268  *
269  * <0 - Error processing/posting read-list.
270  *
271  * NOTE: The ctxt must not be touched after the last WR has been posted
272  * because the I/O completion processing may occur on another
273  * processor and free / modify the context. Ne touche pas!
274  */
275 static int rdma_read_xdr(struct svcxprt_rdma *xprt,
276                          struct rpcrdma_msg *rmsgp,
277                          struct svc_rqst *rqstp,
278                          struct svc_rdma_op_ctxt *hdr_ctxt)
279 {
280         struct ib_send_wr read_wr;
281         int err = 0;
282         int ch_no;
283         int ch_count;
284         int byte_count;
285         int sge_count;
286         u64 sgl_offset;
287         struct rpcrdma_read_chunk *ch;
288         struct svc_rdma_op_ctxt *ctxt = NULL;
289         struct svc_rdma_req_map *rpl_map;
290         struct svc_rdma_req_map *chl_map;
291
292         /* If no read list is present, return 0 */
293         ch = svc_rdma_get_read_chunk(rmsgp);
294         if (!ch)
295                 return 0;
296
297         /* Allocate temporary reply and chunk maps */
298         rpl_map = svc_rdma_get_req_map();
299         chl_map = svc_rdma_get_req_map();
300
301         svc_rdma_rcl_chunk_counts(ch, &ch_count, &byte_count);
302         if (ch_count > RPCSVC_MAXPAGES)
303                 return -EINVAL;
304         sge_count = rdma_rcl_to_sge(xprt, rqstp, hdr_ctxt, rmsgp,
305                                     rpl_map, chl_map,
306                                     ch_count, byte_count);
307         sgl_offset = 0;
308         ch_no = 0;
309
310         for (ch = (struct rpcrdma_read_chunk *)&rmsgp->rm_body.rm_chunks[0];
311              ch->rc_discrim != 0; ch++, ch_no++) {
312 next_sge:
313                 ctxt = svc_rdma_get_context(xprt);
314                 ctxt->direction = DMA_FROM_DEVICE;
315                 clear_bit(RDMACTXT_F_LAST_CTXT, &ctxt->flags);
316
317                 /* Prepare READ WR */
318                 memset(&read_wr, 0, sizeof read_wr);
319                 ctxt->wr_op = IB_WR_RDMA_READ;
320                 read_wr.wr_id = (unsigned long)ctxt;
321                 read_wr.opcode = IB_WR_RDMA_READ;
322                 read_wr.send_flags = IB_SEND_SIGNALED;
323                 read_wr.wr.rdma.rkey = ch->rc_target.rs_handle;
324                 read_wr.wr.rdma.remote_addr =
325                         get_unaligned(&(ch->rc_target.rs_offset)) +
326                         sgl_offset;
327                 read_wr.sg_list = ctxt->sge;
328                 read_wr.num_sge =
329                         rdma_read_max_sge(xprt, chl_map->ch[ch_no].count);
330                 rdma_set_ctxt_sge(xprt, ctxt,
331                                   &rpl_map->sge[chl_map->ch[ch_no].start],
332                                   &sgl_offset,
333                                   read_wr.num_sge);
334                 if (((ch+1)->rc_discrim == 0) &&
335                     (read_wr.num_sge == chl_map->ch[ch_no].count)) {
336                         /*
337                          * Mark the last RDMA_READ with a bit to
338                          * indicate all RPC data has been fetched from
339                          * the client and the RPC needs to be enqueued.
340                          */
341                         set_bit(RDMACTXT_F_LAST_CTXT, &ctxt->flags);
342                         ctxt->read_hdr = hdr_ctxt;
343                 }
344                 /* Post the read */
345                 err = svc_rdma_send(xprt, &read_wr);
346                 if (err) {
347                         printk(KERN_ERR "svcrdma: Error %d posting RDMA_READ\n",
348                                err);
349                         set_bit(XPT_CLOSE, &xprt->sc_xprt.xpt_flags);
350                         svc_rdma_put_context(ctxt, 0);
351                         goto out;
352                 }
353                 atomic_inc(&rdma_stat_read);
354
355                 if (read_wr.num_sge < chl_map->ch[ch_no].count) {
356                         chl_map->ch[ch_no].count -= read_wr.num_sge;
357                         chl_map->ch[ch_no].start += read_wr.num_sge;
358                         goto next_sge;
359                 }
360                 sgl_offset = 0;
361                 err = 1;
362         }
363
364  out:
365         svc_rdma_put_req_map(rpl_map);
366         svc_rdma_put_req_map(chl_map);
367
368         /* Detach arg pages. svc_recv will replenish them */
369         for (ch_no = 0; &rqstp->rq_pages[ch_no] < rqstp->rq_respages; ch_no++)
370                 rqstp->rq_pages[ch_no] = NULL;
371
372         /*
373          * Detach res pages. svc_release must see a resused count of
374          * zero or it will attempt to put them.
375          */
376         while (rqstp->rq_resused)
377                 rqstp->rq_respages[--rqstp->rq_resused] = NULL;
378
379         return err;
380 }
381
382 static int rdma_read_complete(struct svc_rqst *rqstp,
383                               struct svc_rdma_op_ctxt *head)
384 {
385         int page_no;
386         int ret;
387
388         BUG_ON(!head);
389
390         /* Copy RPC pages */
391         for (page_no = 0; page_no < head->count; page_no++) {
392                 put_page(rqstp->rq_pages[page_no]);
393                 rqstp->rq_pages[page_no] = head->pages[page_no];
394         }
395         /* Point rq_arg.pages past header */
396         rqstp->rq_arg.pages = &rqstp->rq_pages[head->hdr_count];
397         rqstp->rq_arg.page_len = head->arg.page_len;
398         rqstp->rq_arg.page_base = head->arg.page_base;
399
400         /* rq_respages starts after the last arg page */
401         rqstp->rq_respages = &rqstp->rq_arg.pages[page_no];
402         rqstp->rq_resused = 0;
403
404         /* Rebuild rq_arg head and tail. */
405         rqstp->rq_arg.head[0] = head->arg.head[0];
406         rqstp->rq_arg.tail[0] = head->arg.tail[0];
407         rqstp->rq_arg.len = head->arg.len;
408         rqstp->rq_arg.buflen = head->arg.buflen;
409
410         /* Free the context */
411         svc_rdma_put_context(head, 0);
412
413         /* XXX: What should this be? */
414         rqstp->rq_prot = IPPROTO_MAX;
415         svc_xprt_copy_addrs(rqstp, rqstp->rq_xprt);
416
417         ret = rqstp->rq_arg.head[0].iov_len
418                 + rqstp->rq_arg.page_len
419                 + rqstp->rq_arg.tail[0].iov_len;
420         dprintk("svcrdma: deferred read ret=%d, rq_arg.len =%d, "
421                 "rq_arg.head[0].iov_base=%p, rq_arg.head[0].iov_len = %zd\n",
422                 ret, rqstp->rq_arg.len, rqstp->rq_arg.head[0].iov_base,
423                 rqstp->rq_arg.head[0].iov_len);
424
425         svc_xprt_received(rqstp->rq_xprt);
426         return ret;
427 }
428
429 /*
430  * Set up the rqstp thread context to point to the RQ buffer. If
431  * necessary, pull additional data from the client with an RDMA_READ
432  * request.
433  */
434 int svc_rdma_recvfrom(struct svc_rqst *rqstp)
435 {
436         struct svc_xprt *xprt = rqstp->rq_xprt;
437         struct svcxprt_rdma *rdma_xprt =
438                 container_of(xprt, struct svcxprt_rdma, sc_xprt);
439         struct svc_rdma_op_ctxt *ctxt = NULL;
440         struct rpcrdma_msg *rmsgp;
441         int ret = 0;
442         int len;
443
444         dprintk("svcrdma: rqstp=%p\n", rqstp);
445
446         spin_lock_bh(&rdma_xprt->sc_rq_dto_lock);
447         if (!list_empty(&rdma_xprt->sc_read_complete_q)) {
448                 ctxt = list_entry(rdma_xprt->sc_read_complete_q.next,
449                                   struct svc_rdma_op_ctxt,
450                                   dto_q);
451                 list_del_init(&ctxt->dto_q);
452         }
453         if (ctxt) {
454                 spin_unlock_bh(&rdma_xprt->sc_rq_dto_lock);
455                 return rdma_read_complete(rqstp, ctxt);
456         }
457
458         if (!list_empty(&rdma_xprt->sc_rq_dto_q)) {
459                 ctxt = list_entry(rdma_xprt->sc_rq_dto_q.next,
460                                   struct svc_rdma_op_ctxt,
461                                   dto_q);
462                 list_del_init(&ctxt->dto_q);
463         } else {
464                 atomic_inc(&rdma_stat_rq_starve);
465                 clear_bit(XPT_DATA, &xprt->xpt_flags);
466                 ctxt = NULL;
467         }
468         spin_unlock_bh(&rdma_xprt->sc_rq_dto_lock);
469         if (!ctxt) {
470                 /* This is the EAGAIN path. The svc_recv routine will
471                  * return -EAGAIN, the nfsd thread will go to call into
472                  * svc_recv again and we shouldn't be on the active
473                  * transport list
474                  */
475                 if (test_bit(XPT_CLOSE, &xprt->xpt_flags))
476                         goto close_out;
477
478                 BUG_ON(ret);
479                 goto out;
480         }
481         dprintk("svcrdma: processing ctxt=%p on xprt=%p, rqstp=%p, status=%d\n",
482                 ctxt, rdma_xprt, rqstp, ctxt->wc_status);
483         BUG_ON(ctxt->wc_status != IB_WC_SUCCESS);
484         atomic_inc(&rdma_stat_recv);
485
486         /* Build up the XDR from the receive buffers. */
487         rdma_build_arg_xdr(rqstp, ctxt, ctxt->byte_len);
488
489         /* Decode the RDMA header. */
490         len = svc_rdma_xdr_decode_req(&rmsgp, rqstp);
491         rqstp->rq_xprt_hlen = len;
492
493         /* If the request is invalid, reply with an error */
494         if (len < 0) {
495                 if (len == -ENOSYS)
496                         svc_rdma_send_error(rdma_xprt, rmsgp, ERR_VERS);
497                 goto close_out;
498         }
499
500         /* Read read-list data. */
501         ret = rdma_read_xdr(rdma_xprt, rmsgp, rqstp, ctxt);
502         if (ret > 0) {
503                 /* read-list posted, defer until data received from client. */
504                 svc_xprt_received(xprt);
505                 return 0;
506         }
507         if (ret < 0) {
508                 /* Post of read-list failed, free context. */
509                 svc_rdma_put_context(ctxt, 1);
510                 return 0;
511         }
512
513         ret = rqstp->rq_arg.head[0].iov_len
514                 + rqstp->rq_arg.page_len
515                 + rqstp->rq_arg.tail[0].iov_len;
516         svc_rdma_put_context(ctxt, 0);
517  out:
518         dprintk("svcrdma: ret = %d, rq_arg.len =%d, "
519                 "rq_arg.head[0].iov_base=%p, rq_arg.head[0].iov_len = %zd\n",
520                 ret, rqstp->rq_arg.len,
521                 rqstp->rq_arg.head[0].iov_base,
522                 rqstp->rq_arg.head[0].iov_len);
523         rqstp->rq_prot = IPPROTO_MAX;
524         svc_xprt_copy_addrs(rqstp, xprt);
525         svc_xprt_received(xprt);
526         return ret;
527
528  close_out:
529         if (ctxt)
530                 svc_rdma_put_context(ctxt, 1);
531         dprintk("svcrdma: transport %p is closing\n", xprt);
532         /*
533          * Set the close bit and enqueue it. svc_recv will see the
534          * close bit and call svc_xprt_delete
535          */
536         set_bit(XPT_CLOSE, &xprt->xpt_flags);
537         svc_xprt_received(xprt);
538         return 0;
539 }