linux/net/sunrpc/xdr.c
<<
>>
Prefs
   1/*
   2 * linux/net/sunrpc/xdr.c
   3 *
   4 * Generic XDR support.
   5 *
   6 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
   7 */
   8
   9#include <linux/module.h>
  10#include <linux/slab.h>
  11#include <linux/types.h>
  12#include <linux/string.h>
  13#include <linux/kernel.h>
  14#include <linux/pagemap.h>
  15#include <linux/errno.h>
  16#include <linux/sunrpc/xdr.h>
  17#include <linux/sunrpc/msg_prot.h>
  18
  19/*
  20 * XDR functions for basic NFS types
  21 */
  22__be32 *
  23xdr_encode_netobj(__be32 *p, const struct xdr_netobj *obj)
  24{
  25        unsigned int    quadlen = XDR_QUADLEN(obj->len);
  26
  27        p[quadlen] = 0;         /* zero trailing bytes */
  28        *p++ = cpu_to_be32(obj->len);
  29        memcpy(p, obj->data, obj->len);
  30        return p + XDR_QUADLEN(obj->len);
  31}
  32EXPORT_SYMBOL_GPL(xdr_encode_netobj);
  33
  34__be32 *
  35xdr_decode_netobj(__be32 *p, struct xdr_netobj *obj)
  36{
  37        unsigned int    len;
  38
  39        if ((len = be32_to_cpu(*p++)) > XDR_MAX_NETOBJ)
  40                return NULL;
  41        obj->len  = len;
  42        obj->data = (u8 *) p;
  43        return p + XDR_QUADLEN(len);
  44}
  45EXPORT_SYMBOL_GPL(xdr_decode_netobj);
  46
  47/**
  48 * xdr_encode_opaque_fixed - Encode fixed length opaque data
  49 * @p: pointer to current position in XDR buffer.
  50 * @ptr: pointer to data to encode (or NULL)
  51 * @nbytes: size of data.
  52 *
  53 * Copy the array of data of length nbytes at ptr to the XDR buffer
  54 * at position p, then align to the next 32-bit boundary by padding
  55 * with zero bytes (see RFC1832).
  56 * Note: if ptr is NULL, only the padding is performed.
  57 *
  58 * Returns the updated current XDR buffer position
  59 *
  60 */
  61__be32 *xdr_encode_opaque_fixed(__be32 *p, const void *ptr, unsigned int nbytes)
  62{
  63        if (likely(nbytes != 0)) {
  64                unsigned int quadlen = XDR_QUADLEN(nbytes);
  65                unsigned int padding = (quadlen << 2) - nbytes;
  66
  67                if (ptr != NULL)
  68                        memcpy(p, ptr, nbytes);
  69                if (padding != 0)
  70                        memset((char *)p + nbytes, 0, padding);
  71                p += quadlen;
  72        }
  73        return p;
  74}
  75EXPORT_SYMBOL_GPL(xdr_encode_opaque_fixed);
  76
  77/**
  78 * xdr_encode_opaque - Encode variable length opaque data
  79 * @p: pointer to current position in XDR buffer.
  80 * @ptr: pointer to data to encode (or NULL)
  81 * @nbytes: size of data.
  82 *
  83 * Returns the updated current XDR buffer position
  84 */
  85__be32 *xdr_encode_opaque(__be32 *p, const void *ptr, unsigned int nbytes)
  86{
  87        *p++ = cpu_to_be32(nbytes);
  88        return xdr_encode_opaque_fixed(p, ptr, nbytes);
  89}
  90EXPORT_SYMBOL_GPL(xdr_encode_opaque);
  91
  92__be32 *
  93xdr_encode_string(__be32 *p, const char *string)
  94{
  95        return xdr_encode_array(p, string, strlen(string));
  96}
  97EXPORT_SYMBOL_GPL(xdr_encode_string);
  98
  99__be32 *
 100xdr_decode_string_inplace(__be32 *p, char **sp,
 101                          unsigned int *lenp, unsigned int maxlen)
 102{
 103        u32 len;
 104
 105        len = be32_to_cpu(*p++);
 106        if (len > maxlen)
 107                return NULL;
 108        *lenp = len;
 109        *sp = (char *) p;
 110        return p + XDR_QUADLEN(len);
 111}
 112EXPORT_SYMBOL_GPL(xdr_decode_string_inplace);
 113
 114/**
 115 * xdr_terminate_string - '\0'-terminate a string residing in an xdr_buf
 116 * @buf: XDR buffer where string resides
 117 * @len: length of string, in bytes
 118 *
 119 */
 120void
 121xdr_terminate_string(struct xdr_buf *buf, const u32 len)
 122{
 123        char *kaddr;
 124
 125        kaddr = kmap_atomic(buf->pages[0]);
 126        kaddr[buf->page_base + len] = '\0';
 127        kunmap_atomic(kaddr);
 128}
 129EXPORT_SYMBOL_GPL(xdr_terminate_string);
 130
 131void
 132xdr_inline_pages(struct xdr_buf *xdr, unsigned int offset,
 133                 struct page **pages, unsigned int base, unsigned int len)
 134{
 135        struct kvec *head = xdr->head;
 136        struct kvec *tail = xdr->tail;
 137        char *buf = (char *)head->iov_base;
 138        unsigned int buflen = head->iov_len;
 139
 140        head->iov_len  = offset;
 141
 142        xdr->pages = pages;
 143        xdr->page_base = base;
 144        xdr->page_len = len;
 145
 146        tail->iov_base = buf + offset;
 147        tail->iov_len = buflen - offset;
 148
 149        xdr->buflen += len;
 150}
 151EXPORT_SYMBOL_GPL(xdr_inline_pages);
 152
 153/*
 154 * Helper routines for doing 'memmove' like operations on a struct xdr_buf
 155 */
 156
 157/**
 158 * _shift_data_right_pages
 159 * @pages: vector of pages containing both the source and dest memory area.
 160 * @pgto_base: page vector address of destination
 161 * @pgfrom_base: page vector address of source
 162 * @len: number of bytes to copy
 163 *
 164 * Note: the addresses pgto_base and pgfrom_base are both calculated in
 165 *       the same way:
 166 *            if a memory area starts at byte 'base' in page 'pages[i]',
 167 *            then its address is given as (i << PAGE_CACHE_SHIFT) + base
 168 * Also note: pgfrom_base must be < pgto_base, but the memory areas
 169 *      they point to may overlap.
 170 */
 171static void
 172_shift_data_right_pages(struct page **pages, size_t pgto_base,
 173                size_t pgfrom_base, size_t len)
 174{
 175        struct page **pgfrom, **pgto;
 176        char *vfrom, *vto;
 177        size_t copy;
 178
 179        BUG_ON(pgto_base <= pgfrom_base);
 180
 181        pgto_base += len;
 182        pgfrom_base += len;
 183
 184        pgto = pages + (pgto_base >> PAGE_CACHE_SHIFT);
 185        pgfrom = pages + (pgfrom_base >> PAGE_CACHE_SHIFT);
 186
 187        pgto_base &= ~PAGE_CACHE_MASK;
 188        pgfrom_base &= ~PAGE_CACHE_MASK;
 189
 190        do {
 191                /* Are any pointers crossing a page boundary? */
 192                if (pgto_base == 0) {
 193                        pgto_base = PAGE_CACHE_SIZE;
 194                        pgto--;
 195                }
 196                if (pgfrom_base == 0) {
 197                        pgfrom_base = PAGE_CACHE_SIZE;
 198                        pgfrom--;
 199                }
 200
 201                copy = len;
 202                if (copy > pgto_base)
 203                        copy = pgto_base;
 204                if (copy > pgfrom_base)
 205                        copy = pgfrom_base;
 206                pgto_base -= copy;
 207                pgfrom_base -= copy;
 208
 209                vto = kmap_atomic(*pgto);
 210                vfrom = kmap_atomic(*pgfrom);
 211                memmove(vto + pgto_base, vfrom + pgfrom_base, copy);
 212                flush_dcache_page(*pgto);
 213                kunmap_atomic(vfrom);
 214                kunmap_atomic(vto);
 215
 216        } while ((len -= copy) != 0);
 217}
 218
 219/**
 220 * _copy_to_pages
 221 * @pages: array of pages
 222 * @pgbase: page vector address of destination
 223 * @p: pointer to source data
 224 * @len: length
 225 *
 226 * Copies data from an arbitrary memory location into an array of pages
 227 * The copy is assumed to be non-overlapping.
 228 */
 229static void
 230_copy_to_pages(struct page **pages, size_t pgbase, const char *p, size_t len)
 231{
 232        struct page **pgto;
 233        char *vto;
 234        size_t copy;
 235
 236        pgto = pages + (pgbase >> PAGE_CACHE_SHIFT);
 237        pgbase &= ~PAGE_CACHE_MASK;
 238
 239        for (;;) {
 240                copy = PAGE_CACHE_SIZE - pgbase;
 241                if (copy > len)
 242                        copy = len;
 243
 244                vto = kmap_atomic(*pgto);
 245                memcpy(vto + pgbase, p, copy);
 246                kunmap_atomic(vto);
 247
 248                len -= copy;
 249                if (len == 0)
 250                        break;
 251
 252                pgbase += copy;
 253                if (pgbase == PAGE_CACHE_SIZE) {
 254                        flush_dcache_page(*pgto);
 255                        pgbase = 0;
 256                        pgto++;
 257                }
 258                p += copy;
 259        }
 260        flush_dcache_page(*pgto);
 261}
 262
 263/**
 264 * _copy_from_pages
 265 * @p: pointer to destination
 266 * @pages: array of pages
 267 * @pgbase: offset of source data
 268 * @len: length
 269 *
 270 * Copies data into an arbitrary memory location from an array of pages
 271 * The copy is assumed to be non-overlapping.
 272 */
 273void
 274_copy_from_pages(char *p, struct page **pages, size_t pgbase, size_t len)
 275{
 276        struct page **pgfrom;
 277        char *vfrom;
 278        size_t copy;
 279
 280        pgfrom = pages + (pgbase >> PAGE_CACHE_SHIFT);
 281        pgbase &= ~PAGE_CACHE_MASK;
 282
 283        do {
 284                copy = PAGE_CACHE_SIZE - pgbase;
 285                if (copy > len)
 286                        copy = len;
 287
 288                vfrom = kmap_atomic(*pgfrom);
 289                memcpy(p, vfrom + pgbase, copy);
 290                kunmap_atomic(vfrom);
 291
 292                pgbase += copy;
 293                if (pgbase == PAGE_CACHE_SIZE) {
 294                        pgbase = 0;
 295                        pgfrom++;
 296                }
 297                p += copy;
 298
 299        } while ((len -= copy) != 0);
 300}
 301EXPORT_SYMBOL_GPL(_copy_from_pages);
 302
 303/**
 304 * xdr_shrink_bufhead
 305 * @buf: xdr_buf
 306 * @len: bytes to remove from buf->head[0]
 307 *
 308 * Shrinks XDR buffer's header kvec buf->head[0] by
 309 * 'len' bytes. The extra data is not lost, but is instead
 310 * moved into the inlined pages and/or the tail.
 311 */
 312static void
 313xdr_shrink_bufhead(struct xdr_buf *buf, size_t len)
 314{
 315        struct kvec *head, *tail;
 316        size_t copy, offs;
 317        unsigned int pglen = buf->page_len;
 318
 319        tail = buf->tail;
 320        head = buf->head;
 321        BUG_ON (len > head->iov_len);
 322
 323        /* Shift the tail first */
 324        if (tail->iov_len != 0) {
 325                if (tail->iov_len > len) {
 326                        copy = tail->iov_len - len;
 327                        memmove((char *)tail->iov_base + len,
 328                                        tail->iov_base, copy);
 329                }
 330                /* Copy from the inlined pages into the tail */
 331                copy = len;
 332                if (copy > pglen)
 333                        copy = pglen;
 334                offs = len - copy;
 335                if (offs >= tail->iov_len)
 336                        copy = 0;
 337                else if (copy > tail->iov_len - offs)
 338                        copy = tail->iov_len - offs;
 339                if (copy != 0)
 340                        _copy_from_pages((char *)tail->iov_base + offs,
 341                                        buf->pages,
 342                                        buf->page_base + pglen + offs - len,
 343                                        copy);
 344                /* Do we also need to copy data from the head into the tail ? */
 345                if (len > pglen) {
 346                        offs = copy = len - pglen;
 347                        if (copy > tail->iov_len)
 348                                copy = tail->iov_len;
 349                        memcpy(tail->iov_base,
 350                                        (char *)head->iov_base +
 351                                        head->iov_len - offs,
 352                                        copy);
 353                }
 354        }
 355        /* Now handle pages */
 356        if (pglen != 0) {
 357                if (pglen > len)
 358                        _shift_data_right_pages(buf->pages,
 359                                        buf->page_base + len,
 360                                        buf->page_base,
 361                                        pglen - len);
 362                copy = len;
 363                if (len > pglen)
 364                        copy = pglen;
 365                _copy_to_pages(buf->pages, buf->page_base,
 366                                (char *)head->iov_base + head->iov_len - len,
 367                                copy);
 368        }
 369        head->iov_len -= len;
 370        buf->buflen -= len;
 371        /* Have we truncated the message? */
 372        if (buf->len > buf->buflen)
 373                buf->len = buf->buflen;
 374}
 375
 376/**
 377 * xdr_shrink_pagelen
 378 * @buf: xdr_buf
 379 * @len: bytes to remove from buf->pages
 380 *
 381 * Shrinks XDR buffer's page array buf->pages by
 382 * 'len' bytes. The extra data is not lost, but is instead
 383 * moved into the tail.
 384 */
 385static void
 386xdr_shrink_pagelen(struct xdr_buf *buf, size_t len)
 387{
 388        struct kvec *tail;
 389        size_t copy;
 390        unsigned int pglen = buf->page_len;
 391        unsigned int tailbuf_len;
 392
 393        tail = buf->tail;
 394        BUG_ON (len > pglen);
 395
 396        tailbuf_len = buf->buflen - buf->head->iov_len - buf->page_len;
 397
 398        /* Shift the tail first */
 399        if (tailbuf_len != 0) {
 400                unsigned int free_space = tailbuf_len - tail->iov_len;
 401
 402                if (len < free_space)
 403                        free_space = len;
 404                tail->iov_len += free_space;
 405
 406                copy = len;
 407                if (tail->iov_len > len) {
 408                        char *p = (char *)tail->iov_base + len;
 409                        memmove(p, tail->iov_base, tail->iov_len - len);
 410                } else
 411                        copy = tail->iov_len;
 412                /* Copy from the inlined pages into the tail */
 413                _copy_from_pages((char *)tail->iov_base,
 414                                buf->pages, buf->page_base + pglen - len,
 415                                copy);
 416        }
 417        buf->page_len -= len;
 418        buf->buflen -= len;
 419        /* Have we truncated the message? */
 420        if (buf->len > buf->buflen)
 421                buf->len = buf->buflen;
 422}
 423
 424void
 425xdr_shift_buf(struct xdr_buf *buf, size_t len)
 426{
 427        xdr_shrink_bufhead(buf, len);
 428}
 429EXPORT_SYMBOL_GPL(xdr_shift_buf);
 430
 431/**
 432 * xdr_stream_pos - Return the current offset from the start of the xdr_stream
 433 * @xdr: pointer to struct xdr_stream
 434 */
 435unsigned int xdr_stream_pos(const struct xdr_stream *xdr)
 436{
 437        return (unsigned int)(XDR_QUADLEN(xdr->buf->len) - xdr->nwords) << 2;
 438}
 439EXPORT_SYMBOL_GPL(xdr_stream_pos);
 440
 441/**
 442 * xdr_init_encode - Initialize a struct xdr_stream for sending data.
 443 * @xdr: pointer to xdr_stream struct
 444 * @buf: pointer to XDR buffer in which to encode data
 445 * @p: current pointer inside XDR buffer
 446 *
 447 * Note: at the moment the RPC client only passes the length of our
 448 *       scratch buffer in the xdr_buf's header kvec. Previously this
 449 *       meant we needed to call xdr_adjust_iovec() after encoding the
 450 *       data. With the new scheme, the xdr_stream manages the details
 451 *       of the buffer length, and takes care of adjusting the kvec
 452 *       length for us.
 453 */
 454void xdr_init_encode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p)
 455{
 456        struct kvec *iov = buf->head;
 457        int scratch_len = buf->buflen - buf->page_len - buf->tail[0].iov_len;
 458
 459        BUG_ON(scratch_len < 0);
 460        xdr->buf = buf;
 461        xdr->iov = iov;
 462        xdr->p = (__be32 *)((char *)iov->iov_base + iov->iov_len);
 463        xdr->end = (__be32 *)((char *)iov->iov_base + scratch_len);
 464        BUG_ON(iov->iov_len > scratch_len);
 465
 466        if (p != xdr->p && p != NULL) {
 467                size_t len;
 468
 469                BUG_ON(p < xdr->p || p > xdr->end);
 470                len = (char *)p - (char *)xdr->p;
 471                xdr->p = p;
 472                buf->len += len;
 473                iov->iov_len += len;
 474        }
 475}
 476EXPORT_SYMBOL_GPL(xdr_init_encode);
 477
 478/**
 479 * xdr_reserve_space - Reserve buffer space for sending
 480 * @xdr: pointer to xdr_stream
 481 * @nbytes: number of bytes to reserve
 482 *
 483 * Checks that we have enough buffer space to encode 'nbytes' more
 484 * bytes of data. If so, update the total xdr_buf length, and
 485 * adjust the length of the current kvec.
 486 */
 487__be32 * xdr_reserve_space(struct xdr_stream *xdr, size_t nbytes)
 488{
 489        __be32 *p = xdr->p;
 490        __be32 *q;
 491
 492        /* align nbytes on the next 32-bit boundary */
 493        nbytes += 3;
 494        nbytes &= ~3;
 495        q = p + (nbytes >> 2);
 496        if (unlikely(q > xdr->end || q < p))
 497                return NULL;
 498        xdr->p = q;
 499        xdr->iov->iov_len += nbytes;
 500        xdr->buf->len += nbytes;
 501        return p;
 502}
 503EXPORT_SYMBOL_GPL(xdr_reserve_space);
 504
 505/**
 506 * xdr_write_pages - Insert a list of pages into an XDR buffer for sending
 507 * @xdr: pointer to xdr_stream
 508 * @pages: list of pages
 509 * @base: offset of first byte
 510 * @len: length of data in bytes
 511 *
 512 */
 513void xdr_write_pages(struct xdr_stream *xdr, struct page **pages, unsigned int base,
 514                 unsigned int len)
 515{
 516        struct xdr_buf *buf = xdr->buf;
 517        struct kvec *iov = buf->tail;
 518        buf->pages = pages;
 519        buf->page_base = base;
 520        buf->page_len = len;
 521
 522        iov->iov_base = (char *)xdr->p;
 523        iov->iov_len  = 0;
 524        xdr->iov = iov;
 525
 526        if (len & 3) {
 527                unsigned int pad = 4 - (len & 3);
 528
 529                BUG_ON(xdr->p >= xdr->end);
 530                iov->iov_base = (char *)xdr->p + (len & 3);
 531                iov->iov_len  += pad;
 532                len += pad;
 533                *xdr->p++ = 0;
 534        }
 535        buf->buflen += len;
 536        buf->len += len;
 537}
 538EXPORT_SYMBOL_GPL(xdr_write_pages);
 539
 540static void xdr_set_iov(struct xdr_stream *xdr, struct kvec *iov,
 541                unsigned int len)
 542{
 543        if (len > iov->iov_len)
 544                len = iov->iov_len;
 545        xdr->p = (__be32*)iov->iov_base;
 546        xdr->end = (__be32*)(iov->iov_base + len);
 547        xdr->iov = iov;
 548        xdr->page_ptr = NULL;
 549}
 550
 551static int xdr_set_page_base(struct xdr_stream *xdr,
 552                unsigned int base, unsigned int len)
 553{
 554        unsigned int pgnr;
 555        unsigned int maxlen;
 556        unsigned int pgoff;
 557        unsigned int pgend;
 558        void *kaddr;
 559
 560        maxlen = xdr->buf->page_len;
 561        if (base >= maxlen)
 562                return -EINVAL;
 563        maxlen -= base;
 564        if (len > maxlen)
 565                len = maxlen;
 566
 567        base += xdr->buf->page_base;
 568
 569        pgnr = base >> PAGE_SHIFT;
 570        xdr->page_ptr = &xdr->buf->pages[pgnr];
 571        kaddr = page_address(*xdr->page_ptr);
 572
 573        pgoff = base & ~PAGE_MASK;
 574        xdr->p = (__be32*)(kaddr + pgoff);
 575
 576        pgend = pgoff + len;
 577        if (pgend > PAGE_SIZE)
 578                pgend = PAGE_SIZE;
 579        xdr->end = (__be32*)(kaddr + pgend);
 580        xdr->iov = NULL;
 581        return 0;
 582}
 583
 584static void xdr_set_next_page(struct xdr_stream *xdr)
 585{
 586        unsigned int newbase;
 587
 588        newbase = (1 + xdr->page_ptr - xdr->buf->pages) << PAGE_SHIFT;
 589        newbase -= xdr->buf->page_base;
 590
 591        if (xdr_set_page_base(xdr, newbase, PAGE_SIZE) < 0)
 592                xdr_set_iov(xdr, xdr->buf->tail, xdr->buf->len);
 593}
 594
 595static bool xdr_set_next_buffer(struct xdr_stream *xdr)
 596{
 597        if (xdr->page_ptr != NULL)
 598                xdr_set_next_page(xdr);
 599        else if (xdr->iov == xdr->buf->head) {
 600                if (xdr_set_page_base(xdr, 0, PAGE_SIZE) < 0)
 601                        xdr_set_iov(xdr, xdr->buf->tail, xdr->buf->len);
 602        }
 603        return xdr->p != xdr->end;
 604}
 605
 606/**
 607 * xdr_init_decode - Initialize an xdr_stream for decoding data.
 608 * @xdr: pointer to xdr_stream struct
 609 * @buf: pointer to XDR buffer from which to decode data
 610 * @p: current pointer inside XDR buffer
 611 */
 612void xdr_init_decode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p)
 613{
 614        xdr->buf = buf;
 615        xdr->scratch.iov_base = NULL;
 616        xdr->scratch.iov_len = 0;
 617        xdr->nwords = XDR_QUADLEN(buf->len);
 618        if (buf->head[0].iov_len != 0)
 619                xdr_set_iov(xdr, buf->head, buf->len);
 620        else if (buf->page_len != 0)
 621                xdr_set_page_base(xdr, 0, buf->len);
 622        if (p != NULL && p > xdr->p && xdr->end >= p) {
 623                xdr->nwords -= p - xdr->p;
 624                xdr->p = p;
 625        }
 626}
 627EXPORT_SYMBOL_GPL(xdr_init_decode);
 628
 629/**
 630 * xdr_init_decode - Initialize an xdr_stream for decoding data.
 631 * @xdr: pointer to xdr_stream struct
 632 * @buf: pointer to XDR buffer from which to decode data
 633 * @pages: list of pages to decode into
 634 * @len: length in bytes of buffer in pages
 635 */
 636void xdr_init_decode_pages(struct xdr_stream *xdr, struct xdr_buf *buf,
 637                           struct page **pages, unsigned int len)
 638{
 639        memset(buf, 0, sizeof(*buf));
 640        buf->pages =  pages;
 641        buf->page_len =  len;
 642        buf->buflen =  len;
 643        buf->len = len;
 644        xdr_init_decode(xdr, buf, NULL);
 645}
 646EXPORT_SYMBOL_GPL(xdr_init_decode_pages);
 647
 648static __be32 * __xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes)
 649{
 650        unsigned int nwords = XDR_QUADLEN(nbytes);
 651        __be32 *p = xdr->p;
 652        __be32 *q = p + nwords;
 653
 654        if (unlikely(nwords > xdr->nwords || q > xdr->end || q < p))
 655                return NULL;
 656        xdr->p = q;
 657        xdr->nwords -= nwords;
 658        return p;
 659}
 660
 661/**
 662 * xdr_set_scratch_buffer - Attach a scratch buffer for decoding data.
 663 * @xdr: pointer to xdr_stream struct
 664 * @buf: pointer to an empty buffer
 665 * @buflen: size of 'buf'
 666 *
 667 * The scratch buffer is used when decoding from an array of pages.
 668 * If an xdr_inline_decode() call spans across page boundaries, then
 669 * we copy the data into the scratch buffer in order to allow linear
 670 * access.
 671 */
 672void xdr_set_scratch_buffer(struct xdr_stream *xdr, void *buf, size_t buflen)
 673{
 674        xdr->scratch.iov_base = buf;
 675        xdr->scratch.iov_len = buflen;
 676}
 677EXPORT_SYMBOL_GPL(xdr_set_scratch_buffer);
 678
 679static __be32 *xdr_copy_to_scratch(struct xdr_stream *xdr, size_t nbytes)
 680{
 681        __be32 *p;
 682        void *cpdest = xdr->scratch.iov_base;
 683        size_t cplen = (char *)xdr->end - (char *)xdr->p;
 684
 685        if (nbytes > xdr->scratch.iov_len)
 686                return NULL;
 687        memcpy(cpdest, xdr->p, cplen);
 688        cpdest += cplen;
 689        nbytes -= cplen;
 690        if (!xdr_set_next_buffer(xdr))
 691                return NULL;
 692        p = __xdr_inline_decode(xdr, nbytes);
 693        if (p == NULL)
 694                return NULL;
 695        memcpy(cpdest, p, nbytes);
 696        return xdr->scratch.iov_base;
 697}
 698
 699/**
 700 * xdr_inline_decode - Retrieve XDR data to decode
 701 * @xdr: pointer to xdr_stream struct
 702 * @nbytes: number of bytes of data to decode
 703 *
 704 * Check if the input buffer is long enough to enable us to decode
 705 * 'nbytes' more bytes of data starting at the current position.
 706 * If so return the current pointer, then update the current
 707 * pointer position.
 708 */
 709__be32 * xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes)
 710{
 711        __be32 *p;
 712
 713        if (nbytes == 0)
 714                return xdr->p;
 715        if (xdr->p == xdr->end && !xdr_set_next_buffer(xdr))
 716                return NULL;
 717        p = __xdr_inline_decode(xdr, nbytes);
 718        if (p != NULL)
 719                return p;
 720        return xdr_copy_to_scratch(xdr, nbytes);
 721}
 722EXPORT_SYMBOL_GPL(xdr_inline_decode);
 723
 724static unsigned int xdr_align_pages(struct xdr_stream *xdr, unsigned int len)
 725{
 726        struct xdr_buf *buf = xdr->buf;
 727        struct kvec *iov;
 728        unsigned int nwords = XDR_QUADLEN(len);
 729        unsigned int cur = xdr_stream_pos(xdr);
 730
 731        if (xdr->nwords == 0)
 732                return 0;
 733        /* Realign pages to current pointer position */
 734        iov  = buf->head;
 735        if (iov->iov_len > cur) {
 736                xdr_shrink_bufhead(buf, iov->iov_len - cur);
 737                xdr->nwords = XDR_QUADLEN(buf->len - cur);
 738        }
 739
 740        if (nwords > xdr->nwords) {
 741                nwords = xdr->nwords;
 742                len = nwords << 2;
 743        }
 744        if (buf->page_len <= len)
 745                len = buf->page_len;
 746        else if (nwords < xdr->nwords) {
 747                /* Truncate page data and move it into the tail */
 748                xdr_shrink_pagelen(buf, buf->page_len - len);
 749                xdr->nwords = XDR_QUADLEN(buf->len - cur);
 750        }
 751        return len;
 752}
 753
 754/**
 755 * xdr_read_pages - Ensure page-based XDR data to decode is aligned at current pointer position
 756 * @xdr: pointer to xdr_stream struct
 757 * @len: number of bytes of page data
 758 *
 759 * Moves data beyond the current pointer position from the XDR head[] buffer
 760 * into the page list. Any data that lies beyond current position + "len"
 761 * bytes is moved into the XDR tail[].
 762 *
 763 * Returns the number of XDR encoded bytes now contained in the pages
 764 */
 765unsigned int xdr_read_pages(struct xdr_stream *xdr, unsigned int len)
 766{
 767        struct xdr_buf *buf = xdr->buf;
 768        struct kvec *iov;
 769        unsigned int nwords;
 770        unsigned int end;
 771        unsigned int padding;
 772
 773        len = xdr_align_pages(xdr, len);
 774        if (len == 0)
 775                return 0;
 776        nwords = XDR_QUADLEN(len);
 777        padding = (nwords << 2) - len;
 778        xdr->iov = iov = buf->tail;
 779        /* Compute remaining message length.  */
 780        end = ((xdr->nwords - nwords) << 2) + padding;
 781        if (end > iov->iov_len)
 782                end = iov->iov_len;
 783
 784        /*
 785         * Position current pointer at beginning of tail, and
 786         * set remaining message length.
 787         */
 788        xdr->p = (__be32 *)((char *)iov->iov_base + padding);
 789        xdr->end = (__be32 *)((char *)iov->iov_base + end);
 790        xdr->page_ptr = NULL;
 791        xdr->nwords = XDR_QUADLEN(end - padding);
 792        return len;
 793}
 794EXPORT_SYMBOL_GPL(xdr_read_pages);
 795
 796/**
 797 * xdr_enter_page - decode data from the XDR page
 798 * @xdr: pointer to xdr_stream struct
 799 * @len: number of bytes of page data
 800 *
 801 * Moves data beyond the current pointer position from the XDR head[] buffer
 802 * into the page list. Any data that lies beyond current position + "len"
 803 * bytes is moved into the XDR tail[]. The current pointer is then
 804 * repositioned at the beginning of the first XDR page.
 805 */
 806void xdr_enter_page(struct xdr_stream *xdr, unsigned int len)
 807{
 808        len = xdr_align_pages(xdr, len);
 809        /*
 810         * Position current pointer at beginning of tail, and
 811         * set remaining message length.
 812         */
 813        if (len != 0)
 814                xdr_set_page_base(xdr, 0, len);
 815}
 816EXPORT_SYMBOL_GPL(xdr_enter_page);
 817
 818static struct kvec empty_iov = {.iov_base = NULL, .iov_len = 0};
 819
 820void
 821xdr_buf_from_iov(struct kvec *iov, struct xdr_buf *buf)
 822{
 823        buf->head[0] = *iov;
 824        buf->tail[0] = empty_iov;
 825        buf->page_len = 0;
 826        buf->buflen = buf->len = iov->iov_len;
 827}
 828EXPORT_SYMBOL_GPL(xdr_buf_from_iov);
 829
 830/* Sets subbuf to the portion of buf of length len beginning base bytes
 831 * from the start of buf. Returns -1 if base of length are out of bounds. */
 832int
 833xdr_buf_subsegment(struct xdr_buf *buf, struct xdr_buf *subbuf,
 834                        unsigned int base, unsigned int len)
 835{
 836        subbuf->buflen = subbuf->len = len;
 837        if (base < buf->head[0].iov_len) {
 838                subbuf->head[0].iov_base = buf->head[0].iov_base + base;
 839                subbuf->head[0].iov_len = min_t(unsigned int, len,
 840                                                buf->head[0].iov_len - base);
 841                len -= subbuf->head[0].iov_len;
 842                base = 0;
 843        } else {
 844                subbuf->head[0].iov_base = NULL;
 845                subbuf->head[0].iov_len = 0;
 846                base -= buf->head[0].iov_len;
 847        }
 848
 849        if (base < buf->page_len) {
 850                subbuf->page_len = min(buf->page_len - base, len);
 851                base += buf->page_base;
 852                subbuf->page_base = base & ~PAGE_CACHE_MASK;
 853                subbuf->pages = &buf->pages[base >> PAGE_CACHE_SHIFT];
 854                len -= subbuf->page_len;
 855                base = 0;
 856        } else {
 857                base -= buf->page_len;
 858                subbuf->page_len = 0;
 859        }
 860
 861        if (base < buf->tail[0].iov_len) {
 862                subbuf->tail[0].iov_base = buf->tail[0].iov_base + base;
 863                subbuf->tail[0].iov_len = min_t(unsigned int, len,
 864                                                buf->tail[0].iov_len - base);
 865                len -= subbuf->tail[0].iov_len;
 866                base = 0;
 867        } else {
 868                subbuf->tail[0].iov_base = NULL;
 869                subbuf->tail[0].iov_len = 0;
 870                base -= buf->tail[0].iov_len;
 871        }
 872
 873        if (base || len)
 874                return -1;
 875        return 0;
 876}
 877EXPORT_SYMBOL_GPL(xdr_buf_subsegment);
 878
 879static void __read_bytes_from_xdr_buf(struct xdr_buf *subbuf, void *obj, unsigned int len)
 880{
 881        unsigned int this_len;
 882
 883        this_len = min_t(unsigned int, len, subbuf->head[0].iov_len);
 884        memcpy(obj, subbuf->head[0].iov_base, this_len);
 885        len -= this_len;
 886        obj += this_len;
 887        this_len = min_t(unsigned int, len, subbuf->page_len);
 888        if (this_len)
 889                _copy_from_pages(obj, subbuf->pages, subbuf->page_base, this_len);
 890        len -= this_len;
 891        obj += this_len;
 892        this_len = min_t(unsigned int, len, subbuf->tail[0].iov_len);
 893        memcpy(obj, subbuf->tail[0].iov_base, this_len);
 894}
 895
 896/* obj is assumed to point to allocated memory of size at least len: */
 897int read_bytes_from_xdr_buf(struct xdr_buf *buf, unsigned int base, void *obj, unsigned int len)
 898{
 899        struct xdr_buf subbuf;
 900        int status;
 901
 902        status = xdr_buf_subsegment(buf, &subbuf, base, len);
 903        if (status != 0)
 904                return status;
 905        __read_bytes_from_xdr_buf(&subbuf, obj, len);
 906        return 0;
 907}
 908EXPORT_SYMBOL_GPL(read_bytes_from_xdr_buf);
 909
 910static void __write_bytes_to_xdr_buf(struct xdr_buf *subbuf, void *obj, unsigned int len)
 911{
 912        unsigned int this_len;
 913
 914        this_len = min_t(unsigned int, len, subbuf->head[0].iov_len);
 915        memcpy(subbuf->head[0].iov_base, obj, this_len);
 916        len -= this_len;
 917        obj += this_len;
 918        this_len = min_t(unsigned int, len, subbuf->page_len);
 919        if (this_len)
 920                _copy_to_pages(subbuf->pages, subbuf->page_base, obj, this_len);
 921        len -= this_len;
 922        obj += this_len;
 923        this_len = min_t(unsigned int, len, subbuf->tail[0].iov_len);
 924        memcpy(subbuf->tail[0].iov_base, obj, this_len);
 925}
 926
 927/* obj is assumed to point to allocated memory of size at least len: */
 928int write_bytes_to_xdr_buf(struct xdr_buf *buf, unsigned int base, void *obj, unsigned int len)
 929{
 930        struct xdr_buf subbuf;
 931        int status;
 932
 933        status = xdr_buf_subsegment(buf, &subbuf, base, len);
 934        if (status != 0)
 935                return status;
 936        __write_bytes_to_xdr_buf(&subbuf, obj, len);
 937        return 0;
 938}
 939EXPORT_SYMBOL_GPL(write_bytes_to_xdr_buf);
 940
 941int
 942xdr_decode_word(struct xdr_buf *buf, unsigned int base, u32 *obj)
 943{
 944        __be32  raw;
 945        int     status;
 946
 947        status = read_bytes_from_xdr_buf(buf, base, &raw, sizeof(*obj));
 948        if (status)
 949                return status;
 950        *obj = be32_to_cpu(raw);
 951        return 0;
 952}
 953EXPORT_SYMBOL_GPL(xdr_decode_word);
 954
 955int
 956xdr_encode_word(struct xdr_buf *buf, unsigned int base, u32 obj)
 957{
 958        __be32  raw = cpu_to_be32(obj);
 959
 960        return write_bytes_to_xdr_buf(buf, base, &raw, sizeof(obj));
 961}
 962EXPORT_SYMBOL_GPL(xdr_encode_word);
 963
 964/* If the netobj starting offset bytes from the start of xdr_buf is contained
 965 * entirely in the head or the tail, set object to point to it; otherwise
 966 * try to find space for it at the end of the tail, copy it there, and
 967 * set obj to point to it. */
 968int xdr_buf_read_netobj(struct xdr_buf *buf, struct xdr_netobj *obj, unsigned int offset)
 969{
 970        struct xdr_buf subbuf;
 971
 972        if (xdr_decode_word(buf, offset, &obj->len))
 973                return -EFAULT;
 974        if (xdr_buf_subsegment(buf, &subbuf, offset + 4, obj->len))
 975                return -EFAULT;
 976
 977        /* Is the obj contained entirely in the head? */
 978        obj->data = subbuf.head[0].iov_base;
 979        if (subbuf.head[0].iov_len == obj->len)
 980                return 0;
 981        /* ..or is the obj contained entirely in the tail? */
 982        obj->data = subbuf.tail[0].iov_base;
 983        if (subbuf.tail[0].iov_len == obj->len)
 984                return 0;
 985
 986        /* use end of tail as storage for obj:
 987         * (We don't copy to the beginning because then we'd have
 988         * to worry about doing a potentially overlapping copy.
 989         * This assumes the object is at most half the length of the
 990         * tail.) */
 991        if (obj->len > buf->buflen - buf->len)
 992                return -ENOMEM;
 993        if (buf->tail[0].iov_len != 0)
 994                obj->data = buf->tail[0].iov_base + buf->tail[0].iov_len;
 995        else
 996                obj->data = buf->head[0].iov_base + buf->head[0].iov_len;
 997        __read_bytes_from_xdr_buf(&subbuf, obj->data, obj->len);
 998        return 0;
 999}
1000EXPORT_SYMBOL_GPL(xdr_buf_read_netobj);
1001
1002/* Returns 0 on success, or else a negative error code. */
1003static int
1004xdr_xcode_array2(struct xdr_buf *buf, unsigned int base,
1005                 struct xdr_array2_desc *desc, int encode)
1006{
1007        char *elem = NULL, *c;
1008        unsigned int copied = 0, todo, avail_here;
1009        struct page **ppages = NULL;
1010        int err;
1011
1012        if (encode) {
1013                if (xdr_encode_word(buf, base, desc->array_len) != 0)
1014                        return -EINVAL;
1015        } else {
1016                if (xdr_decode_word(buf, base, &desc->array_len) != 0 ||
1017                    desc->array_len > desc->array_maxlen ||
1018                    (unsigned long) base + 4 + desc->array_len *
1019                                    desc->elem_size > buf->len)
1020                        return -EINVAL;
1021        }
1022        base += 4;
1023
1024        if (!desc->xcode)
1025                return 0;
1026
1027        todo = desc->array_len * desc->elem_size;
1028
1029        /* process head */
1030        if (todo && base < buf->head->iov_len) {
1031                c = buf->head->iov_base + base;
1032                avail_here = min_t(unsigned int, todo,
1033                                   buf->head->iov_len - base);
1034                todo -= avail_here;
1035
1036                while (avail_here >= desc->elem_size) {
1037                        err = desc->xcode(desc, c);
1038                        if (err)
1039                                goto out;
1040                        c += desc->elem_size;
1041                        avail_here -= desc->elem_size;
1042                }
1043                if (avail_here) {
1044                        if (!elem) {
1045                                elem = kmalloc(desc->elem_size, GFP_KERNEL);
1046                                err = -ENOMEM;
1047                                if (!elem)
1048                                        goto out;
1049                        }
1050                        if (encode) {
1051                                err = desc->xcode(desc, elem);
1052                                if (err)
1053                                        goto out;
1054                                memcpy(c, elem, avail_here);
1055                        } else
1056                                memcpy(elem, c, avail_here);
1057                        copied = avail_here;
1058                }
1059                base = buf->head->iov_len;  /* align to start of pages */
1060        }
1061
1062        /* process pages array */
1063        base -= buf->head->iov_len;
1064        if (todo && base < buf->page_len) {
1065                unsigned int avail_page;
1066
1067                avail_here = min(todo, buf->page_len - base);
1068                todo -= avail_here;
1069
1070                base += buf->page_base;
1071                ppages = buf->pages + (base >> PAGE_CACHE_SHIFT);
1072                base &= ~PAGE_CACHE_MASK;
1073                avail_page = min_t(unsigned int, PAGE_CACHE_SIZE - base,
1074                                        avail_here);
1075                c = kmap(*ppages) + base;
1076
1077                while (avail_here) {
1078                        avail_here -= avail_page;
1079                        if (copied || avail_page < desc->elem_size) {
1080                                unsigned int l = min(avail_page,
1081                                        desc->elem_size - copied);
1082                                if (!elem) {
1083                                        elem = kmalloc(desc->elem_size,
1084                                                       GFP_KERNEL);
1085                                        err = -ENOMEM;
1086                                        if (!elem)
1087                                                goto out;
1088                                }
1089                                if (encode) {
1090                                        if (!copied) {
1091                                                err = desc->xcode(desc, elem);
1092                                                if (err)
1093                                                        goto out;
1094                                        }
1095                                        memcpy(c, elem + copied, l);
1096                                        copied += l;
1097                                        if (copied == desc->elem_size)
1098                                                copied = 0;
1099                                } else {
1100                                        memcpy(elem + copied, c, l);
1101                                        copied += l;
1102                                        if (copied == desc->elem_size) {
1103                                                err = desc->xcode(desc, elem);
1104                                                if (err)
1105                                                        goto out;
1106                                                copied = 0;
1107                                        }
1108                                }
1109                                avail_page -= l;
1110                                c += l;
1111                        }
1112                        while (avail_page >= desc->elem_size) {
1113                                err = desc->xcode(desc, c);
1114                                if (err)
1115                                        goto out;
1116                                c += desc->elem_size;
1117                                avail_page -= desc->elem_size;
1118                        }
1119                        if (avail_page) {
1120                                unsigned int l = min(avail_page,
1121                                            desc->elem_size - copied);
1122                                if (!elem) {
1123                                        elem = kmalloc(desc->elem_size,
1124                                                       GFP_KERNEL);
1125                                        err = -ENOMEM;
1126                                        if (!elem)
1127                                                goto out;
1128                                }
1129                                if (encode) {
1130                                        if (!copied) {
1131                                                err = desc->xcode(desc, elem);
1132                                                if (err)
1133                                                        goto out;
1134                                        }
1135                                        memcpy(c, elem + copied, l);
1136                                        copied += l;
1137                                        if (copied == desc->elem_size)
1138                                                copied = 0;
1139                                } else {
1140                                        memcpy(elem + copied, c, l);
1141                                        copied += l;
1142                                        if (copied == desc->elem_size) {
1143                                                err = desc->xcode(desc, elem);
1144                                                if (err)
1145                                                        goto out;
1146                                                copied = 0;
1147                                        }
1148                                }
1149                        }
1150                        if (avail_here) {
1151                                kunmap(*ppages);
1152                                ppages++;
1153                                c = kmap(*ppages);
1154                        }
1155
1156                        avail_page = min(avail_here,
1157                                 (unsigned int) PAGE_CACHE_SIZE);
1158                }
1159                base = buf->page_len;  /* align to start of tail */
1160        }
1161
1162        /* process tail */
1163        base -= buf->page_len;
1164        if (todo) {
1165                c = buf->tail->iov_base + base;
1166                if (copied) {
1167                        unsigned int l = desc->elem_size - copied;
1168
1169                        if (encode)
1170                                memcpy(c, elem + copied, l);
1171                        else {
1172                                memcpy(elem + copied, c, l);
1173                                err = desc->xcode(desc, elem);
1174                                if (err)
1175                                        goto out;
1176                        }
1177                        todo -= l;
1178                        c += l;
1179                }
1180                while (todo) {
1181                        err = desc->xcode(desc, c);
1182                        if (err)
1183                                goto out;
1184                        c += desc->elem_size;
1185                        todo -= desc->elem_size;
1186                }
1187        }
1188        err = 0;
1189
1190out:
1191        kfree(elem);
1192        if (ppages)
1193                kunmap(*ppages);
1194        return err;
1195}
1196
1197int
1198xdr_decode_array2(struct xdr_buf *buf, unsigned int base,
1199                  struct xdr_array2_desc *desc)
1200{
1201        if (base >= buf->len)
1202                return -EINVAL;
1203
1204        return xdr_xcode_array2(buf, base, desc, 0);
1205}
1206EXPORT_SYMBOL_GPL(xdr_decode_array2);
1207
1208int
1209xdr_encode_array2(struct xdr_buf *buf, unsigned int base,
1210                  struct xdr_array2_desc *desc)
1211{
1212        if ((unsigned long) base + 4 + desc->array_len * desc->elem_size >
1213            buf->head->iov_len + buf->page_len + buf->tail->iov_len)
1214                return -EINVAL;
1215
1216        return xdr_xcode_array2(buf, base, desc, 1);
1217}
1218EXPORT_SYMBOL_GPL(xdr_encode_array2);
1219
1220int
1221xdr_process_buf(struct xdr_buf *buf, unsigned int offset, unsigned int len,
1222                int (*actor)(struct scatterlist *, void *), void *data)
1223{
1224        int i, ret = 0;
1225        unsigned int page_len, thislen, page_offset;
1226        struct scatterlist      sg[1];
1227
1228        sg_init_table(sg, 1);
1229
1230        if (offset >= buf->head[0].iov_len) {
1231                offset -= buf->head[0].iov_len;
1232        } else {
1233                thislen = buf->head[0].iov_len - offset;
1234                if (thislen > len)
1235                        thislen = len;
1236                sg_set_buf(sg, buf->head[0].iov_base + offset, thislen);
1237                ret = actor(sg, data);
1238                if (ret)
1239                        goto out;
1240                offset = 0;
1241                len -= thislen;
1242        }
1243        if (len == 0)
1244                goto out;
1245
1246        if (offset >= buf->page_len) {
1247                offset -= buf->page_len;
1248        } else {
1249                page_len = buf->page_len - offset;
1250                if (page_len > len)
1251                        page_len = len;
1252                len -= page_len;
1253                page_offset = (offset + buf->page_base) & (PAGE_CACHE_SIZE - 1);
1254                i = (offset + buf->page_base) >> PAGE_CACHE_SHIFT;
1255                thislen = PAGE_CACHE_SIZE - page_offset;
1256                do {
1257                        if (thislen > page_len)
1258                                thislen = page_len;
1259                        sg_set_page(sg, buf->pages[i], thislen, page_offset);
1260                        ret = actor(sg, data);
1261                        if (ret)
1262                                goto out;
1263                        page_len -= thislen;
1264                        i++;
1265                        page_offset = 0;
1266                        thislen = PAGE_CACHE_SIZE;
1267                } while (page_len != 0);
1268                offset = 0;
1269        }
1270        if (len == 0)
1271                goto out;
1272        if (offset < buf->tail[0].iov_len) {
1273                thislen = buf->tail[0].iov_len - offset;
1274                if (thislen > len)
1275                        thislen = len;
1276                sg_set_buf(sg, buf->tail[0].iov_base + offset, thislen);
1277                ret = actor(sg, data);
1278                len -= thislen;
1279        }
1280        if (len != 0)
1281                ret = -EINVAL;
1282out:
1283        return ret;
1284}
1285EXPORT_SYMBOL_GPL(xdr_process_buf);
1286
1287
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.