Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-2.6] / net / sunrpc / xprtrdma / xprt_rdma.h
1 /*
2  * Copyright (c) 2003-2007 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
40 #ifndef _LINUX_SUNRPC_XPRT_RDMA_H
41 #define _LINUX_SUNRPC_XPRT_RDMA_H
42
43 #include <linux/wait.h>                 /* wait_queue_head_t, etc */
44 #include <linux/spinlock.h>             /* spinlock_t, etc */
45 #include <asm/atomic.h>                 /* atomic_t, etc */
46
47 #include <rdma/rdma_cm.h>               /* RDMA connection api */
48 #include <rdma/ib_verbs.h>              /* RDMA verbs api */
49
50 #include <linux/sunrpc/clnt.h>          /* rpc_xprt */
51 #include <linux/sunrpc/rpc_rdma.h>      /* RPC/RDMA protocol */
52 #include <linux/sunrpc/xprtrdma.h>      /* xprt parameters */
53
54 /*
55  * Interface Adapter -- one per transport instance
56  */
57 struct rpcrdma_ia {
58         struct rdma_cm_id       *ri_id;
59         struct ib_pd            *ri_pd;
60         struct ib_mr            *ri_bind_mem;
61         struct completion       ri_done;
62         int                     ri_async_rc;
63         enum rpcrdma_memreg     ri_memreg_strategy;
64 };
65
66 /*
67  * RDMA Endpoint -- one per transport instance
68  */
69
70 struct rpcrdma_ep {
71         atomic_t                rep_cqcount;
72         int                     rep_cqinit;
73         int                     rep_connected;
74         struct rpcrdma_ia       *rep_ia;
75         struct ib_cq            *rep_cq;
76         struct ib_qp_init_attr  rep_attr;
77         wait_queue_head_t       rep_connect_wait;
78         struct ib_sge           rep_pad;        /* holds zeroed pad */
79         struct ib_mr            *rep_pad_mr;    /* holds zeroed pad */
80         void                    (*rep_func)(struct rpcrdma_ep *);
81         struct rpc_xprt         *rep_xprt;      /* for rep_func */
82         struct rdma_conn_param  rep_remote_cma;
83         struct sockaddr_storage rep_remote_addr;
84 };
85
86 #define INIT_CQCOUNT(ep) atomic_set(&(ep)->rep_cqcount, (ep)->rep_cqinit)
87 #define DECR_CQCOUNT(ep) atomic_sub_return(1, &(ep)->rep_cqcount)
88
89 /*
90  * struct rpcrdma_rep -- this structure encapsulates state required to recv
91  * and complete a reply, asychronously. It needs several pieces of
92  * state:
93  *   o recv buffer (posted to provider)
94  *   o ib_sge (also donated to provider)
95  *   o status of reply (length, success or not)
96  *   o bookkeeping state to get run by tasklet (list, etc)
97  *
98  * These are allocated during initialization, per-transport instance;
99  * however, the tasklet execution list itself is global, as it should
100  * always be pretty short.
101  *
102  * N of these are associated with a transport instance, and stored in
103  * struct rpcrdma_buffer. N is the max number of outstanding requests.
104  */
105
106 /* temporary static scatter/gather max */
107 #define RPCRDMA_MAX_DATA_SEGS   (8)     /* max scatter/gather */
108 #define RPCRDMA_MAX_SEGS        (RPCRDMA_MAX_DATA_SEGS + 2) /* head+tail = 2 */
109 #define MAX_RPCRDMAHDR  (\
110         /* max supported RPC/RDMA header */ \
111         sizeof(struct rpcrdma_msg) + (2 * sizeof(u32)) + \
112         (sizeof(struct rpcrdma_read_chunk) * RPCRDMA_MAX_SEGS) + sizeof(u32))
113
114 struct rpcrdma_buffer;
115
116 struct rpcrdma_rep {
117         unsigned int    rr_len;         /* actual received reply length */
118         struct rpcrdma_buffer *rr_buffer; /* home base for this structure */
119         struct rpc_xprt *rr_xprt;       /* needed for request/reply matching */
120         void (*rr_func)(struct rpcrdma_rep *);/* called by tasklet in softint */
121         struct list_head rr_list;       /* tasklet list */
122         wait_queue_head_t rr_unbind;    /* optional unbind wait */
123         struct ib_sge   rr_iov;         /* for posting */
124         struct ib_mr    *rr_handle;     /* handle for mem in rr_iov */
125         char    rr_base[MAX_RPCRDMAHDR]; /* minimal inline receive buffer */
126 };
127
128 /*
129  * struct rpcrdma_req -- structure central to the request/reply sequence.
130  *
131  * N of these are associated with a transport instance, and stored in
132  * struct rpcrdma_buffer. N is the max number of outstanding requests.
133  *
134  * It includes pre-registered buffer memory for send AND recv.
135  * The recv buffer, however, is not owned by this structure, and
136  * is "donated" to the hardware when a recv is posted. When a
137  * reply is handled, the recv buffer used is given back to the
138  * struct rpcrdma_req associated with the request.
139  *
140  * In addition to the basic memory, this structure includes an array
141  * of iovs for send operations. The reason is that the iovs passed to
142  * ib_post_{send,recv} must not be modified until the work request
143  * completes.
144  *
145  * NOTES:
146  *   o RPCRDMA_MAX_SEGS is the max number of addressible chunk elements we
147  *     marshal. The number needed varies depending on the iov lists that
148  *     are passed to us, the memory registration mode we are in, and if
149  *     physical addressing is used, the layout.
150  */
151
152 struct rpcrdma_mr_seg {         /* chunk descriptors */
153         union {                         /* chunk memory handles */
154                 struct ib_mr    *rl_mr;         /* if registered directly */
155                 struct rpcrdma_mw {             /* if registered from region */
156                         union {
157                                 struct ib_mw    *mw;
158                                 struct ib_fmr   *fmr;
159                         } r;
160                         struct list_head mw_list;
161                 } *rl_mw;
162         } mr_chunk;
163         u64             mr_base;        /* registration result */
164         u32             mr_rkey;        /* registration result */
165         u32             mr_len;         /* length of chunk or segment */
166         int             mr_nsegs;       /* number of segments in chunk or 0 */
167         enum dma_data_direction mr_dir; /* segment mapping direction */
168         dma_addr_t      mr_dma;         /* segment mapping address */
169         size_t          mr_dmalen;      /* segment mapping length */
170         struct page     *mr_page;       /* owning page, if any */
171         char            *mr_offset;     /* kva if no page, else offset */
172 };
173
174 struct rpcrdma_req {
175         size_t          rl_size;        /* actual length of buffer */
176         unsigned int    rl_niovs;       /* 0, 2 or 4 */
177         unsigned int    rl_nchunks;     /* non-zero if chunks */
178         struct rpcrdma_buffer *rl_buffer; /* home base for this structure */
179         struct rpcrdma_rep      *rl_reply;/* holder for reply buffer */
180         struct rpcrdma_mr_seg rl_segments[RPCRDMA_MAX_SEGS];/* chunk segments */
181         struct ib_sge   rl_send_iov[4]; /* for active requests */
182         struct ib_sge   rl_iov;         /* for posting */
183         struct ib_mr    *rl_handle;     /* handle for mem in rl_iov */
184         char            rl_base[MAX_RPCRDMAHDR]; /* start of actual buffer */
185         __u32           rl_xdr_buf[0];  /* start of returned rpc rq_buffer */
186 };
187 #define rpcr_to_rdmar(r) \
188         container_of((r)->rq_buffer, struct rpcrdma_req, rl_xdr_buf[0])
189
190 /*
191  * struct rpcrdma_buffer -- holds list/queue of pre-registered memory for
192  * inline requests/replies, and client/server credits.
193  *
194  * One of these is associated with a transport instance
195  */
196 struct rpcrdma_buffer {
197         spinlock_t      rb_lock;        /* protects indexes */
198         atomic_t        rb_credits;     /* most recent server credits */
199         unsigned long   rb_cwndscale;   /* cached framework rpc_cwndscale */
200         int             rb_max_requests;/* client max requests */
201         struct list_head rb_mws;        /* optional memory windows/fmrs */
202         int             rb_send_index;
203         struct rpcrdma_req      **rb_send_bufs;
204         int             rb_recv_index;
205         struct rpcrdma_rep      **rb_recv_bufs;
206         char            *rb_pool;
207 };
208 #define rdmab_to_ia(b) (&container_of((b), struct rpcrdma_xprt, rx_buf)->rx_ia)
209
210 /*
211  * Internal structure for transport instance creation. This
212  * exists primarily for modularity.
213  *
214  * This data should be set with mount options
215  */
216 struct rpcrdma_create_data_internal {
217         struct sockaddr_storage addr;   /* RDMA server address */
218         unsigned int    max_requests;   /* max requests (slots) in flight */
219         unsigned int    rsize;          /* mount rsize - max read hdr+data */
220         unsigned int    wsize;          /* mount wsize - max write hdr+data */
221         unsigned int    inline_rsize;   /* max non-rdma read data payload */
222         unsigned int    inline_wsize;   /* max non-rdma write data payload */
223         unsigned int    padding;        /* non-rdma write header padding */
224 };
225
226 #define RPCRDMA_INLINE_READ_THRESHOLD(rq) \
227         (rpcx_to_rdmad(rq->rq_task->tk_xprt).inline_rsize)
228
229 #define RPCRDMA_INLINE_WRITE_THRESHOLD(rq)\
230         (rpcx_to_rdmad(rq->rq_task->tk_xprt).inline_wsize)
231
232 #define RPCRDMA_INLINE_PAD_VALUE(rq)\
233         rpcx_to_rdmad(rq->rq_task->tk_xprt).padding
234
235 /*
236  * Statistics for RPCRDMA
237  */
238 struct rpcrdma_stats {
239         unsigned long           read_chunk_count;
240         unsigned long           write_chunk_count;
241         unsigned long           reply_chunk_count;
242
243         unsigned long long      total_rdma_request;
244         unsigned long long      total_rdma_reply;
245
246         unsigned long long      pullup_copy_count;
247         unsigned long long      fixup_copy_count;
248         unsigned long           hardway_register_count;
249         unsigned long           failed_marshal_count;
250         unsigned long           bad_reply_count;
251 };
252
253 /*
254  * RPCRDMA transport -- encapsulates the structures above for
255  * integration with RPC.
256  *
257  * The contained structures are embedded, not pointers,
258  * for convenience. This structure need not be visible externally.
259  *
260  * It is allocated and initialized during mount, and released
261  * during unmount.
262  */
263 struct rpcrdma_xprt {
264         struct rpc_xprt         xprt;
265         struct rpcrdma_ia       rx_ia;
266         struct rpcrdma_ep       rx_ep;
267         struct rpcrdma_buffer   rx_buf;
268         struct rpcrdma_create_data_internal rx_data;
269         struct delayed_work     rdma_connect;
270         struct rpcrdma_stats    rx_stats;
271 };
272
273 #define rpcx_to_rdmax(x) container_of(x, struct rpcrdma_xprt, xprt)
274 #define rpcx_to_rdmad(x) (rpcx_to_rdmax(x)->rx_data)
275
276 /*
277  * Interface Adapter calls - xprtrdma/verbs.c
278  */
279 int rpcrdma_ia_open(struct rpcrdma_xprt *, struct sockaddr *, int);
280 void rpcrdma_ia_close(struct rpcrdma_ia *);
281
282 /*
283  * Endpoint calls - xprtrdma/verbs.c
284  */
285 int rpcrdma_ep_create(struct rpcrdma_ep *, struct rpcrdma_ia *,
286                                 struct rpcrdma_create_data_internal *);
287 int rpcrdma_ep_destroy(struct rpcrdma_ep *, struct rpcrdma_ia *);
288 int rpcrdma_ep_connect(struct rpcrdma_ep *, struct rpcrdma_ia *);
289 int rpcrdma_ep_disconnect(struct rpcrdma_ep *, struct rpcrdma_ia *);
290
291 int rpcrdma_ep_post(struct rpcrdma_ia *, struct rpcrdma_ep *,
292                                 struct rpcrdma_req *);
293 int rpcrdma_ep_post_recv(struct rpcrdma_ia *, struct rpcrdma_ep *,
294                                 struct rpcrdma_rep *);
295
296 /*
297  * Buffer calls - xprtrdma/verbs.c
298  */
299 int rpcrdma_buffer_create(struct rpcrdma_buffer *, struct rpcrdma_ep *,
300                                 struct rpcrdma_ia *,
301                                 struct rpcrdma_create_data_internal *);
302 void rpcrdma_buffer_destroy(struct rpcrdma_buffer *);
303
304 struct rpcrdma_req *rpcrdma_buffer_get(struct rpcrdma_buffer *);
305 void rpcrdma_buffer_put(struct rpcrdma_req *);
306 void rpcrdma_recv_buffer_get(struct rpcrdma_req *);
307 void rpcrdma_recv_buffer_put(struct rpcrdma_rep *);
308
309 int rpcrdma_register_internal(struct rpcrdma_ia *, void *, int,
310                                 struct ib_mr **, struct ib_sge *);
311 int rpcrdma_deregister_internal(struct rpcrdma_ia *,
312                                 struct ib_mr *, struct ib_sge *);
313
314 int rpcrdma_register_external(struct rpcrdma_mr_seg *,
315                                 int, int, struct rpcrdma_xprt *);
316 int rpcrdma_deregister_external(struct rpcrdma_mr_seg *,
317                                 struct rpcrdma_xprt *, void *);
318
319 /*
320  * RPC/RDMA connection management calls - xprtrdma/rpc_rdma.c
321  */
322 void rpcrdma_conn_func(struct rpcrdma_ep *);
323 void rpcrdma_reply_handler(struct rpcrdma_rep *);
324
325 /*
326  * RPC/RDMA protocol calls - xprtrdma/rpc_rdma.c
327  */
328 int rpcrdma_marshal_req(struct rpc_rqst *);
329
330 #endif                          /* _LINUX_SUNRPC_XPRT_RDMA_H */