Commit | Line | Data |
---|---|---|
ef1eac0a TT |
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/xdr.h> | |
43 | #include <linux/sunrpc/debug.h> | |
44 | #include <asm/unaligned.h> | |
45 | #include <linux/sunrpc/rpc_rdma.h> | |
46 | #include <linux/sunrpc/svc_rdma.h> | |
47 | ||
48 | #define RPCDBG_FACILITY RPCDBG_SVCXPRT | |
49 | ||
50 | /* | |
51 | * Decodes a read chunk list. The expected format is as follows: | |
52 | * descrim : xdr_one | |
30b7e246 CL |
53 | * position : __be32 offset into XDR stream |
54 | * handle : __be32 RKEY | |
ef1eac0a TT |
55 | * . . . |
56 | * end-of-list: xdr_zero | |
57 | */ | |
30b7e246 | 58 | static __be32 *decode_read_list(__be32 *va, __be32 *vaend) |
ef1eac0a TT |
59 | { |
60 | struct rpcrdma_read_chunk *ch = (struct rpcrdma_read_chunk *)va; | |
61 | ||
62 | while (ch->rc_discrim != xdr_zero) { | |
ef1eac0a TT |
63 | if (((unsigned long)ch + sizeof(struct rpcrdma_read_chunk)) > |
64 | (unsigned long)vaend) { | |
65 | dprintk("svcrdma: vaend=%p, ch=%p\n", vaend, ch); | |
66 | return NULL; | |
67 | } | |
ef1eac0a TT |
68 | ch++; |
69 | } | |
30b7e246 | 70 | return &ch->rc_position; |
ef1eac0a TT |
71 | } |
72 | ||
ef1eac0a TT |
73 | /* |
74 | * Decodes a write chunk list. The expected format is as follows: | |
75 | * descrim : xdr_one | |
76 | * nchunks : <count> | |
30b7e246 CL |
77 | * handle : __be32 RKEY ---+ |
78 | * length : __be32 <len of segment> | | |
ef1eac0a TT |
79 | * offset : remove va + <count> |
80 | * . . . | | |
81 | * ---+ | |
82 | */ | |
30b7e246 | 83 | static __be32 *decode_write_list(__be32 *va, __be32 *vaend) |
ef1eac0a | 84 | { |
b2781e10 | 85 | unsigned long start, end; |
cec56c8f TT |
86 | int nchunks; |
87 | ||
ef1eac0a TT |
88 | struct rpcrdma_write_array *ary = |
89 | (struct rpcrdma_write_array *)va; | |
90 | ||
91 | /* Check for not write-array */ | |
92 | if (ary->wc_discrim == xdr_zero) | |
30b7e246 | 93 | return &ary->wc_nchunks; |
ef1eac0a TT |
94 | |
95 | if ((unsigned long)ary + sizeof(struct rpcrdma_write_array) > | |
96 | (unsigned long)vaend) { | |
97 | dprintk("svcrdma: ary=%p, vaend=%p\n", ary, vaend); | |
98 | return NULL; | |
99 | } | |
30b7e246 | 100 | nchunks = be32_to_cpu(ary->wc_nchunks); |
b2781e10 DC |
101 | |
102 | start = (unsigned long)&ary->wc_array[0]; | |
103 | end = (unsigned long)vaend; | |
104 | if (nchunks < 0 || | |
105 | nchunks > (SIZE_MAX - start) / sizeof(struct rpcrdma_write_chunk) || | |
106 | (start + (sizeof(struct rpcrdma_write_chunk) * nchunks)) > end) { | |
ef1eac0a | 107 | dprintk("svcrdma: ary=%p, wc_nchunks=%d, vaend=%p\n", |
cec56c8f | 108 | ary, nchunks, vaend); |
ef1eac0a TT |
109 | return NULL; |
110 | } | |
ef1eac0a TT |
111 | /* |
112 | * rs_length is the 2nd 4B field in wc_target and taking its | |
113 | * address skips the list terminator | |
114 | */ | |
30b7e246 | 115 | return &ary->wc_array[nchunks].wc_target.rs_length; |
ef1eac0a TT |
116 | } |
117 | ||
30b7e246 | 118 | static __be32 *decode_reply_array(__be32 *va, __be32 *vaend) |
ef1eac0a | 119 | { |
b2781e10 | 120 | unsigned long start, end; |
cec56c8f | 121 | int nchunks; |
ef1eac0a TT |
122 | struct rpcrdma_write_array *ary = |
123 | (struct rpcrdma_write_array *)va; | |
124 | ||
125 | /* Check for no reply-array */ | |
126 | if (ary->wc_discrim == xdr_zero) | |
30b7e246 | 127 | return &ary->wc_nchunks; |
ef1eac0a TT |
128 | |
129 | if ((unsigned long)ary + sizeof(struct rpcrdma_write_array) > | |
130 | (unsigned long)vaend) { | |
131 | dprintk("svcrdma: ary=%p, vaend=%p\n", ary, vaend); | |
132 | return NULL; | |
133 | } | |
30b7e246 | 134 | nchunks = be32_to_cpu(ary->wc_nchunks); |
b2781e10 DC |
135 | |
136 | start = (unsigned long)&ary->wc_array[0]; | |
137 | end = (unsigned long)vaend; | |
138 | if (nchunks < 0 || | |
139 | nchunks > (SIZE_MAX - start) / sizeof(struct rpcrdma_write_chunk) || | |
140 | (start + (sizeof(struct rpcrdma_write_chunk) * nchunks)) > end) { | |
ef1eac0a | 141 | dprintk("svcrdma: ary=%p, wc_nchunks=%d, vaend=%p\n", |
cec56c8f | 142 | ary, nchunks, vaend); |
ef1eac0a TT |
143 | return NULL; |
144 | } | |
30b7e246 | 145 | return (__be32 *)&ary->wc_array[nchunks]; |
ef1eac0a TT |
146 | } |
147 | ||
148 | int svc_rdma_xdr_decode_req(struct rpcrdma_msg **rdma_req, | |
149 | struct svc_rqst *rqstp) | |
150 | { | |
151 | struct rpcrdma_msg *rmsgp = NULL; | |
30b7e246 | 152 | __be32 *va, *vaend; |
ef1eac0a TT |
153 | u32 hdr_len; |
154 | ||
155 | rmsgp = (struct rpcrdma_msg *)rqstp->rq_arg.head[0].iov_base; | |
156 | ||
157 | /* Verify that there's enough bytes for header + something */ | |
158 | if (rqstp->rq_arg.len <= RPCRDMA_HDRLEN_MIN) { | |
159 | dprintk("svcrdma: header too short = %d\n", | |
160 | rqstp->rq_arg.len); | |
161 | return -EINVAL; | |
162 | } | |
163 | ||
30b7e246 | 164 | if (rmsgp->rm_vers != rpcrdma_version) |
ef1eac0a TT |
165 | return -ENOSYS; |
166 | ||
167 | /* Pull in the extra for the padded case and bump our pointer */ | |
30b7e246 | 168 | if (rmsgp->rm_type == rdma_msgp) { |
ef1eac0a | 169 | int hdrlen; |
30b7e246 | 170 | |
ef1eac0a | 171 | rmsgp->rm_body.rm_padded.rm_align = |
30b7e246 | 172 | be32_to_cpu(rmsgp->rm_body.rm_padded.rm_align); |
ef1eac0a | 173 | rmsgp->rm_body.rm_padded.rm_thresh = |
30b7e246 | 174 | be32_to_cpu(rmsgp->rm_body.rm_padded.rm_thresh); |
ef1eac0a TT |
175 | |
176 | va = &rmsgp->rm_body.rm_padded.rm_pempty[4]; | |
177 | rqstp->rq_arg.head[0].iov_base = va; | |
178 | hdrlen = (u32)((unsigned long)va - (unsigned long)rmsgp); | |
179 | rqstp->rq_arg.head[0].iov_len -= hdrlen; | |
180 | if (hdrlen > rqstp->rq_arg.len) | |
181 | return -EINVAL; | |
182 | return hdrlen; | |
183 | } | |
184 | ||
185 | /* The chunk list may contain either a read chunk list or a write | |
186 | * chunk list and a reply chunk list. | |
187 | */ | |
188 | va = &rmsgp->rm_body.rm_chunks[0]; | |
30b7e246 | 189 | vaend = (__be32 *)((unsigned long)rmsgp + rqstp->rq_arg.len); |
ef1eac0a TT |
190 | va = decode_read_list(va, vaend); |
191 | if (!va) | |
192 | return -EINVAL; | |
193 | va = decode_write_list(va, vaend); | |
194 | if (!va) | |
195 | return -EINVAL; | |
196 | va = decode_reply_array(va, vaend); | |
197 | if (!va) | |
198 | return -EINVAL; | |
199 | ||
200 | rqstp->rq_arg.head[0].iov_base = va; | |
201 | hdr_len = (unsigned long)va - (unsigned long)rmsgp; | |
202 | rqstp->rq_arg.head[0].iov_len -= hdr_len; | |
203 | ||
204 | *rdma_req = rmsgp; | |
205 | return hdr_len; | |
206 | } | |
207 | ||
ef1eac0a TT |
208 | int svc_rdma_xdr_encode_error(struct svcxprt_rdma *xprt, |
209 | struct rpcrdma_msg *rmsgp, | |
30b7e246 | 210 | enum rpcrdma_errcode err, __be32 *va) |
ef1eac0a | 211 | { |
30b7e246 | 212 | __be32 *startp = va; |
ef1eac0a | 213 | |
30b7e246 CL |
214 | *va++ = rmsgp->rm_xid; |
215 | *va++ = rmsgp->rm_vers; | |
216 | *va++ = cpu_to_be32(xprt->sc_max_requests); | |
217 | *va++ = rdma_error; | |
218 | *va++ = cpu_to_be32(err); | |
ef1eac0a | 219 | if (err == ERR_VERS) { |
30b7e246 CL |
220 | *va++ = rpcrdma_version; |
221 | *va++ = rpcrdma_version; | |
ef1eac0a TT |
222 | } |
223 | ||
224 | return (int)((unsigned long)va - (unsigned long)startp); | |
225 | } | |
226 | ||
227 | int svc_rdma_xdr_get_reply_hdr_len(struct rpcrdma_msg *rmsgp) | |
228 | { | |
229 | struct rpcrdma_write_array *wr_ary; | |
230 | ||
231 | /* There is no read-list in a reply */ | |
232 | ||
233 | /* skip write list */ | |
234 | wr_ary = (struct rpcrdma_write_array *) | |
235 | &rmsgp->rm_body.rm_chunks[1]; | |
236 | if (wr_ary->wc_discrim) | |
237 | wr_ary = (struct rpcrdma_write_array *) | |
30b7e246 | 238 | &wr_ary->wc_array[be32_to_cpu(wr_ary->wc_nchunks)]. |
ef1eac0a TT |
239 | wc_target.rs_length; |
240 | else | |
241 | wr_ary = (struct rpcrdma_write_array *) | |
242 | &wr_ary->wc_nchunks; | |
243 | ||
244 | /* skip reply array */ | |
245 | if (wr_ary->wc_discrim) | |
246 | wr_ary = (struct rpcrdma_write_array *) | |
30b7e246 | 247 | &wr_ary->wc_array[be32_to_cpu(wr_ary->wc_nchunks)]; |
ef1eac0a TT |
248 | else |
249 | wr_ary = (struct rpcrdma_write_array *) | |
250 | &wr_ary->wc_nchunks; | |
251 | ||
252 | return (unsigned long) wr_ary - (unsigned long) rmsgp; | |
253 | } | |
254 | ||
255 | void svc_rdma_xdr_encode_write_list(struct rpcrdma_msg *rmsgp, int chunks) | |
256 | { | |
257 | struct rpcrdma_write_array *ary; | |
258 | ||
259 | /* no read-list */ | |
260 | rmsgp->rm_body.rm_chunks[0] = xdr_zero; | |
261 | ||
262 | /* write-array discrim */ | |
263 | ary = (struct rpcrdma_write_array *) | |
264 | &rmsgp->rm_body.rm_chunks[1]; | |
265 | ary->wc_discrim = xdr_one; | |
30b7e246 | 266 | ary->wc_nchunks = cpu_to_be32(chunks); |
ef1eac0a TT |
267 | |
268 | /* write-list terminator */ | |
269 | ary->wc_array[chunks].wc_target.rs_handle = xdr_zero; | |
270 | ||
271 | /* reply-array discriminator */ | |
272 | ary->wc_array[chunks].wc_target.rs_length = xdr_zero; | |
273 | } | |
274 | ||
275 | void svc_rdma_xdr_encode_reply_array(struct rpcrdma_write_array *ary, | |
276 | int chunks) | |
277 | { | |
278 | ary->wc_discrim = xdr_one; | |
30b7e246 | 279 | ary->wc_nchunks = cpu_to_be32(chunks); |
ef1eac0a TT |
280 | } |
281 | ||
282 | void svc_rdma_xdr_encode_array_chunk(struct rpcrdma_write_array *ary, | |
283 | int chunk_no, | |
cec56c8f TT |
284 | __be32 rs_handle, |
285 | __be64 rs_offset, | |
ef1eac0a TT |
286 | u32 write_len) |
287 | { | |
288 | struct rpcrdma_segment *seg = &ary->wc_array[chunk_no].wc_target; | |
cec56c8f TT |
289 | seg->rs_handle = rs_handle; |
290 | seg->rs_offset = rs_offset; | |
30b7e246 | 291 | seg->rs_length = cpu_to_be32(write_len); |
ef1eac0a TT |
292 | } |
293 | ||
294 | void svc_rdma_xdr_encode_reply_header(struct svcxprt_rdma *xprt, | |
295 | struct rpcrdma_msg *rdma_argp, | |
296 | struct rpcrdma_msg *rdma_resp, | |
297 | enum rpcrdma_proc rdma_type) | |
298 | { | |
30b7e246 CL |
299 | rdma_resp->rm_xid = rdma_argp->rm_xid; |
300 | rdma_resp->rm_vers = rdma_argp->rm_vers; | |
301 | rdma_resp->rm_credit = cpu_to_be32(xprt->sc_max_requests); | |
302 | rdma_resp->rm_type = cpu_to_be32(rdma_type); | |
ef1eac0a TT |
303 | |
304 | /* Encode <nul> chunks lists */ | |
305 | rdma_resp->rm_body.rm_chunks[0] = xdr_zero; | |
306 | rdma_resp->rm_body.rm_chunks[1] = xdr_zero; | |
307 | rdma_resp->rm_body.rm_chunks[2] = xdr_zero; | |
308 | } |