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        if (nwords > xdr->nwords) {
 734                nwords = xdr->nwords;
 735                len = nwords << 2;
 736        }
 737        /* Realign pages to current pointer position */
 738        iov  = buf->head;
 739        if (iov->iov_len > cur)
 740                xdr_shrink_bufhead(buf, iov->iov_len - cur);
 741
 742        /* Truncate page data and move it into the tail */
 743        if (buf->page_len > len)
 744                xdr_shrink_pagelen(buf, buf->page_len - len);
 745        xdr->nwords = XDR_QUADLEN(buf->len - cur);
 746        return len;
 747}
 748
 749/**
 750 * xdr_read_pages - Ensure page-based XDR data to decode is aligned at current pointer position
 751 * @xdr: pointer to xdr_stream struct
 752 * @len: number of bytes of page data
 753 *
 754 * Moves data beyond the current pointer position from the XDR head[] buffer
 755 * into the page list. Any data that lies beyond current position + "len"
 756 * bytes is moved into the XDR tail[].
 757 *
 758 * Returns the number of XDR encoded bytes now contained in the pages
 759 */
 760unsigned int xdr_read_pages(struct xdr_stream *xdr, unsigned int len)
 761{
 762        struct xdr_buf *buf = xdr->buf;
 763        struct kvec *iov;
 764        unsigned int nwords;
 765        unsigned int end;
 766        unsigned int padding;
 767
 768        len = xdr_align_pages(xdr, len);
 769        if (len == 0)
 770                return 0;
 771        nwords = XDR_QUADLEN(len);
 772        padding = (nwords << 2) - len;
 773        xdr->iov = iov = buf->tail;
 774        /* Compute remaining message length.  */
 775        end = ((xdr->nwords - nwords) << 2) + padding;
 776        if (end > iov->iov_len)
 777                end = iov->iov_len;
 778
 779        /*
 780         * Position current pointer at beginning of tail, and
 781         * set remaining message length.
 782         */
 783        xdr->p = (__be32 *)((char *)iov->iov_base + padding);
 784        xdr->end = (__be32 *)((char *)iov->iov_base + end);
 785        xdr->page_ptr = NULL;
 786        xdr->nwords = XDR_QUADLEN(end - padding);
 787        return len;
 788}
 789EXPORT_SYMBOL_GPL(xdr_read_pages);
 790
 791/**
 792 * xdr_enter_page - decode data from the XDR page
 793 * @xdr: pointer to xdr_stream struct
 794 * @len: number of bytes of page data
 795 *
 796 * Moves data beyond the current pointer position from the XDR head[] buffer
 797 * into the page list. Any data that lies beyond current position + "len"
 798 * bytes is moved into the XDR tail[]. The current pointer is then
 799 * repositioned at the beginning of the first XDR page.
 800 */
 801void xdr_enter_page(struct xdr_stream *xdr, unsigned int len)
 802{
 803        len = xdr_align_pages(xdr, len);
 804        /*
 805         * Position current pointer at beginning of tail, and
 806         * set remaining message length.
 807         */
 808        if (len != 0)
 809                xdr_set_page_base(xdr, 0, len);
 810}
 811EXPORT_SYMBOL_GPL(xdr_enter_page);
 812
 813static struct kvec empty_iov = {.iov_base = NULL, .iov_len = 0};
 814
 815void
 816xdr_buf_from_iov(struct kvec *iov, struct xdr_buf *buf)
 817{
 818        buf->head[0] = *iov;
 819        buf->tail[0] = empty_iov;
 820        buf->page_len = 0;
 821        buf->buflen = buf->len = iov->iov_len;
 822}
 823EXPORT_SYMBOL_GPL(xdr_buf_from_iov);
 824
 825/* Sets subbuf to the portion of buf of length len beginning base bytes
 826 * from the start of buf. Returns -1 if base of length are out of bounds. */
 827int
 828xdr_buf_subsegment(struct xdr_buf *buf, struct xdr_buf *subbuf,
 829                        unsigned int base, unsigned int len)
 830{
 831        subbuf->buflen = subbuf->len = len;
 832        if (base < buf->head[0].iov_len) {
 833                subbuf->head[0].iov_base = buf->head[0].iov_base + base;
 834                subbuf->head[0].iov_len = min_t(unsigned int, len,
 835                                                buf->head[0].iov_len - base);
 836                len -= subbuf->head[0].iov_len;
 837                base = 0;
 838        } else {
 839                subbuf->head[0].iov_base = NULL;
 840                subbuf->head[0].iov_len = 0;
 841                base -= buf->head[0].iov_len;
 842        }
 843
 844        if (base < buf->page_len) {
 845                subbuf->page_len = min(buf->page_len - base, len);
 846                base += buf->page_base;
 847                subbuf->page_base = base & ~PAGE_CACHE_MASK;
 848                subbuf->pages = &buf->pages[base >> PAGE_CACHE_SHIFT];
 849                len -= subbuf->page_len;
 850                base = 0;
 851        } else {
 852                base -= buf->page_len;
 853                subbuf->page_len = 0;
 854        }
 855
 856        if (base < buf->tail[0].iov_len) {
 857                subbuf->tail[0].iov_base = buf->tail[0].iov_base + base;
 858                subbuf->tail[0].iov_len = min_t(unsigned int, len,
 859                                                buf->tail[0].iov_len - base);
 860                len -= subbuf->tail[0].iov_len;
 861                base = 0;
 862        } else {
 863                subbuf->tail[0].iov_base = NULL;
 864                subbuf->tail[0].iov_len = 0;
 865                base -= buf->tail[0].iov_len;
 866        }
 867
 868        if (base || len)
 869                return -1;
 870        return 0;
 871}
 872EXPORT_SYMBOL_GPL(xdr_buf_subsegment);
 873
 874static void __read_bytes_from_xdr_buf(struct xdr_buf *subbuf, void *obj, unsigned int len)
 875{
 876        unsigned int this_len;
 877
 878        this_len = min_t(unsigned int, len, subbuf->head[0].iov_len);
 879        memcpy(obj, subbuf->head[0].iov_base, this_len);
 880        len -= this_len;
 881        obj += this_len;
 882        this_len = min_t(unsigned int, len, subbuf->page_len);
 883        if (this_len)
 884                _copy_from_pages(obj, subbuf->pages, subbuf->page_base, this_len);
 885        len -= this_len;
 886        obj += this_len;
 887        this_len = min_t(unsigned int, len, subbuf->tail[0].iov_len);
 888        memcpy(obj, subbuf->tail[0].iov_base, this_len);
 889}
 890
 891/* obj is assumed to point to allocated memory of size at least len: */
 892int read_bytes_from_xdr_buf(struct xdr_buf *buf, unsigned int base, void *obj, unsigned int len)
 893{
 894        struct xdr_buf subbuf;
 895        int status;
 896
 897        status = xdr_buf_subsegment(buf, &subbuf, base, len);
 898        if (status != 0)
 899                return status;
 900        __read_bytes_from_xdr_buf(&subbuf, obj, len);
 901        return 0;
 902}
 903EXPORT_SYMBOL_GPL(read_bytes_from_xdr_buf);
 904
 905static void __write_bytes_to_xdr_buf(struct xdr_buf *subbuf, void *obj, unsigned int len)
 906{
 907        unsigned int this_len;
 908
 909        this_len = min_t(unsigned int, len, subbuf->head[0].iov_len);
 910        memcpy(subbuf->head[0].iov_base, obj, this_len);
 911        len -= this_len;
 912        obj += this_len;
 913        this_len = min_t(unsigned int, len, subbuf->page_len);
 914        if (this_len)
 915                _copy_to_pages(subbuf->pages, subbuf->page_base, obj, this_len);
 916        len -= this_len;
 917        obj += this_len;
 918        this_len = min_t(unsigned int, len, subbuf->tail[0].iov_len);
 919        memcpy(subbuf->tail[0].iov_base, obj, this_len);
 920}
 921
 922/* obj is assumed to point to allocated memory of size at least len: */
 923int write_bytes_to_xdr_buf(struct xdr_buf *buf, unsigned int base, void *obj, unsigned int len)
 924{
 925        struct xdr_buf subbuf;
 926        int status;
 927
 928        status = xdr_buf_subsegment(buf, &subbuf, base, len);
 929        if (status != 0)
 930                return status;
 931        __write_bytes_to_xdr_buf(&subbuf, obj, len);
 932        return 0;
 933}
 934EXPORT_SYMBOL_GPL(write_bytes_to_xdr_buf);
 935
 936int
 937xdr_decode_word(struct xdr_buf *buf, unsigned int base, u32 *obj)
 938{
 939        __be32  raw;
 940        int     status;
 941
 942        status = read_bytes_from_xdr_buf(buf, base, &raw, sizeof(*obj));
 943        if (status)
 944                return status;
 945        *obj = be32_to_cpu(raw);
 946        return 0;
 947}
 948EXPORT_SYMBOL_GPL(xdr_decode_word);
 949
 950int
 951xdr_encode_word(struct xdr_buf *buf, unsigned int base, u32 obj)
 952{
 953        __be32  raw = cpu_to_be32(obj);
 954
 955        return write_bytes_to_xdr_buf(buf, base, &raw, sizeof(obj));
 956}
 957EXPORT_SYMBOL_GPL(xdr_encode_word);
 958
 959/* If the netobj starting offset bytes from the start of xdr_buf is contained
 960 * entirely in the head or the tail, set object to point to it; otherwise
 961 * try to find space for it at the end of the tail, copy it there, and
 962 * set obj to point to it. */
 963int xdr_buf_read_netobj(struct xdr_buf *buf, struct xdr_netobj *obj, unsigned int offset)
 964{
 965        struct xdr_buf subbuf;
 966
 967        if (xdr_decode_word(buf, offset, &obj->len))
 968                return -EFAULT;
 969        if (xdr_buf_subsegment(buf, &subbuf, offset + 4, obj->len))
 970                return -EFAULT;
 971
 972        /* Is the obj contained entirely in the head? */
 973        obj->data = subbuf.head[0].iov_base;
 974        if (subbuf.head[0].iov_len == obj->len)
 975                return 0;
 976        /* ..or is the obj contained entirely in the tail? */
 977        obj->data = subbuf.tail[0].iov_base;
 978        if (subbuf.tail[0].iov_len == obj->len)
 979                return 0;
 980
 981        /* use end of tail as storage for obj:
 982         * (We don't copy to the beginning because then we'd have
 983         * to worry about doing a potentially overlapping copy.
 984         * This assumes the object is at most half the length of the
 985         * tail.) */
 986        if (obj->len > buf->buflen - buf->len)
 987                return -ENOMEM;
 988        if (buf->tail[0].iov_len != 0)
 989                obj->data = buf->tail[0].iov_base + buf->tail[0].iov_len;
 990        else
 991                obj->data = buf->head[0].iov_base + buf->head[0].iov_len;
 992        __read_bytes_from_xdr_buf(&subbuf, obj->data, obj->len);
 993        return 0;
 994}
 995EXPORT_SYMBOL_GPL(xdr_buf_read_netobj);
 996
 997/* Returns 0 on success, or else a negative error code. */
 998static int
 999xdr_xcode_array2(struct xdr_buf *buf, unsigned int base,
1000                 struct xdr_array2_desc *desc, int encode)
1001{
1002        char *elem = NULL, *c;
1003        unsigned int copied = 0, todo, avail_here;
1004        struct page **ppages = NULL;
1005        int err;
1006
1007        if (encode) {
1008                if (xdr_encode_word(buf, base, desc->array_len) != 0)
1009                        return -EINVAL;
1010        } else {
1011                if (xdr_decode_word(buf, base, &desc->array_len) != 0 ||
1012                    desc->array_len > desc->array_maxlen ||
1013                    (unsigned long) base + 4 + desc->array_len *
1014                                    desc->elem_size > buf->len)
1015                        return -EINVAL;
1016        }
1017        base += 4;
1018
1019        if (!desc->xcode)
1020                return 0;
1021
1022        todo = desc->array_len * desc->elem_size;
1023
1024        /* process head */
1025        if (todo && base < buf->head->iov_len) {
1026                c = buf->head->iov_base + base;
1027                avail_here = min_t(unsigned int, todo,
1028                                   buf->head->iov_len - base);
1029                todo -= avail_here;
1030
1031                while (avail_here >= desc->elem_size) {
1032                        err = desc->xcode(desc, c);
1033                        if (err)
1034                                goto out;
1035                        c += desc->elem_size;
1036                        avail_here -= desc->elem_size;
1037                }
1038                if (avail_here) {
1039                        if (!elem) {
1040                                elem = kmalloc(desc->elem_size, GFP_KERNEL);
1041                                err = -ENOMEM;
1042                                if (!elem)
1043                                        goto out;
1044                        }
1045                        if (encode) {
1046                                err = desc->xcode(desc, elem);
1047                                if (err)
1048                                        goto out;
1049                                memcpy(c, elem, avail_here);
1050                        } else
1051                                memcpy(elem, c, avail_here);
1052                        copied = avail_here;
1053                }
1054                base = buf->head->iov_len;  /* align to start of pages */
1055        }
1056
1057        /* process pages array */
1058        base -= buf->head->iov_len;
1059        if (todo && base < buf->page_len) {
1060                unsigned int avail_page;
1061
1062                avail_here = min(todo, buf->page_len - base);
1063                todo -= avail_here;
1064
1065                base += buf->page_base;
1066                ppages = buf->pages + (base >> PAGE_CACHE_SHIFT);
1067                base &= ~PAGE_CACHE_MASK;
1068                avail_page = min_t(unsigned int, PAGE_CACHE_SIZE - base,
1069                                        avail_here);
1070                c = kmap(*ppages) + base;
1071
1072                while (avail_here) {
1073                        avail_here -= avail_page;
1074                        if (copied || avail_page < desc->elem_size) {
1075                                unsigned int l = min(avail_page,
1076                                        desc->elem_size - copied);
1077                                if (!elem) {
1078                                        elem = kmalloc(desc->elem_size,
1079                                                       GFP_KERNEL);
1080                                        err = -ENOMEM;
1081                                        if (!elem)
1082                                                goto out;
1083                                }
1084                                if (encode) {
1085                                        if (!copied) {
1086                                                err = desc->xcode(desc, elem);
1087                                                if (err)
1088                                                        goto out;
1089                                        }
1090                                        memcpy(c, elem + copied, l);
1091                                        copied += l;
1092                                        if (copied == desc->elem_size)
1093                                                copied = 0;
1094                                } else {
1095                                        memcpy(elem + copied, c, l);
1096                                        copied += l;
1097                                        if (copied == desc->elem_size) {
1098                                                err = desc->xcode(desc, elem);
1099                                                if (err)
1100                                                        goto out;
1101                                                copied = 0;
1102                                        }
1103                                }
1104                                avail_page -= l;
1105                                c += l;
1106                        }
1107                        while (avail_page >= desc->elem_size) {
1108                                err = desc->xcode(desc, c);
1109                                if (err)
1110                                        goto out;
1111                                c += desc->elem_size;
1112                                avail_page -= desc->elem_size;
1113                        }
1114                        if (avail_page) {
1115                                unsigned int l = min(avail_page,
1116                                            desc->elem_size - copied);
1117                                if (!elem) {
1118                                        elem = kmalloc(desc->elem_size,
1119                                                       GFP_KERNEL);
1120                                        err = -ENOMEM;
1121                                        if (!elem)
1122                                                goto out;
1123                                }
1124                                if (encode) {
1125                                        if (!copied) {
1126                                                err = desc->xcode(desc, elem);
1127                                                if (err)
1128                                                        goto out;
1129                                        }
1130                                        memcpy(c, elem + copied, l);
1131                                        copied += l;
1132                                        if (copied == desc->elem_size)
1133                                                copied = 0;
1134                                } else {
1135                                        memcpy(elem + copied, c, l);
1136                                        copied += l;
1137                                        if (copied == desc->elem_size) {
1138                                                err = desc->xcode(desc, elem);
1139                                                if (err)
1140                                                        goto out;
1141                                                copied = 0;
1142                                        }
1143                                }
1144                        }
1145                        if (avail_here) {
1146                                kunmap(*ppages);
1147                                ppages++;
1148                                c = kmap(*ppages);
1149                        }
1150
1151                        avail_page = min(avail_here,
1152                                 (unsigned int) PAGE_CACHE_SIZE);
1153                }
1154                base = buf->page_len;  /* align to start of tail */
1155        }
1156
1157        /* process tail */
1158        base -= buf->page_len;
1159        if (todo) {
1160                c = buf->tail->iov_base + base;
1161                if (copied) {
1162                        unsigned int l = desc->elem_size - copied;
1163
1164                        if (encode)
1165                                memcpy(c, elem + copied, l);
1166                        else {
1167                                memcpy(elem + copied, c, l);
1168                                err = desc->xcode(desc, elem);
1169                                if (err)
1170                                        goto out;
1171                        }
1172                        todo -= l;
1173                        c += l;
1174                }
1175                while (todo) {
1176                        err = desc->xcode(desc, c);
1177                        if (err)
1178                                goto out;
1179                        c += desc->elem_size;
1180                        todo -= desc->elem_size;
1181                }
1182        }
1183        err = 0;
1184
1185out:
1186        kfree(elem);
1187        if (ppages)
1188                kunmap(*ppages);
1189        return err;
1190}
1191
1192int
1193xdr_decode_array2(struct xdr_buf *buf, unsigned int base,
1194                  struct xdr_array2_desc *desc)
1195{
1196        if (base >= buf->len)
1197                return -EINVAL;
1198
1199        return xdr_xcode_array2(buf, base, desc, 0);
1200}
1201EXPORT_SYMBOL_GPL(xdr_decode_array2);
1202
1203int
1204xdr_encode_array2(struct xdr_buf *buf, unsigned int base,
1205                  struct xdr_array2_desc *desc)
1206{
1207        if ((unsigned long) base + 4 + desc->array_len * desc->elem_size >
1208            buf->head->iov_len + buf->page_len + buf->tail->iov_len)
1209                return -EINVAL;
1210
1211        return xdr_xcode_array2(buf, base, desc, 1);
1212}
1213EXPORT_SYMBOL_GPL(xdr_encode_array2);
1214
1215int
1216xdr_process_buf(struct xdr_buf *buf, unsigned int offset, unsigned int len,
1217                int (*actor)(struct scatterlist *, void *), void *data)
1218{
1219        int i, ret = 0;
1220        unsigned int page_len, thislen, page_offset;
1221        struct scatterlist      sg[1];
1222
1223        sg_init_table(sg, 1);
1224
1225        if (offset >= buf->head[0].iov_len) {
1226                offset -= buf->head[0].iov_len;
1227        } else {
1228                thislen = buf->head[0].iov_len - offset;
1229                if (thislen > len)
1230                        thislen = len;
1231                sg_set_buf(sg, buf->head[0].iov_base + offset, thislen);
1232                ret = actor(sg, data);
1233                if (ret)
1234                        goto out;
1235                offset = 0;
1236                len -= thislen;
1237        }
1238        if (len == 0)
1239                goto out;
1240
1241        if (offset >= buf->page_len) {
1242                offset -= buf->page_len;
1243        } else {
1244                page_len = buf->page_len - offset;
1245                if (page_len > len)
1246                        page_len = len;
1247                len -= page_len;
1248                page_offset = (offset + buf->page_base) & (PAGE_CACHE_SIZE - 1);
1249                i = (offset + buf->page_base) >> PAGE_CACHE_SHIFT;
1250                thislen = PAGE_CACHE_SIZE - page_offset;
1251                do {
1252                        if (thislen > page_len)
1253                                thislen = page_len;
1254                        sg_set_page(sg, buf->pages[i], thislen, page_offset);
1255                        ret = actor(sg, data);
1256                        if (ret)
1257                                goto out;
1258                        page_len -= thislen;
1259                        i++;
1260                        page_offset = 0;
1261                        thislen = PAGE_CACHE_SIZE;
1262                } while (page_len != 0);
1263                offset = 0;
1264        }
1265        if (len == 0)
1266                goto out;
1267        if (offset < buf->tail[0].iov_len) {
1268                thislen = buf->tail[0].iov_len - offset;
1269                if (thislen > len)
1270                        thislen = len;
1271                sg_set_buf(sg, buf->tail[0].iov_base + offset, thislen);
1272                ret = actor(sg, data);
1273                len -= thislen;
1274        }
1275        if (len != 0)
1276                ret = -EINVAL;
1277out:
1278        return ret;
1279}
1280EXPORT_SYMBOL_GPL(xdr_process_buf);
1281
1282
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.