1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <rpc/types.h>
27 #include <rpc/xdr.h>
28 #include <sys/types.h>
29 #include <sys/sdt.h>
30 #include <rpc/auth.h>
31 #include <rpc/rpc_rdma.h>
32
33 struct private {
34 int min_chunk;
35 uint_t flags; /* controls setting for rdma xdr */
36 int num_chunk;
37 caddr_t inline_buf; /* temporary buffer for xdr inlining */
38 int inline_len; /* inline buffer length */
39 uint_t xp_reply_chunk_len;
40 uint_t xp_reply_chunk_len_alt;
41 };
42
43 /* ARGSUSED */
44 static bool_t
45 x_putint32_t(XDR *xdrs, int32_t *ip)
46 {
47 xdrs->x_handy += BYTES_PER_XDR_UNIT;
48 return (TRUE);
49 }
50
51 /* ARGSUSED */
52 static bool_t
53 x_putbytes(XDR *xdrs, char *bp, int len)
54 {
55 struct private *xdrp = (struct private *)xdrs->x_private;
56
57 /*
58 * min_chunk = 0, means that the stream of bytes, to estimate size of,
59 * contains no chunks to seperate out. See xdrrdma_putbytes()
60 */
61 if (len < xdrp->min_chunk || !(xdrp->flags & XDR_RDMA_CHUNK)) {
62 xdrs->x_handy += len;
63 return (TRUE);
64 }
65 /*
66 * Chunk item. No impact on xdr size.
67 */
68 xdrp->num_chunk++;
69
70 return (TRUE);
71 }
72
73 static uint_t
74 x_getpostn(XDR *xdrs)
75 {
76 return (xdrs->x_handy);
77 }
78
79 /* ARGSUSED */
80 static bool_t
81 x_setpostn(XDR *xdrs, uint_t pos)
82 {
83 /* This is not allowed */
84 return (FALSE);
85 }
86
87 /* ARGSUSED */
88 static bool_t
89 x_control(XDR *xdrs, int request, void *info)
90 {
91 int32_t *int32p;
92 uint_t in_flags;
93 rdma_chunkinfo_t *rcip = NULL;
94 rdma_chunkinfo_lengths_t *rcilp = NULL;
95 struct private *xdrp = (struct private *)xdrs->x_private;
96
97 switch (request) {
98 case XDR_RDMA_SET_FLAGS:
99 /*
100 * Set the flags provided in the *info in xp_flags for rdma xdr
101 * stream control.
102 */
103 int32p = (int32_t *)info;
104 in_flags = (uint_t)(*int32p);
105
106 xdrp->flags = in_flags;
107 return (TRUE);
108
109 case XDR_RDMA_GET_FLAGS:
110 /*
111 * Get the flags provided in xp_flags return through *info
112 */
113 int32p = (int32_t *)info;
114
115 *int32p = (int32_t)xdrp->flags;
116 return (TRUE);
117
118 case XDR_RDMA_GET_CHUNK_LEN:
119 rcilp = (rdma_chunkinfo_lengths_t *)info;
120 rcilp->rcil_len = xdrp->xp_reply_chunk_len;
121 rcilp->rcil_len_alt = xdrp->xp_reply_chunk_len_alt;
122
123 return (TRUE);
124
125 case XDR_RDMA_ADD_CHUNK:
126 rcip = (rdma_chunkinfo_t *)info;
127
128 switch (rcip->rci_type) {
129 case RCI_WRITE_UIO_CHUNK:
130 xdrp->xp_reply_chunk_len_alt += rcip->rci_len;
131 break;
132
133 case RCI_WRITE_ADDR_CHUNK:
134 xdrp->xp_reply_chunk_len_alt += rcip->rci_len;
135 break;
136
137 case RCI_REPLY_CHUNK:
138 xdrp->xp_reply_chunk_len += rcip->rci_len;
139 break;
140 }
141 return (TRUE);
142
143 default:
144 return (FALSE);
145 }
146 }
147
148 /* ARGSUSED */
149 static rpc_inline_t *
150 x_inline(XDR *xdrs, int len)
151 {
152 struct private *xdrp = (struct private *)xdrs->x_private;
153
154 if (len == 0) {
155 return (NULL);
156 }
157 if (xdrs->x_op != XDR_ENCODE) {
158 return (NULL);
159 }
160 if (len >= xdrp->min_chunk) {
161 return (NULL);
162 }
163 if (len <= xdrp->inline_len) {
164 /* inline_buf was already allocated, just reuse it */
165 xdrs->x_handy += len;
166 return ((rpc_inline_t *)xdrp->inline_buf);
167 } else {
168 /* Free the earlier space and allocate new area */
169 if (xdrp->inline_buf)
170 mem_free(xdrp->inline_buf, xdrp->inline_len);
171 if ((xdrp->inline_buf = (caddr_t)mem_alloc(len)) == NULL) {
172 xdrp->inline_len = 0;
173 return (NULL);
174 }
175 xdrp->inline_len = len;
176 xdrs->x_handy += len;
177 return ((rpc_inline_t *)xdrp->inline_buf);
178 }
179 }
180
181 static int
182 harmless()
183 {
184 /* Always return FALSE/NULL, as the case may be */
185 return (0);
186 }
187
188 static void
189 x_destroy(XDR *xdrs)
190 {
191 struct private *xdrp = (struct private *)xdrs->x_private;
192
193 xdrs->x_handy = 0;
194 if (xdrp) {
195 if (xdrp->inline_buf)
196 mem_free(xdrp->inline_buf, xdrp->inline_len);
197 mem_free(xdrp, sizeof (struct private));
198 xdrs->x_private = NULL;
199 }
200 xdrs->x_base = 0;
201 }
202
203 static bool_t
204 xdrrdma_common(XDR *xdrs, int min_chunk)
205 {
206 struct private *xdrp;
207
208 xdrs->x_ops = xdrrdma_xops();
209 xdrs->x_op = XDR_ENCODE;
210 xdrs->x_handy = 0;
211 xdrs->x_base = NULL;
212 xdrs->x_private = kmem_zalloc(sizeof (struct private), KM_SLEEP);
213 xdrp = (struct private *)xdrs->x_private;
214 xdrp->min_chunk = min_chunk;
215 xdrp->flags = 0;
216 if (xdrp->min_chunk != 0)
217 xdrp->flags |= XDR_RDMA_CHUNK;
218
219 xdrp->xp_reply_chunk_len = 0;
220 xdrp->xp_reply_chunk_len_alt = 0;
221
222 return (TRUE);
223 }
224
225 unsigned int
226 xdrrdma_sizeof(xdrproc_t func, void *data, int min_chunk,
227 uint_t *reply_size, uint_t *reply_size_alt)
228 {
229 XDR x;
230 struct xdr_ops ops;
231 bool_t stat;
232 struct private *xdrp;
233
234 x.x_ops = &ops;
235 (void) xdrrdma_common(&x, min_chunk);
236
237 stat = func(&x, data);
238 xdrp = (struct private *)x.x_private;
239 if (xdrp) {
240 if (reply_size != NULL)
241 *reply_size = xdrp->xp_reply_chunk_len;
242 if (reply_size_alt != NULL)
243 *reply_size_alt = xdrp->xp_reply_chunk_len_alt;
244 if (xdrp->inline_buf)
245 mem_free(xdrp->inline_buf, xdrp->inline_len);
246 mem_free(xdrp, sizeof (struct private));
247 }
248 return (stat == TRUE ? (unsigned int)x.x_handy: 0);
249 }
250
251 unsigned int
252 xdrrdma_authsize(AUTH *auth, struct cred *cred, int min_chunk)
253 {
254 XDR x;
255 struct xdr_ops ops;
256 bool_t stat;
257 struct private *xdrp;
258
259 x.x_ops = &ops;
260 (void) xdrrdma_common(&x, min_chunk);
261
262 stat = AUTH_MARSHALL(auth, &x, cred);
263 xdrp = (struct private *)x.x_private;
264 if (xdrp) {
265 if (xdrp->inline_buf)
266 mem_free(xdrp->inline_buf, xdrp->inline_len);
267 mem_free(xdrp, sizeof (struct private));
268 }
269 return (stat == TRUE ? (unsigned int)x.x_handy: 0);
270 }
271
272 struct xdr_ops *
273 xdrrdma_xops(void)
274 {
275 static struct xdr_ops ops;
276
277 /* to stop ANSI-C compiler from complaining */
278 typedef bool_t (* dummyfunc1)(XDR *, long *);
279 typedef bool_t (* dummyfunc2)(XDR *, caddr_t, int);
280 typedef bool_t (* dummyfunc3)(XDR *, int32_t *);
281
282 ops.x_putbytes = x_putbytes;
283 ops.x_inline = x_inline;
284 ops.x_getpostn = x_getpostn;
285 ops.x_setpostn = x_setpostn;
286 ops.x_destroy = x_destroy;
287 ops.x_control = x_control;
288
289 #if defined(_LP64) || defined(_KERNEL)
290 ops.x_getint32 = (dummyfunc3)harmless;
291 ops.x_putint32 = x_putint32_t;
292 #endif
293
294 /* the other harmless ones */
295 ops.x_getbytes = (dummyfunc2)harmless;
296
297 return (&ops);
298 }