LXR linux/net/sunrpc/xprtrdma/svc_rdma

   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
  53 *    position : u32 offset into XDR stream
  54 *    handle   : u32 RKEY
  55 *    . . .
  56 *  end-of-list: xdr_zero
  57 */
  58static u32 *decode_read_list(u32 *va, u32 *vaend)
  59{
  60        struct rpcrdma_read_chunk *ch = (struct rpcrdma_read_chunk *)va;
  61
  62        while (ch->rc_discrim != xdr_zero) {
  63                u64 ch_offset;
  64
  65                if (((unsigned long)ch + sizeof(struct rpcrdma_read_chunk)) >
  66                    (unsigned long)vaend) {
  67                        dprintk("svcrdma: vaend=%p, ch=%p\n", vaend, ch);
  68                        return NULL;
  69                }
  70
  71                ch->rc_discrim = ntohl(ch->rc_discrim);
  72                ch->rc_position = ntohl(ch->rc_position);
  73                ch->rc_target.rs_handle = ntohl(ch->rc_target.rs_handle);
  74                ch->rc_target.rs_length = ntohl(ch->rc_target.rs_length);
  75                va = (u32 *)&ch->rc_target.rs_offset;
  76                xdr_decode_hyper(va, &ch_offset);
  77                put_unaligned(ch_offset, (u64 *)va);
  78                ch++;
  79        }
  80        return (u32 *)&ch->rc_position;
  81}
  82
  83/*
  84 * Determine number of chunks and total bytes in chunk list. The chunk
  85 * list has already been verified to fit within the RPCRDMA header.
  86 */
  87void svc_rdma_rcl_chunk_counts(struct rpcrdma_read_chunk *ch,
  88                               int *ch_count, int *byte_count)
  89{
  90        /* compute the number of bytes represented by read chunks */
  91        *byte_count = 0;
  92        *ch_count = 0;
  93        for (; ch->rc_discrim != 0; ch++) {
  94                *byte_count = *byte_count + ch->rc_target.rs_length;
  95                *ch_count = *ch_count + 1;
  96        }
  97}
  98
  99/*
 100 * Decodes a write chunk list. The expected format is as follows:
 101 *    descrim  : xdr_one
 102 *    nchunks  : <count>
 103 *       handle   : u32 RKEY              ---+
 104 *       length   : u32 <len of segment>     |
 105 *       offset   : remove va                + <count>
 106 *       . . .                               |
 107 *                                        ---+
 108 */
 109static u32 *decode_write_list(u32 *va, u32 *vaend)
 110{
 111        int ch_no;
 112        struct rpcrdma_write_array *ary =
 113                (struct rpcrdma_write_array *)va;
 114
 115        /* Check for not write-array */
 116        if (ary->wc_discrim == xdr_zero)
 117                return (u32 *)&ary->wc_nchunks;
 118
 119        if ((unsigned long)ary + sizeof(struct rpcrdma_write_array) >
 120            (unsigned long)vaend) {
 121                dprintk("svcrdma: ary=%p, vaend=%p\n", ary, vaend);
 122                return NULL;
 123        }
 124        ary->wc_discrim = ntohl(ary->wc_discrim);
 125        ary->wc_nchunks = ntohl(ary->wc_nchunks);
 126        if (((unsigned long)&ary->wc_array[0] +
 127             (sizeof(struct rpcrdma_write_chunk) * ary->wc_nchunks)) >
 128            (unsigned long)vaend) {
 129                dprintk("svcrdma: ary=%p, wc_nchunks=%d, vaend=%p\n",
 130                        ary, ary->wc_nchunks, vaend);
 131                return NULL;
 132        }
 133        for (ch_no = 0; ch_no < ary->wc_nchunks; ch_no++) {
 134                u64 ch_offset;
 135
 136                ary->wc_array[ch_no].wc_target.rs_handle =
 137                        ntohl(ary->wc_array[ch_no].wc_target.rs_handle);
 138                ary->wc_array[ch_no].wc_target.rs_length =
 139                        ntohl(ary->wc_array[ch_no].wc_target.rs_length);
 140                va = (u32 *)&ary->wc_array[ch_no].wc_target.rs_offset;
 141                xdr_decode_hyper(va, &ch_offset);
 142                put_unaligned(ch_offset, (u64 *)va);
 143        }
 144
 145        /*
 146         * rs_length is the 2nd 4B field in wc_target and taking its
 147         * address skips the list terminator
 148         */
 149        return (u32 *)&ary->wc_array[ch_no].wc_target.rs_length;
 150}
 151
 152static u32 *decode_reply_array(u32 *va, u32 *vaend)
 153{
 154        int ch_no;
 155        struct rpcrdma_write_array *ary =
 156                (struct rpcrdma_write_array *)va;
 157
 158        /* Check for no reply-array */
 159        if (ary->wc_discrim == xdr_zero)
 160                return (u32 *)&ary->wc_nchunks;
 161
 162        if ((unsigned long)ary + sizeof(struct rpcrdma_write_array) >
 163            (unsigned long)vaend) {
 164                dprintk("svcrdma: ary=%p, vaend=%p\n", ary, vaend);
 165                return NULL;
 166        }
 167        ary->wc_discrim = ntohl(ary->wc_discrim);
 168        ary->wc_nchunks = ntohl(ary->wc_nchunks);
 169        if (((unsigned long)&ary->wc_array[0] +
 170             (sizeof(struct rpcrdma_write_chunk) * ary->wc_nchunks)) >
 171            (unsigned long)vaend) {
 172                dprintk("svcrdma: ary=%p, wc_nchunks=%d, vaend=%p\n",
 173                        ary, ary->wc_nchunks, vaend);
 174                return NULL;
 175        }
 176        for (ch_no = 0; ch_no < ary->wc_nchunks; ch_no++) {
 177                u64 ch_offset;
 178
 179                ary->wc_array[ch_no].wc_target.rs_handle =
 180                        ntohl(ary->wc_array[ch_no].wc_target.rs_handle);
 181                ary->wc_array[ch_no].wc_target.rs_length =
 182                        ntohl(ary->wc_array[ch_no].wc_target.rs_length);
 183                va = (u32 *)&ary->wc_array[ch_no].wc_target.rs_offset;
 184                xdr_decode_hyper(va, &ch_offset);
 185                put_unaligned(ch_offset, (u64 *)va);
 186        }
 187
 188        return (u32 *)&ary->wc_array[ch_no];
 189}
 190
 191int svc_rdma_xdr_decode_req(struct rpcrdma_msg **rdma_req,
 192                            struct svc_rqst *rqstp)
 193{
 194        struct rpcrdma_msg *rmsgp = NULL;
 195        u32 *va;
 196        u32 *vaend;
 197        u32 hdr_len;
 198
 199        rmsgp = (struct rpcrdma_msg *)rqstp->rq_arg.head[0].iov_base;
 200
 201        /* Verify that there's enough bytes for header + something */
 202        if (rqstp->rq_arg.len <= RPCRDMA_HDRLEN_MIN) {
 203                dprintk("svcrdma: header too short = %d\n",
 204                        rqstp->rq_arg.len);
 205                return -EINVAL;
 206        }
 207
 208        /* Decode the header */
 209        rmsgp->rm_xid = ntohl(rmsgp->rm_xid);
 210        rmsgp->rm_vers = ntohl(rmsgp->rm_vers);
 211        rmsgp->rm_credit = ntohl(rmsgp->rm_credit);
 212        rmsgp->rm_type = ntohl(rmsgp->rm_type);
 213
 214        if (rmsgp->rm_vers != RPCRDMA_VERSION)
 215                return -ENOSYS;
 216
 217        /* Pull in the extra for the padded case and bump our pointer */
 218        if (rmsgp->rm_type == RDMA_MSGP) {
 219                int hdrlen;
 220                rmsgp->rm_body.rm_padded.rm_align =
 221                        ntohl(rmsgp->rm_body.rm_padded.rm_align);
 222                rmsgp->rm_body.rm_padded.rm_thresh =
 223                        ntohl(rmsgp->rm_body.rm_padded.rm_thresh);
 224
 225                va = &rmsgp->rm_body.rm_padded.rm_pempty[4];
 226                rqstp->rq_arg.head[0].iov_base = va;
 227                hdrlen = (u32)((unsigned long)va - (unsigned long)rmsgp);
 228                rqstp->rq_arg.head[0].iov_len -= hdrlen;
 229                if (hdrlen > rqstp->rq_arg.len)
 230                        return -EINVAL;
 231                return hdrlen;
 232        }
 233
 234        /* The chunk list may contain either a read chunk list or a write
 235         * chunk list and a reply chunk list.
 236         */
 237        va = &rmsgp->rm_body.rm_chunks[0];
 238        vaend = (u32 *)((unsigned long)rmsgp + rqstp->rq_arg.len);
 239        va = decode_read_list(va, vaend);
 240        if (!va)
 241                return -EINVAL;
 242        va = decode_write_list(va, vaend);
 243        if (!va)
 244                return -EINVAL;
 245        va = decode_reply_array(va, vaend);
 246        if (!va)
 247                return -EINVAL;
 248
 249        rqstp->rq_arg.head[0].iov_base = va;
 250        hdr_len = (unsigned long)va - (unsigned long)rmsgp;
 251        rqstp->rq_arg.head[0].iov_len -= hdr_len;
 252
 253        *rdma_req = rmsgp;
 254        return hdr_len;
 255}
 256
 257int svc_rdma_xdr_decode_deferred_req(struct svc_rqst *rqstp)
 258{
 259        struct rpcrdma_msg *rmsgp = NULL;
 260        struct rpcrdma_read_chunk *ch;
 261        struct rpcrdma_write_array *ary;
 262        u32 *va;
 263        u32 hdrlen;
 264
 265        dprintk("svcrdma: processing deferred RDMA header on rqstp=%p\n",
 266                rqstp);
 267        rmsgp = (struct rpcrdma_msg *)rqstp->rq_arg.head[0].iov_base;
 268
 269        /* Pull in the extra for the padded case and bump our pointer */
 270        if (rmsgp->rm_type == RDMA_MSGP) {
 271                va = &rmsgp->rm_body.rm_padded.rm_pempty[4];
 272                rqstp->rq_arg.head[0].iov_base = va;
 273                hdrlen = (u32)((unsigned long)va - (unsigned long)rmsgp);
 274                rqstp->rq_arg.head[0].iov_len -= hdrlen;
 275                return hdrlen;
 276        }
 277
 278        /*
 279         * Skip all chunks to find RPC msg. These were previously processed
 280         */
 281        va = &rmsgp->rm_body.rm_chunks[0];
 282
 283        /* Skip read-list */
 284        for (ch = (struct rpcrdma_read_chunk *)va;
 285             ch->rc_discrim != xdr_zero; ch++);
 286        va = (u32 *)&ch->rc_position;
 287
 288        /* Skip write-list */
 289        ary = (struct rpcrdma_write_array *)va;
 290        if (ary->wc_discrim == xdr_zero)
 291                va = (u32 *)&ary->wc_nchunks;
 292        else
 293                /*
 294                 * rs_length is the 2nd 4B field in wc_target and taking its
 295                 * address skips the list terminator
 296                 */
 297                va = (u32 *)&ary->wc_array[ary->wc_nchunks].wc_target.rs_length;
 298
 299        /* Skip reply-array */
 300        ary = (struct rpcrdma_write_array *)va;
 301        if (ary->wc_discrim == xdr_zero)
 302                va = (u32 *)&ary->wc_nchunks;
 303        else
 304                va = (u32 *)&ary->wc_array[ary->wc_nchunks];
 305
 306        rqstp->rq_arg.head[0].iov_base = va;
 307        hdrlen = (unsigned long)va - (unsigned long)rmsgp;
 308        rqstp->rq_arg.head[0].iov_len -= hdrlen;
 309
 310        return hdrlen;
 311}
 312
 313int svc_rdma_xdr_encode_error(struct svcxprt_rdma *xprt,
 314                              struct rpcrdma_msg *rmsgp,
 315                              enum rpcrdma_errcode err, u32 *va)
 316{
 317        u32 *startp = va;
 318
 319        *va++ = htonl(rmsgp->rm_xid);
 320        *va++ = htonl(rmsgp->rm_vers);
 321        *va++ = htonl(xprt->sc_max_requests);
 322        *va++ = htonl(RDMA_ERROR);
 323        *va++ = htonl(err);
 324        if (err == ERR_VERS) {
 325                *va++ = htonl(RPCRDMA_VERSION);
 326                *va++ = htonl(RPCRDMA_VERSION);
 327        }
 328
 329        return (int)((unsigned long)va - (unsigned long)startp);
 330}
 331
 332int svc_rdma_xdr_get_reply_hdr_len(struct rpcrdma_msg *rmsgp)
 333{
 334        struct rpcrdma_write_array *wr_ary;
 335
 336        /* There is no read-list in a reply */
 337
 338        /* skip write list */
 339        wr_ary = (struct rpcrdma_write_array *)
 340                &rmsgp->rm_body.rm_chunks[1];
 341        if (wr_ary->wc_discrim)
 342                wr_ary = (struct rpcrdma_write_array *)
 343                        &wr_ary->wc_array[ntohl(wr_ary->wc_nchunks)].
 344                        wc_target.rs_length;
 345        else
 346                wr_ary = (struct rpcrdma_write_array *)
 347                        &wr_ary->wc_nchunks;
 348
 349        /* skip reply array */
 350        if (wr_ary->wc_discrim)
 351                wr_ary = (struct rpcrdma_write_array *)
 352                        &wr_ary->wc_array[ntohl(wr_ary->wc_nchunks)];
 353        else
 354                wr_ary = (struct rpcrdma_write_array *)
 355                        &wr_ary->wc_nchunks;
 356
 357        return (unsigned long) wr_ary - (unsigned long) rmsgp;
 358}
 359
 360void svc_rdma_xdr_encode_write_list(struct rpcrdma_msg *rmsgp, int chunks)
 361{
 362        struct rpcrdma_write_array *ary;
 363
 364        /* no read-list */
 365        rmsgp->rm_body.rm_chunks[0] = xdr_zero;
 366
 367        /* write-array discrim */
 368        ary = (struct rpcrdma_write_array *)
 369                &rmsgp->rm_body.rm_chunks[1];
 370        ary->wc_discrim = xdr_one;
 371        ary->wc_nchunks = htonl(chunks);
 372
 373        /* write-list terminator */
 374        ary->wc_array[chunks].wc_target.rs_handle = xdr_zero;
 375
 376        /* reply-array discriminator */
 377        ary->wc_array[chunks].wc_target.rs_length = xdr_zero;
 378}
 379
 380void svc_rdma_xdr_encode_reply_array(struct rpcrdma_write_array *ary,
 381                                 int chunks)
 382{
 383        ary->wc_discrim = xdr_one;
 384        ary->wc_nchunks = htonl(chunks);
 385}
 386
 387void svc_rdma_xdr_encode_array_chunk(struct rpcrdma_write_array *ary,
 388                                     int chunk_no,
 389                                     u32 rs_handle, u64 rs_offset,
 390                                     u32 write_len)
 391{
 392        struct rpcrdma_segment *seg = &ary->wc_array[chunk_no].wc_target;
 393        seg->rs_handle = htonl(rs_handle);
 394        seg->rs_length = htonl(write_len);
 395        xdr_encode_hyper((u32 *) &seg->rs_offset, rs_offset);
 396}
 397
 398void svc_rdma_xdr_encode_reply_header(struct svcxprt_rdma *xprt,
 399                                  struct rpcrdma_msg *rdma_argp,
 400                                  struct rpcrdma_msg *rdma_resp,
 401                                  enum rpcrdma_proc rdma_type)
 402{
 403        rdma_resp->rm_xid = htonl(rdma_argp->rm_xid);
 404        rdma_resp->rm_vers = htonl(rdma_argp->rm_vers);
 405        rdma_resp->rm_credit = htonl(xprt->sc_max_requests);
 406        rdma_resp->rm_type = htonl(rdma_type);
 407
 408        /* Encode <nul> chunks lists */
 409        rdma_resp->rm_body.rm_chunks[0] = xdr_zero;
 410        rdma_resp->rm_body.rm_chunks[1] = xdr_zero;
 411        rdma_resp->rm_body.rm_chunks[2] = xdr_zero;
 412}
 413