usr/src/uts/common/rpc/xdrrdma_sizeof.c

   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  * Copyright 2017 RackTop Systems.
  26  */
  27
  28 #include <rpc/types.h>
  29 #include <rpc/xdr.h>
  30 #include <sys/types.h>
  31 #include <sys/sdt.h>
  32 #include <rpc/auth.h>
  33 #include <rpc/rpc_rdma.h>
  34
  35 struct private {
  36         int     min_chunk;
  37         uint_t  flags;                  /* controls setting for rdma xdr */
  38         int     num_chunk;
  39         caddr_t inline_buf;             /* temporary buffer for xdr inlining */
  40         int     inline_len;             /* inline buffer length */
  41         uint_t  xp_reply_chunk_len;
  42         uint_t  xp_reply_chunk_len_alt;
  43 };
  44
  45 /* ARGSUSED */
  46 static bool_t
  47 x_putint32_t(XDR *xdrs, int32_t *ip)
  48 {
  49         xdrs->x_handy += BYTES_PER_XDR_UNIT;
  50         return (TRUE);
  51 }
  52
  53 /* ARGSUSED */
  54 static bool_t
  55 x_putbytes(XDR *xdrs, char *bp, int len)
  56 {
  57         struct private *xdrp = (struct private *)xdrs->x_private;
  58
  59         /*
  60          * min_chunk = 0, means that the stream of bytes, to estimate size of,
  61          * contains no chunks to seperate out. See xdrrdma_putbytes()
  62          */
  63         if (len < xdrp->min_chunk || !(xdrp->flags & XDR_RDMA_CHUNK)) {
  64                 xdrs->x_handy += len;
  65                 return (TRUE);
  66         }
  67         /*
  68          * Chunk item. No impact on xdr size.
  69          */
  70         xdrp->num_chunk++;
  71
  72         return (TRUE);
  73 }
  74
  75 static uint_t
  76 x_getpostn(XDR *xdrs)
  77 {
  78         return (xdrs->x_handy);
  79 }
  80
  81 /* ARGSUSED */
  82 static bool_t
  83 x_setpostn(XDR *xdrs, uint_t pos)
  84 {
  85         /* This is not allowed */
  86         return (FALSE);
  87 }
  88
  89 /* ARGSUSED */
  90 static bool_t
  91 x_control(XDR *xdrs, int request, void *info)
  92 {
  93         int32_t *int32p;
  94         uint_t in_flags;
  95         rdma_chunkinfo_t *rcip = NULL;
  96         rdma_chunkinfo_lengths_t *rcilp = NULL;
  97         struct private *xdrp = (struct private *)xdrs->x_private;
  98
  99         switch (request) {
 100         case XDR_RDMA_SET_FLAGS:
 101                 /*
 102                  * Set the flags provided in the *info in xp_flags for rdma xdr
 103                  * stream control.
 104                  */
 105                 int32p = (int32_t *)info;
 106                 in_flags = (uint_t)(*int32p);
 107
 108                 xdrp->flags = in_flags;
 109                 return (TRUE);
 110
 111         case XDR_RDMA_GET_FLAGS:
 112                 /*
 113                  * Get the flags provided in xp_flags return through *info
 114                  */
 115                 int32p = (int32_t *)info;
 116
 117                 *int32p = (int32_t)xdrp->flags;
 118                 return (TRUE);
 119
 120         case XDR_RDMA_GET_CHUNK_LEN:
 121                 rcilp = (rdma_chunkinfo_lengths_t *)info;
 122                 rcilp->rcil_len = xdrp->xp_reply_chunk_len;
 123                 rcilp->rcil_len_alt = xdrp->xp_reply_chunk_len_alt;
 124
 125                 return (TRUE);
 126
 127         case XDR_RDMA_ADD_CHUNK:
 128                 rcip = (rdma_chunkinfo_t *)info;
 129
 130                 switch (rcip->rci_type) {
 131                 case RCI_WRITE_UIO_CHUNK:
 132                         xdrp->xp_reply_chunk_len_alt += rcip->rci_len;
 133                         break;
 134
 135                 case RCI_WRITE_ADDR_CHUNK:
 136                         xdrp->xp_reply_chunk_len_alt += rcip->rci_len;
 137                         break;
 138
 139                 case RCI_REPLY_CHUNK:
 140                         xdrp->xp_reply_chunk_len += rcip->rci_len;
 141                         break;
 142                 }
 143                 return (TRUE);
 144
 145         default:
 146                 return (FALSE);
 147         }
 148 }
 149
 150 /* ARGSUSED */
 151 static rpc_inline_t *
 152 x_inline(XDR *xdrs, int len)
 153 {
 154         struct private *xdrp = (struct private *)xdrs->x_private;
 155
 156         if (len == 0) {
 157                 return (NULL);
 158         }
 159         if (xdrs->x_op != XDR_ENCODE) {
 160                 return (NULL);
 161         }
 162         if (len >= xdrp->min_chunk) {
 163                 return (NULL);
 164         }
 165         if (len <= xdrp->inline_len) {
 166                 /* inline_buf was already allocated, just reuse it */
 167                 xdrs->x_handy += len;
 168                 return ((rpc_inline_t *)xdrp->inline_buf);
 169         } else {
 170                 /* Free the earlier space and allocate new area */
 171                 if (xdrp->inline_buf)
 172                         mem_free(xdrp->inline_buf, xdrp->inline_len);
 173                 if ((xdrp->inline_buf = (caddr_t)mem_alloc(len)) == NULL) {
 174                         xdrp->inline_len = 0;
 175                         return (NULL);
 176                 }
 177                 xdrp->inline_len = len;
 178                 xdrs->x_handy += len;
 179                 return ((rpc_inline_t *)xdrp->inline_buf);
 180         }
 181 }
 182
 183 static int
 184 harmless()
 185 {
 186         /* Always return FALSE/NULL, as the case may be */
 187         return (0);
 188 }
 189
 190 static void
 191 x_destroy(XDR *xdrs)
 192 {
 193         struct private *xdrp = (struct private *)xdrs->x_private;
 194
 195         xdrs->x_handy = 0;
 196         if (xdrp) {
 197                 if (xdrp->inline_buf)
 198                         mem_free(xdrp->inline_buf, xdrp->inline_len);
 199                 mem_free(xdrp, sizeof (struct private));
 200                 xdrs->x_private = NULL;
 201         }
 202         xdrs->x_base = 0;
 203 }
 204
 205 static bool_t
 206 xdrrdma_common(XDR *xdrs, int min_chunk)
 207 {
 208         struct private *xdrp;
 209
 210         xdrs->x_ops = xdrrdma_xops();
 211         xdrs->x_op = XDR_ENCODE;
 212         xdrs->x_handy = 0;
 213         xdrs->x_base = NULL;
 214         xdrs->x_private = kmem_zalloc(sizeof (struct private), KM_SLEEP);
 215         xdrp = (struct private *)xdrs->x_private;
 216         xdrp->min_chunk = min_chunk;
 217         xdrp->flags = 0;
 218         if (xdrp->min_chunk != 0)
 219                 xdrp->flags |= XDR_RDMA_CHUNK;
 220
 221         xdrp->xp_reply_chunk_len = 0;
 222         xdrp->xp_reply_chunk_len_alt = 0;
 223
 224         return (TRUE);
 225 }
 226
 227 unsigned int
 228 xdrrdma_sizeof(xdrproc_t func, void *data, int min_chunk,
 229     uint_t *reply_size, uint_t *reply_size_alt)
 230 {
 231         XDR x;
 232         struct xdr_ops ops;
 233         bool_t stat;
 234         struct private *xdrp;
 235
 236         x.x_ops = &ops;
 237         (void) xdrrdma_common(&x, min_chunk);
 238
 239         stat = func(&x, data);
 240         xdrp = (struct private *)x.x_private;
 241         if (xdrp) {
 242                 if (reply_size != NULL)
 243                         *reply_size = xdrp->xp_reply_chunk_len;
 244                 if (reply_size_alt != NULL)
 245                         *reply_size_alt = xdrp->xp_reply_chunk_len_alt;
 246                 if (xdrp->inline_buf)
 247                         mem_free(xdrp->inline_buf, xdrp->inline_len);
 248                 mem_free(xdrp, sizeof (struct private));
 249         }
 250         return (stat == TRUE ? (unsigned int)x.x_handy: 0);
 251 }
 252
 253 unsigned int
 254 xdrrdma_authsize(AUTH *auth, struct cred *cred, int min_chunk)
 255 {
 256         XDR x;
 257         struct xdr_ops ops;
 258         bool_t stat;
 259         struct private *xdrp;
 260
 261         x.x_ops = &ops;
 262         (void) xdrrdma_common(&x, min_chunk);
 263
 264         stat = AUTH_MARSHALL(auth, &x, cred);
 265         xdrp = (struct private *)x.x_private;
 266         if (xdrp) {
 267                 if (xdrp->inline_buf)
 268                         mem_free(xdrp->inline_buf, xdrp->inline_len);
 269                 mem_free(xdrp, sizeof (struct private));
 270         }
 271         return (stat == TRUE ? (unsigned int)x.x_handy: 0);
 272 }
 273
 274 struct xdr_ops *
 275 xdrrdma_xops(void)
 276 {
 277         static struct xdr_ops ops;
 278
 279         ops.x_putbytes = x_putbytes;
 280         ops.x_inline = x_inline;
 281         ops.x_getpostn = x_getpostn;
 282         ops.x_setpostn = x_setpostn;
 283         ops.x_destroy = x_destroy;
 284         ops.x_control = x_control;
 285
 286 #if defined(_LP64) || defined(_KERNEL)
 287         ops.x_getint32 = (void *)harmless;
 288         ops.x_putint32 = x_putint32_t;
 289 #endif
 290
 291         /* the other harmless ones */
 292         ops.x_getbytes = (void *)harmless;
 293
 294         return (&ops);
 295 }