net/sunrpc/xdr.c

   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 *
  23 xdr_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 }
  32 EXPORT_SYMBOL_GPL(xdr_encode_netobj);
  33
  34 __be32 *
  35 xdr_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 }
  45 EXPORT_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 }
  75 EXPORT_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 }
  90 EXPORT_SYMBOL_GPL(xdr_encode_opaque);
  91
  92 __be32 *
  93 xdr_encode_string(__be32 *p, const char *string)
  94 {
  95         return xdr_encode_array(p, string, strlen(string));
  96 }
  97 EXPORT_SYMBOL_GPL(xdr_encode_string);
  98
  99 __be32 *
 100 xdr_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 }
 112 EXPORT_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  */
 120 void
 121 xdr_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 }
 129 EXPORT_SYMBOL_GPL(xdr_terminate_string);
 130
 131 void
 132 xdr_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 }
 151 EXPORT_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  */
 171 static 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  */
 229 static 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  */
 273 void
 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 }
 301 EXPORT_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  */
 312 static void
 313 xdr_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
 322         WARN_ON_ONCE(len > head->iov_len);
 323         if (len > head->iov_len)
 324                 len = head->iov_len;
 325
 326         /* Shift the tail first */
 327         if (tail->iov_len != 0) {
 328                 if (tail->iov_len > len) {
 329                         copy = tail->iov_len - len;
 330                         memmove((char *)tail->iov_base + len,
 331                                         tail->iov_base, copy);
 332                 }
 333                 /* Copy from the inlined pages into the tail */
 334                 copy = len;
 335                 if (copy > pglen)
 336                         copy = pglen;
 337                 offs = len - copy;
 338                 if (offs >= tail->iov_len)
 339                         copy = 0;
 340                 else if (copy > tail->iov_len - offs)
 341                         copy = tail->iov_len - offs;
 342                 if (copy != 0)
 343                         _copy_from_pages((char *)tail->iov_base + offs,
 344                                         buf->pages,
 345                                         buf->page_base + pglen + offs - len,
 346                                         copy);
 347                 /* Do we also need to copy data from the head into the tail ? */
 348                 if (len > pglen) {
 349                         offs = copy = len - pglen;
 350                         if (copy > tail->iov_len)
 351                                 copy = tail->iov_len;
 352                         memcpy(tail->iov_base,
 353                                         (char *)head->iov_base +
 354                                         head->iov_len - offs,
 355                                         copy);
 356                 }
 357         }
 358         /* Now handle pages */
 359         if (pglen != 0) {
 360                 if (pglen > len)
 361                         _shift_data_right_pages(buf->pages,
 362                                         buf->page_base + len,
 363                                         buf->page_base,
 364                                         pglen - len);
 365                 copy = len;
 366                 if (len > pglen)
 367                         copy = pglen;
 368                 _copy_to_pages(buf->pages, buf->page_base,
 369                                 (char *)head->iov_base + head->iov_len - len,
 370                                 copy);
 371         }
 372         head->iov_len -= len;
 373         buf->buflen -= len;
 374         /* Have we truncated the message? */
 375         if (buf->len > buf->buflen)
 376                 buf->len = buf->buflen;
 377 }
 378
 379 /**
 380  * xdr_shrink_pagelen
 381  * @buf: xdr_buf
 382  * @len: bytes to remove from buf->pages
 383  *
 384  * Shrinks XDR buffer's page array buf->pages by
 385  * 'len' bytes. The extra data is not lost, but is instead
 386  * moved into the tail.
 387  */
 388 static void
 389 xdr_shrink_pagelen(struct xdr_buf *buf, size_t len)
 390 {
 391         struct kvec *tail;
 392         size_t copy;
 393         unsigned int pglen = buf->page_len;
 394         unsigned int tailbuf_len;
 395
 396         tail = buf->tail;
 397         BUG_ON (len > pglen);
 398
 399         tailbuf_len = buf->buflen - buf->head->iov_len - buf->page_len;
 400
 401         /* Shift the tail first */
 402         if (tailbuf_len != 0) {
 403                 unsigned int free_space = tailbuf_len - tail->iov_len;
 404
 405                 if (len < free_space)
 406                         free_space = len;
 407                 tail->iov_len += free_space;
 408
 409                 copy = len;
 410                 if (tail->iov_len > len) {
 411                         char *p = (char *)tail->iov_base + len;
 412                         memmove(p, tail->iov_base, tail->iov_len - len);
 413                 } else
 414                         copy = tail->iov_len;
 415                 /* Copy from the inlined pages into the tail */
 416                 _copy_from_pages((char *)tail->iov_base,
 417                                 buf->pages, buf->page_base + pglen - len,
 418                                 copy);
 419         }
 420         buf->page_len -= len;
 421         buf->buflen -= len;
 422         /* Have we truncated the message? */
 423         if (buf->len > buf->buflen)
 424                 buf->len = buf->buflen;
 425 }
 426
 427 void
 428 xdr_shift_buf(struct xdr_buf *buf, size_t len)
 429 {
 430         xdr_shrink_bufhead(buf, len);
 431 }
 432 EXPORT_SYMBOL_GPL(xdr_shift_buf);
 433
 434 /**
 435  * xdr_stream_pos - Return the current offset from the start of the xdr_stream
 436  * @xdr: pointer to struct xdr_stream
 437  */
 438 unsigned int xdr_stream_pos(const struct xdr_stream *xdr)
 439 {
 440         return (unsigned int)(XDR_QUADLEN(xdr->buf->len) - xdr->nwords) << 2;
 441 }
 442 EXPORT_SYMBOL_GPL(xdr_stream_pos);
 443
 444 /**
 445  * xdr_init_encode - Initialize a struct xdr_stream for sending data.
 446  * @xdr: pointer to xdr_stream struct
 447  * @buf: pointer to XDR buffer in which to encode data
 448  * @p: current pointer inside XDR buffer
 449  *
 450  * Note: at the moment the RPC client only passes the length of our
 451  *       scratch buffer in the xdr_buf's header kvec. Previously this
 452  *       meant we needed to call xdr_adjust_iovec() after encoding the
 453  *       data. With the new scheme, the xdr_stream manages the details
 454  *       of the buffer length, and takes care of adjusting the kvec
 455  *       length for us.
 456  */
 457 void xdr_init_encode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p)
 458 {
 459         struct kvec *iov = buf->head;
 460         int scratch_len = buf->buflen - buf->page_len - buf->tail[0].iov_len;
 461
 462         BUG_ON(scratch_len < 0);
 463         xdr->buf = buf;
 464         xdr->iov = iov;
 465         xdr->p = (__be32 *)((char *)iov->iov_base + iov->iov_len);
 466         xdr->end = (__be32 *)((char *)iov->iov_base + scratch_len);
 467         BUG_ON(iov->iov_len > scratch_len);
 468
 469         if (p != xdr->p && p != NULL) {
 470                 size_t len;
 471
 472                 BUG_ON(p < xdr->p || p > xdr->end);
 473                 len = (char *)p - (char *)xdr->p;
 474                 xdr->p = p;
 475                 buf->len += len;
 476                 iov->iov_len += len;
 477         }
 478 }
 479 EXPORT_SYMBOL_GPL(xdr_init_encode);
 480
 481 /**
 482  * xdr_reserve_space - Reserve buffer space for sending
 483  * @xdr: pointer to xdr_stream
 484  * @nbytes: number of bytes to reserve
 485  *
 486  * Checks that we have enough buffer space to encode 'nbytes' more
 487  * bytes of data. If so, update the total xdr_buf length, and
 488  * adjust the length of the current kvec.
 489  */
 490 __be32 * xdr_reserve_space(struct xdr_stream *xdr, size_t nbytes)
 491 {
 492         __be32 *p = xdr->p;
 493         __be32 *q;
 494
 495         /* align nbytes on the next 32-bit boundary */
 496         nbytes += 3;
 497         nbytes &= ~3;
 498         q = p + (nbytes >> 2);
 499         if (unlikely(q > xdr->end || q < p))
 500                 return NULL;
 501         xdr->p = q;
 502         xdr->iov->iov_len += nbytes;
 503         xdr->buf->len += nbytes;
 504         return p;
 505 }
 506 EXPORT_SYMBOL_GPL(xdr_reserve_space);
 507
 508 /**
 509  * xdr_write_pages - Insert a list of pages into an XDR buffer for sending
 510  * @xdr: pointer to xdr_stream
 511  * @pages: list of pages
 512  * @base: offset of first byte
 513  * @len: length of data in bytes
 514  *
 515  */
 516 void xdr_write_pages(struct xdr_stream *xdr, struct page **pages, unsigned int base,
 517                  unsigned int len)
 518 {
 519         struct xdr_buf *buf = xdr->buf;
 520         struct kvec *iov = buf->tail;
 521         buf->pages = pages;
 522         buf->page_base = base;
 523         buf->page_len = len;
 524
 525         iov->iov_base = (char *)xdr->p;
 526         iov->iov_len  = 0;
 527         xdr->iov = iov;
 528
 529         if (len & 3) {
 530                 unsigned int pad = 4 - (len & 3);
 531
 532                 BUG_ON(xdr->p >= xdr->end);
 533                 iov->iov_base = (char *)xdr->p + (len & 3);
 534                 iov->iov_len  += pad;
 535                 len += pad;
 536                 *xdr->p++ = 0;
 537         }
 538         buf->buflen += len;
 539         buf->len += len;
 540 }
 541 EXPORT_SYMBOL_GPL(xdr_write_pages);
 542
 543 static void xdr_set_iov(struct xdr_stream *xdr, struct kvec *iov,
 544                 unsigned int len)
 545 {
 546         if (len > iov->iov_len)
 547                 len = iov->iov_len;
 548         xdr->p = (__be32*)iov->iov_base;
 549         xdr->end = (__be32*)(iov->iov_base + len);
 550         xdr->iov = iov;
 551         xdr->page_ptr = NULL;
 552 }
 553
 554 static int xdr_set_page_base(struct xdr_stream *xdr,
 555                 unsigned int base, unsigned int len)
 556 {
 557         unsigned int pgnr;
 558         unsigned int maxlen;
 559         unsigned int pgoff;
 560         unsigned int pgend;
 561         void *kaddr;
 562
 563         maxlen = xdr->buf->page_len;
 564         if (base >= maxlen)
 565                 return -EINVAL;
 566         maxlen -= base;
 567         if (len > maxlen)
 568                 len = maxlen;
 569
 570         base += xdr->buf->page_base;
 571
 572         pgnr = base >> PAGE_SHIFT;
 573         xdr->page_ptr = &xdr->buf->pages[pgnr];
 574         kaddr = page_address(*xdr->page_ptr);
 575
 576         pgoff = base & ~PAGE_MASK;
 577         xdr->p = (__be32*)(kaddr + pgoff);
 578
 579         pgend = pgoff + len;
 580         if (pgend > PAGE_SIZE)
 581                 pgend = PAGE_SIZE;
 582         xdr->end = (__be32*)(kaddr + pgend);
 583         xdr->iov = NULL;
 584         return 0;
 585 }
 586
 587 static void xdr_set_next_page(struct xdr_stream *xdr)
 588 {
 589         unsigned int newbase;
 590
 591         newbase = (1 + xdr->page_ptr - xdr->buf->pages) << PAGE_SHIFT;
 592         newbase -= xdr->buf->page_base;
 593
 594         if (xdr_set_page_base(xdr, newbase, PAGE_SIZE) < 0)
 595                 xdr_set_iov(xdr, xdr->buf->tail, xdr->buf->len);
 596 }
 597
 598 static bool xdr_set_next_buffer(struct xdr_stream *xdr)
 599 {
 600         if (xdr->page_ptr != NULL)
 601                 xdr_set_next_page(xdr);
 602         else if (xdr->iov == xdr->buf->head) {
 603                 if (xdr_set_page_base(xdr, 0, PAGE_SIZE) < 0)
 604                         xdr_set_iov(xdr, xdr->buf->tail, xdr->buf->len);
 605         }
 606         return xdr->p != xdr->end;
 607 }
 608
 609 /**
 610  * xdr_init_decode - Initialize an xdr_stream for decoding data.
 611  * @xdr: pointer to xdr_stream struct
 612  * @buf: pointer to XDR buffer from which to decode data
 613  * @p: current pointer inside XDR buffer
 614  */
 615 void xdr_init_decode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p)
 616 {
 617         xdr->buf = buf;
 618         xdr->scratch.iov_base = NULL;
 619         xdr->scratch.iov_len = 0;
 620         xdr->nwords = XDR_QUADLEN(buf->len);
 621         if (buf->head[0].iov_len != 0)
 622                 xdr_set_iov(xdr, buf->head, buf->len);
 623         else if (buf->page_len != 0)
 624                 xdr_set_page_base(xdr, 0, buf->len);
 625         if (p != NULL && p > xdr->p && xdr->end >= p) {
 626                 xdr->nwords -= p - xdr->p;
 627                 xdr->p = p;
 628         }
 629 }
 630 EXPORT_SYMBOL_GPL(xdr_init_decode);
 631
 632 /**
 633  * xdr_init_decode - Initialize an xdr_stream for decoding data.
 634  * @xdr: pointer to xdr_stream struct
 635  * @buf: pointer to XDR buffer from which to decode data
 636  * @pages: list of pages to decode into
 637  * @len: length in bytes of buffer in pages
 638  */
 639 void xdr_init_decode_pages(struct xdr_stream *xdr, struct xdr_buf *buf,
 640                            struct page **pages, unsigned int len)
 641 {
 642         memset(buf, 0, sizeof(*buf));
 643         buf->pages =  pages;
 644         buf->page_len =  len;
 645         buf->buflen =  len;
 646         buf->len = len;
 647         xdr_init_decode(xdr, buf, NULL);
 648 }
 649 EXPORT_SYMBOL_GPL(xdr_init_decode_pages);
 650
 651 static __be32 * __xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes)
 652 {
 653         unsigned int nwords = XDR_QUADLEN(nbytes);
 654         __be32 *p = xdr->p;
 655         __be32 *q = p + nwords;
 656
 657         if (unlikely(nwords > xdr->nwords || q > xdr->end || q < p))
 658                 return NULL;
 659         xdr->p = q;
 660         xdr->nwords -= nwords;
 661         return p;
 662 }
 663
 664 /**
 665  * xdr_set_scratch_buffer - Attach a scratch buffer for decoding data.
 666  * @xdr: pointer to xdr_stream struct
 667  * @buf: pointer to an empty buffer
 668  * @buflen: size of 'buf'
 669  *
 670  * The scratch buffer is used when decoding from an array of pages.
 671  * If an xdr_inline_decode() call spans across page boundaries, then
 672  * we copy the data into the scratch buffer in order to allow linear
 673  * access.
 674  */
 675 void xdr_set_scratch_buffer(struct xdr_stream *xdr, void *buf, size_t buflen)
 676 {
 677         xdr->scratch.iov_base = buf;
 678         xdr->scratch.iov_len = buflen;
 679 }
 680 EXPORT_SYMBOL_GPL(xdr_set_scratch_buffer);
 681
 682 static __be32 *xdr_copy_to_scratch(struct xdr_stream *xdr, size_t nbytes)
 683 {
 684         __be32 *p;
 685         void *cpdest = xdr->scratch.iov_base;
 686         size_t cplen = (char *)xdr->end - (char *)xdr->p;
 687
 688         if (nbytes > xdr->scratch.iov_len)
 689                 return NULL;
 690         memcpy(cpdest, xdr->p, cplen);
 691         cpdest += cplen;
 692         nbytes -= cplen;
 693         if (!xdr_set_next_buffer(xdr))
 694                 return NULL;
 695         p = __xdr_inline_decode(xdr, nbytes);
 696         if (p == NULL)
 697                 return NULL;
 698         memcpy(cpdest, p, nbytes);
 699         return xdr->scratch.iov_base;
 700 }
 701
 702 /**
 703  * xdr_inline_decode - Retrieve XDR data to decode
 704  * @xdr: pointer to xdr_stream struct
 705  * @nbytes: number of bytes of data to decode
 706  *
 707  * Check if the input buffer is long enough to enable us to decode
 708  * 'nbytes' more bytes of data starting at the current position.
 709  * If so return the current pointer, then update the current
 710  * pointer position.
 711  */
 712 __be32 * xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes)
 713 {
 714         __be32 *p;
 715
 716         if (nbytes == 0)
 717                 return xdr->p;
 718         if (xdr->p == xdr->end && !xdr_set_next_buffer(xdr))
 719                 return NULL;
 720         p = __xdr_inline_decode(xdr, nbytes);
 721         if (p != NULL)
 722                 return p;
 723         return xdr_copy_to_scratch(xdr, nbytes);
 724 }
 725 EXPORT_SYMBOL_GPL(xdr_inline_decode);
 726
 727 static unsigned int xdr_align_pages(struct xdr_stream *xdr, unsigned int len)
 728 {
 729         struct xdr_buf *buf = xdr->buf;
 730         struct kvec *iov;
 731         unsigned int nwords = XDR_QUADLEN(len);
 732         unsigned int cur = xdr_stream_pos(xdr);
 733
 734         if (xdr->nwords == 0)
 735                 return 0;
 736         /* Realign pages to current pointer position */
 737         iov  = buf->head;
 738         if (iov->iov_len > cur) {
 739                 xdr_shrink_bufhead(buf, iov->iov_len - cur);
 740                 xdr->nwords = XDR_QUADLEN(buf->len - cur);
 741         }
 742
 743         if (nwords > xdr->nwords) {
 744                 nwords = xdr->nwords;
 745                 len = nwords << 2;
 746         }
 747         if (buf->page_len <= len)
 748                 len = buf->page_len;
 749         else if (nwords < xdr->nwords) {
 750                 /* Truncate page data and move it into the tail */
 751                 xdr_shrink_pagelen(buf, buf->page_len - len);
 752                 xdr->nwords = XDR_QUADLEN(buf->len - cur);
 753         }
 754         return len;
 755 }
 756
 757 /**
 758  * xdr_read_pages - Ensure page-based XDR data to decode is aligned at current pointer position
 759  * @xdr: pointer to xdr_stream struct
 760  * @len: number of bytes of page data
 761  *
 762  * Moves data beyond the current pointer position from the XDR head[] buffer
 763  * into the page list. Any data that lies beyond current position + "len"
 764  * bytes is moved into the XDR tail[].
 765  *
 766  * Returns the number of XDR encoded bytes now contained in the pages
 767  */
 768 unsigned int xdr_read_pages(struct xdr_stream *xdr, unsigned int len)
 769 {
 770         struct xdr_buf *buf = xdr->buf;
 771         struct kvec *iov;
 772         unsigned int nwords;
 773         unsigned int end;
 774         unsigned int padding;
 775
 776         len = xdr_align_pages(xdr, len);
 777         if (len == 0)
 778                 return 0;
 779         nwords = XDR_QUADLEN(len);
 780         padding = (nwords << 2) - len;
 781         xdr->iov = iov = buf->tail;
 782         /* Compute remaining message length.  */
 783         end = ((xdr->nwords - nwords) << 2) + padding;
 784         if (end > iov->iov_len)
 785                 end = iov->iov_len;
 786
 787         /*
 788          * Position current pointer at beginning of tail, and
 789          * set remaining message length.
 790          */
 791         xdr->p = (__be32 *)((char *)iov->iov_base + padding);
 792         xdr->end = (__be32 *)((char *)iov->iov_base + end);
 793         xdr->page_ptr = NULL;
 794         xdr->nwords = XDR_QUADLEN(end - padding);
 795         return len;
 796 }
 797 EXPORT_SYMBOL_GPL(xdr_read_pages);
 798
 799 /**
 800  * xdr_enter_page - decode data from the XDR page
 801  * @xdr: pointer to xdr_stream struct
 802  * @len: number of bytes of page data
 803  *
 804  * Moves data beyond the current pointer position from the XDR head[] buffer
 805  * into the page list. Any data that lies beyond current position + "len"
 806  * bytes is moved into the XDR tail[]. The current pointer is then
 807  * repositioned at the beginning of the first XDR page.
 808  */
 809 void xdr_enter_page(struct xdr_stream *xdr, unsigned int len)
 810 {
 811         len = xdr_align_pages(xdr, len);
 812         /*
 813          * Position current pointer at beginning of tail, and
 814          * set remaining message length.
 815          */
 816         if (len != 0)
 817                 xdr_set_page_base(xdr, 0, len);
 818 }
 819 EXPORT_SYMBOL_GPL(xdr_enter_page);
 820
 821 static struct kvec empty_iov = {.iov_base = NULL, .iov_len = 0};
 822
 823 void
 824 xdr_buf_from_iov(struct kvec *iov, struct xdr_buf *buf)
 825 {
 826         buf->head[0] = *iov;
 827         buf->tail[0] = empty_iov;
 828         buf->page_len = 0;
 829         buf->buflen = buf->len = iov->iov_len;
 830 }
 831 EXPORT_SYMBOL_GPL(xdr_buf_from_iov);
 832
 833 /* Sets subbuf to the portion of buf of length len beginning base bytes
 834  * from the start of buf. Returns -1 if base of length are out of bounds. */
 835 int
 836 xdr_buf_subsegment(struct xdr_buf *buf, struct xdr_buf *subbuf,
 837                         unsigned int base, unsigned int len)
 838 {
 839         subbuf->buflen = subbuf->len = len;
 840         if (base < buf->head[0].iov_len) {
 841                 subbuf->head[0].iov_base = buf->head[0].iov_base + base;
 842                 subbuf->head[0].iov_len = min_t(unsigned int, len,
 843                                                 buf->head[0].iov_len - base);
 844                 len -= subbuf->head[0].iov_len;
 845                 base = 0;
 846         } else {
 847                 subbuf->head[0].iov_base = NULL;
 848                 subbuf->head[0].iov_len = 0;
 849                 base -= buf->head[0].iov_len;
 850         }
 851
 852         if (base < buf->page_len) {
 853                 subbuf->page_len = min(buf->page_len - base, len);
 854                 base += buf->page_base;
 855                 subbuf->page_base = base & ~PAGE_CACHE_MASK;
 856                 subbuf->pages = &buf->pages[base >> PAGE_CACHE_SHIFT];
 857                 len -= subbuf->page_len;
 858                 base = 0;
 859         } else {
 860                 base -= buf->page_len;
 861                 subbuf->page_len = 0;
 862         }
 863
 864         if (base < buf->tail[0].iov_len) {
 865                 subbuf->tail[0].iov_base = buf->tail[0].iov_base + base;
 866                 subbuf->tail[0].iov_len = min_t(unsigned int, len,
 867                                                 buf->tail[0].iov_len - base);
 868                 len -= subbuf->tail[0].iov_len;
 869                 base = 0;
 870         } else {
 871                 subbuf->tail[0].iov_base = NULL;
 872                 subbuf->tail[0].iov_len = 0;
 873                 base -= buf->tail[0].iov_len;
 874         }
 875
 876         if (base || len)
 877                 return -1;
 878         return 0;
 879 }
 880 EXPORT_SYMBOL_GPL(xdr_buf_subsegment);
 881
 882 /**
 883  * xdr_buf_trim - lop at most "len" bytes off the end of "buf"
 884  * @buf: buf to be trimmed
 885  * @len: number of bytes to reduce "buf" by
 886  *
 887  * Trim an xdr_buf by the given number of bytes by fixing up the lengths. Note
 888  * that it's possible that we'll trim less than that amount if the xdr_buf is
 889  * too small, or if (for instance) it's all in the head and the parser has
 890  * already read too far into it.
 891  */
 892 void xdr_buf_trim(struct xdr_buf *buf, unsigned int len)
 893 {
 894         size_t cur;
 895         unsigned int trim = len;
 896
 897         if (buf->tail[0].iov_len) {
 898                 cur = min_t(size_t, buf->tail[0].iov_len, trim);
 899                 buf->tail[0].iov_len -= cur;
 900                 trim -= cur;
 901                 if (!trim)
 902                         goto fix_len;
 903         }
 904
 905         if (buf->page_len) {
 906                 cur = min_t(unsigned int, buf->page_len, trim);
 907                 buf->page_len -= cur;
 908                 trim -= cur;
 909                 if (!trim)
 910                         goto fix_len;
 911         }
 912
 913         if (buf->head[0].iov_len) {
 914                 cur = min_t(size_t, buf->head[0].iov_len, trim);
 915                 buf->head[0].iov_len -= cur;
 916                 trim -= cur;
 917         }
 918 fix_len:
 919         buf->len -= (len - trim);
 920 }
 921 EXPORT_SYMBOL_GPL(xdr_buf_trim);
 922
 923 static void __read_bytes_from_xdr_buf(struct xdr_buf *subbuf, void *obj, unsigned int len)
 924 {
 925         unsigned int this_len;
 926
 927         this_len = min_t(unsigned int, len, subbuf->head[0].iov_len);
 928         memcpy(obj, subbuf->head[0].iov_base, this_len);
 929         len -= this_len;
 930         obj += this_len;
 931         this_len = min_t(unsigned int, len, subbuf->page_len);
 932         if (this_len)
 933                 _copy_from_pages(obj, subbuf->pages, subbuf->page_base, this_len);
 934         len -= this_len;
 935         obj += this_len;
 936         this_len = min_t(unsigned int, len, subbuf->tail[0].iov_len);
 937         memcpy(obj, subbuf->tail[0].iov_base, this_len);
 938 }
 939
 940 /* obj is assumed to point to allocated memory of size at least len: */
 941 int read_bytes_from_xdr_buf(struct xdr_buf *buf, unsigned int base, void *obj, unsigned int len)
 942 {
 943         struct xdr_buf subbuf;
 944         int status;
 945
 946         status = xdr_buf_subsegment(buf, &subbuf, base, len);
 947         if (status != 0)
 948                 return status;
 949         __read_bytes_from_xdr_buf(&subbuf, obj, len);
 950         return 0;
 951 }
 952 EXPORT_SYMBOL_GPL(read_bytes_from_xdr_buf);
 953
 954 static void __write_bytes_to_xdr_buf(struct xdr_buf *subbuf, void *obj, unsigned int len)
 955 {
 956         unsigned int this_len;
 957
 958         this_len = min_t(unsigned int, len, subbuf->head[0].iov_len);
 959         memcpy(subbuf->head[0].iov_base, obj, this_len);
 960         len -= this_len;
 961         obj += this_len;
 962         this_len = min_t(unsigned int, len, subbuf->page_len);
 963         if (this_len)
 964                 _copy_to_pages(subbuf->pages, subbuf->page_base, obj, this_len);
 965         len -= this_len;
 966         obj += this_len;
 967         this_len = min_t(unsigned int, len, subbuf->tail[0].iov_len);
 968         memcpy(subbuf->tail[0].iov_base, obj, this_len);
 969 }
 970
 971 /* obj is assumed to point to allocated memory of size at least len: */
 972 int write_bytes_to_xdr_buf(struct xdr_buf *buf, unsigned int base, void *obj, unsigned int len)
 973 {
 974         struct xdr_buf subbuf;
 975         int status;
 976
 977         status = xdr_buf_subsegment(buf, &subbuf, base, len);
 978         if (status != 0)
 979                 return status;
 980         __write_bytes_to_xdr_buf(&subbuf, obj, len);
 981         return 0;
 982 }
 983 EXPORT_SYMBOL_GPL(write_bytes_to_xdr_buf);
 984
 985 int
 986 xdr_decode_word(struct xdr_buf *buf, unsigned int base, u32 *obj)
 987 {
 988         __be32  raw;
 989         int     status;
 990
 991         status = read_bytes_from_xdr_buf(buf, base, &raw, sizeof(*obj));
 992         if (status)
 993                 return status;
 994         *obj = be32_to_cpu(raw);
 995         return 0;
 996 }
 997 EXPORT_SYMBOL_GPL(xdr_decode_word);
 998
 999 int
1000 xdr_encode_word(struct xdr_buf *buf, unsigned int base, u32 obj)
1001 {
1002         __be32  raw = cpu_to_be32(obj);
1003
1004         return write_bytes_to_xdr_buf(buf, base, &raw, sizeof(obj));
1005 }
1006 EXPORT_SYMBOL_GPL(xdr_encode_word);
1007
1008 /* If the netobj starting offset bytes from the start of xdr_buf is contained
1009  * entirely in the head or the tail, set object to point to it; otherwise
1010  * try to find space for it at the end of the tail, copy it there, and
1011  * set obj to point to it. */
1012 int xdr_buf_read_netobj(struct xdr_buf *buf, struct xdr_netobj *obj, unsigned int offset)
1013 {
1014         struct xdr_buf subbuf;
1015
1016         if (xdr_decode_word(buf, offset, &obj->len))
1017                 return -EFAULT;
1018         if (xdr_buf_subsegment(buf, &subbuf, offset + 4, obj->len))
1019                 return -EFAULT;
1020
1021         /* Is the obj contained entirely in the head? */
1022         obj->data = subbuf.head[0].iov_base;
1023         if (subbuf.head[0].iov_len == obj->len)
1024                 return 0;
1025         /* ..or is the obj contained entirely in the tail? */
1026         obj->data = subbuf.tail[0].iov_base;
1027         if (subbuf.tail[0].iov_len == obj->len)
1028                 return 0;
1029
1030         /* use end of tail as storage for obj:
1031          * (We don't copy to the beginning because then we'd have
1032          * to worry about doing a potentially overlapping copy.
1033          * This assumes the object is at most half the length of the
1034          * tail.) */
1035         if (obj->len > buf->buflen - buf->len)
1036                 return -ENOMEM;
1037         if (buf->tail[0].iov_len != 0)
1038                 obj->data = buf->tail[0].iov_base + buf->tail[0].iov_len;
1039         else
1040                 obj->data = buf->head[0].iov_base + buf->head[0].iov_len;
1041         __read_bytes_from_xdr_buf(&subbuf, obj->data, obj->len);
1042         return 0;
1043 }
1044 EXPORT_SYMBOL_GPL(xdr_buf_read_netobj);
1045
1046 /* Returns 0 on success, or else a negative error code. */
1047 static int
1048 xdr_xcode_array2(struct xdr_buf *buf, unsigned int base,
1049                  struct xdr_array2_desc *desc, int encode)
1050 {
1051         char *elem = NULL, *c;
1052         unsigned int copied = 0, todo, avail_here;
1053         struct page **ppages = NULL;
1054         int err;
1055
1056         if (encode) {
1057                 if (xdr_encode_word(buf, base, desc->array_len) != 0)
1058                         return -EINVAL;
1059         } else {
1060                 if (xdr_decode_word(buf, base, &desc->array_len) != 0 ||
1061                     desc->array_len > desc->array_maxlen ||
1062                     (unsigned long) base + 4 + desc->array_len *
1063                                     desc->elem_size > buf->len)
1064                         return -EINVAL;
1065         }
1066         base += 4;
1067
1068         if (!desc->xcode)
1069                 return 0;
1070
1071         todo = desc->array_len * desc->elem_size;
1072
1073         /* process head */
1074         if (todo && base < buf->head->iov_len) {
1075                 c = buf->head->iov_base + base;
1076                 avail_here = min_t(unsigned int, todo,
1077                                    buf->head->iov_len - base);
1078                 todo -= avail_here;
1079
1080                 while (avail_here >= desc->elem_size) {
1081                         err = desc->xcode(desc, c);
1082                         if (err)
1083                                 goto out;
1084                         c += desc->elem_size;
1085                         avail_here -= desc->elem_size;
1086                 }
1087                 if (avail_here) {
1088                         if (!elem) {
1089                                 elem = kmalloc(desc->elem_size, GFP_KERNEL);
1090                                 err = -ENOMEM;
1091                                 if (!elem)
1092                                         goto out;
1093                         }
1094                         if (encode) {
1095                                 err = desc->xcode(desc, elem);
1096                                 if (err)
1097                                         goto out;
1098                                 memcpy(c, elem, avail_here);
1099                         } else
1100                                 memcpy(elem, c, avail_here);
1101                         copied = avail_here;
1102                 }
1103                 base = buf->head->iov_len;  /* align to start of pages */
1104         }
1105
1106         /* process pages array */
1107         base -= buf->head->iov_len;
1108         if (todo && base < buf->page_len) {
1109                 unsigned int avail_page;
1110
1111                 avail_here = min(todo, buf->page_len - base);
1112                 todo -= avail_here;
1113
1114                 base += buf->page_base;
1115                 ppages = buf->pages + (base >> PAGE_CACHE_SHIFT);
1116                 base &= ~PAGE_CACHE_MASK;
1117                 avail_page = min_t(unsigned int, PAGE_CACHE_SIZE - base,
1118                                         avail_here);
1119                 c = kmap(*ppages) + base;
1120
1121                 while (avail_here) {
1122                         avail_here -= avail_page;
1123                         if (copied || avail_page < desc->elem_size) {
1124                                 unsigned int l = min(avail_page,
1125                                         desc->elem_size - copied);
1126                                 if (!elem) {
1127                                         elem = kmalloc(desc->elem_size,
1128                                                        GFP_KERNEL);
1129                                         err = -ENOMEM;
1130                                         if (!elem)
1131                                                 goto out;
1132                                 }
1133                                 if (encode) {
1134                                         if (!copied) {
1135                                                 err = desc->xcode(desc, elem);
1136                                                 if (err)
1137                                                         goto out;
1138                                         }
1139                                         memcpy(c, elem + copied, l);
1140                                         copied += l;
1141                                         if (copied == desc->elem_size)
1142                                                 copied = 0;
1143                                 } else {
1144                                         memcpy(elem + copied, c, l);
1145                                         copied += l;
1146                                         if (copied == desc->elem_size) {
1147                                                 err = desc->xcode(desc, elem);
1148                                                 if (err)
1149                                                         goto out;
1150                                                 copied = 0;
1151                                         }
1152                                 }
1153                                 avail_page -= l;
1154                                 c += l;
1155                         }
1156                         while (avail_page >= desc->elem_size) {
1157                                 err = desc->xcode(desc, c);
1158                                 if (err)
1159                                         goto out;
1160                                 c += desc->elem_size;
1161                                 avail_page -= desc->elem_size;
1162                         }
1163                         if (avail_page) {
1164                                 unsigned int l = min(avail_page,
1165                                             desc->elem_size - copied);
1166                                 if (!elem) {
1167                                         elem = kmalloc(desc->elem_size,
1168                                                        GFP_KERNEL);
1169                                         err = -ENOMEM;
1170                                         if (!elem)
1171                                                 goto out;
1172                                 }
1173                                 if (encode) {
1174                                         if (!copied) {
1175                                                 err = desc->xcode(desc, elem);
1176                                                 if (err)
1177                                                         goto out;
1178                                         }
1179                                         memcpy(c, elem + copied, l);
1180                                         copied += l;
1181                                         if (copied == desc->elem_size)
1182                                                 copied = 0;
1183                                 } else {
1184                                         memcpy(elem + copied, c, l);
1185                                         copied += l;
1186                                         if (copied == desc->elem_size) {
1187                                                 err = desc->xcode(desc, elem);
1188                                                 if (err)
1189                                                         goto out;
1190                                                 copied = 0;
1191                                         }
1192                                 }
1193                         }
1194                         if (avail_here) {
1195                                 kunmap(*ppages);
1196                                 ppages++;
1197                                 c = kmap(*ppages);
1198                         }
1199
1200                         avail_page = min(avail_here,
1201                                  (unsigned int) PAGE_CACHE_SIZE);
1202                 }
1203                 base = buf->page_len;  /* align to start of tail */
1204         }
1205
1206         /* process tail */
1207         base -= buf->page_len;
1208         if (todo) {
1209                 c = buf->tail->iov_base + base;
1210                 if (copied) {
1211                         unsigned int l = desc->elem_size - copied;
1212
1213                         if (encode)
1214                                 memcpy(c, elem + copied, l);
1215                         else {
1216                                 memcpy(elem + copied, c, l);
1217                                 err = desc->xcode(desc, elem);
1218                                 if (err)
1219                                         goto out;
1220                         }
1221                         todo -= l;
1222                         c += l;
1223                 }
1224                 while (todo) {
1225                         err = desc->xcode(desc, c);
1226                         if (err)
1227                                 goto out;
1228                         c += desc->elem_size;
1229                         todo -= desc->elem_size;
1230                 }
1231         }
1232         err = 0;
1233
1234 out:
1235         kfree(elem);
1236         if (ppages)
1237                 kunmap(*ppages);
1238         return err;
1239 }
1240
1241 int
1242 xdr_decode_array2(struct xdr_buf *buf, unsigned int base,
1243                   struct xdr_array2_desc *desc)
1244 {
1245         if (base >= buf->len)
1246                 return -EINVAL;
1247
1248         return xdr_xcode_array2(buf, base, desc, 0);
1249 }
1250 EXPORT_SYMBOL_GPL(xdr_decode_array2);
1251
1252 int
1253 xdr_encode_array2(struct xdr_buf *buf, unsigned int base,
1254                   struct xdr_array2_desc *desc)
1255 {
1256         if ((unsigned long) base + 4 + desc->array_len * desc->elem_size >
1257             buf->head->iov_len + buf->page_len + buf->tail->iov_len)
1258                 return -EINVAL;
1259
1260         return xdr_xcode_array2(buf, base, desc, 1);
1261 }
1262 EXPORT_SYMBOL_GPL(xdr_encode_array2);
1263
1264 int
1265 xdr_process_buf(struct xdr_buf *buf, unsigned int offset, unsigned int len,
1266                 int (*actor)(struct scatterlist *, void *), void *data)
1267 {
1268         int i, ret = 0;
1269         unsigned int page_len, thislen, page_offset;
1270         struct scatterlist      sg[1];
1271
1272         sg_init_table(sg, 1);
1273
1274         if (offset >= buf->head[0].iov_len) {
1275                 offset -= buf->head[0].iov_len;
1276         } else {
1277                 thislen = buf->head[0].iov_len - offset;
1278                 if (thislen > len)
1279                         thislen = len;
1280                 sg_set_buf(sg, buf->head[0].iov_base + offset, thislen);
1281                 ret = actor(sg, data);
1282                 if (ret)
1283                         goto out;
1284                 offset = 0;
1285                 len -= thislen;
1286         }
1287         if (len == 0)
1288                 goto out;
1289
1290         if (offset >= buf->page_len) {
1291                 offset -= buf->page_len;
1292         } else {
1293                 page_len = buf->page_len - offset;
1294                 if (page_len > len)
1295                         page_len = len;
1296                 len -= page_len;
1297                 page_offset = (offset + buf->page_base) & (PAGE_CACHE_SIZE - 1);
1298                 i = (offset + buf->page_base) >> PAGE_CACHE_SHIFT;
1299                 thislen = PAGE_CACHE_SIZE - page_offset;
1300                 do {
1301                         if (thislen > page_len)
1302                                 thislen = page_len;
1303                         sg_set_page(sg, buf->pages[i], thislen, page_offset);
1304                         ret = actor(sg, data);
1305                         if (ret)
1306                                 goto out;
1307                         page_len -= thislen;
1308                         i++;
1309                         page_offset = 0;
1310                         thislen = PAGE_CACHE_SIZE;
1311                 } while (page_len != 0);
1312                 offset = 0;
1313         }
1314         if (len == 0)
1315                 goto out;
1316         if (offset < buf->tail[0].iov_len) {
1317                 thislen = buf->tail[0].iov_len - offset;
1318                 if (thislen > len)
1319                         thislen = len;
1320                 sg_set_buf(sg, buf->tail[0].iov_base + offset, thislen);
1321                 ret = actor(sg, data);
1322                 len -= thislen;
1323         }
1324         if (len != 0)
1325                 ret = -EINVAL;
1326 out:
1327         return ret;
1328 }
1329 EXPORT_SYMBOL_GPL(xdr_process_buf);
1330