Lines Matching +full:trim +full:- +full:data +full:- +full:valid
1 // SPDX-License-Identifier: GPL-2.0-only
31 unsigned int quadlen = XDR_QUADLEN(obj->len); in xdr_encode_netobj()
34 *p++ = cpu_to_be32(obj->len); in xdr_encode_netobj()
35 memcpy(p, obj->data, obj->len); in xdr_encode_netobj()
36 return p + XDR_QUADLEN(obj->len); in xdr_encode_netobj()
41 * xdr_encode_opaque_fixed - Encode fixed length opaque data
43 * @ptr: pointer to data to encode (or NULL)
44 * @nbytes: size of data.
46 * Copy the array of data of length nbytes at ptr to the XDR buffer
47 * at position p, then align to the next 32-bit boundary by padding
58 unsigned int padding = (quadlen << 2) - nbytes; in xdr_encode_opaque_fixed()
71 * xdr_encode_opaque - Encode variable length opaque data
73 * @ptr: pointer to data to encode (or NULL)
74 * @nbytes: size of data.
93 * xdr_terminate_string - '\0'-terminate a string residing in an xdr_buf
102 kaddr = kmap_atomic(buf->pages[0]); in xdr_terminate_string()
103 kaddr[buf->page_base + len] = '\0'; in xdr_terminate_string()
110 if (!buf->page_len) in xdr_buf_pagecount()
112 return (buf->page_base + buf->page_len + PAGE_SIZE - 1) >> PAGE_SHIFT; in xdr_buf_pagecount()
120 if (n != 0 && buf->bvec == NULL) { in xdr_alloc_bvec()
121 buf->bvec = kmalloc_array(n, sizeof(buf->bvec[0]), gfp); in xdr_alloc_bvec()
122 if (!buf->bvec) in xdr_alloc_bvec()
123 return -ENOMEM; in xdr_alloc_bvec()
125 bvec_set_page(&buf->bvec[i], buf->pages[i], PAGE_SIZE, in xdr_alloc_bvec()
135 kfree(buf->bvec); in xdr_free_bvec()
136 buf->bvec = NULL; in xdr_free_bvec()
140 * xdr_buf_to_bvec - Copy components of an xdr_buf into a bio_vec array
150 const struct kvec *head = xdr->head; in xdr_buf_to_bvec()
151 const struct kvec *tail = xdr->tail; in xdr_buf_to_bvec()
154 if (head->iov_len) { in xdr_buf_to_bvec()
155 bvec_set_virt(bvec++, head->iov_base, head->iov_len); in xdr_buf_to_bvec()
159 if (xdr->page_len) { in xdr_buf_to_bvec()
161 struct page **pages = xdr->pages; in xdr_buf_to_bvec()
163 offset = offset_in_page(xdr->page_base); in xdr_buf_to_bvec()
164 remaining = xdr->page_len; in xdr_buf_to_bvec()
167 PAGE_SIZE - offset); in xdr_buf_to_bvec()
169 remaining -= len; in xdr_buf_to_bvec()
176 if (tail->iov_len) { in xdr_buf_to_bvec()
177 bvec_set_virt(bvec, tail->iov_base, tail->iov_len); in xdr_buf_to_bvec()
186 return count - 1; in xdr_buf_to_bvec()
191 * xdr_inline_pages - Prepare receive buffer for a large reply
193 * @offset: expected offset where data payload will start, in bytes
196 * @len: expected size of the upper layer data payload, in bytes
203 struct kvec *head = xdr->head; in xdr_inline_pages()
204 struct kvec *tail = xdr->tail; in xdr_inline_pages()
205 char *buf = (char *)head->iov_base; in xdr_inline_pages()
206 unsigned int buflen = head->iov_len; in xdr_inline_pages()
208 head->iov_len = offset; in xdr_inline_pages()
210 xdr->pages = pages; in xdr_inline_pages()
211 xdr->page_base = base; in xdr_inline_pages()
212 xdr->page_len = len; in xdr_inline_pages()
214 tail->iov_base = buf + offset; in xdr_inline_pages()
215 tail->iov_len = buflen - offset; in xdr_inline_pages()
216 xdr->buflen += len; in xdr_inline_pages()
268 if (copy > (PAGE_SIZE - pgto_base)) in _shift_data_left_pages()
269 copy = PAGE_SIZE - pgto_base; in _shift_data_left_pages()
270 if (copy > (PAGE_SIZE - pgfrom_base)) in _shift_data_left_pages()
271 copy = PAGE_SIZE - pgfrom_base; in _shift_data_left_pages()
286 } while ((len -= copy) != 0); in _shift_data_left_pages()
329 pgto--; in _shift_data_right_pages()
333 pgfrom--; in _shift_data_right_pages()
341 pgto_base -= copy; in _shift_data_right_pages()
342 pgfrom_base -= copy; in _shift_data_right_pages()
354 } while ((len -= copy) != 0); in _shift_data_right_pages()
361 * @p: pointer to source data
364 * Copies data from an arbitrary memory location into an array of pages
365 * The copy is assumed to be non-overlapping.
381 copy = PAGE_SIZE - pgbase; in _copy_to_pages()
389 len -= copy; in _copy_to_pages()
408 * @pgbase: offset of source data
411 * Copies data into an arbitrary memory location from an array of pages
412 * The copy is assumed to be non-overlapping.
428 copy = PAGE_SIZE - pgbase; in _copy_from_pages()
443 } while ((len -= copy) != 0); in _copy_from_pages()
450 if (base >= iov->iov_len) in xdr_buf_iov_zero()
452 if (len > iov->iov_len - base) in xdr_buf_iov_zero()
453 len = iov->iov_len - base; in xdr_buf_iov_zero()
454 memset(iov->iov_base + base, 0, len); in xdr_buf_iov_zero()
466 struct page **pages = buf->pages; in xdr_buf_pages_zero()
473 if (pgbase >= buf->page_len) { in xdr_buf_pages_zero()
474 xdr_buf_iov_zero(buf->tail, pgbase - buf->page_len, len); in xdr_buf_pages_zero()
477 if (pgbase + len > buf->page_len) { in xdr_buf_pages_zero()
478 xdr_buf_iov_zero(buf->tail, 0, pgbase + len - buf->page_len); in xdr_buf_pages_zero()
479 len = buf->page_len - pgbase; in xdr_buf_pages_zero()
482 pgbase += buf->page_base; in xdr_buf_pages_zero()
488 zero = PAGE_SIZE - pgbase; in xdr_buf_pages_zero()
500 } while ((len -= zero) != 0); in xdr_buf_pages_zero()
508 if (!(buf->flags & XDRBUF_SPARSE_PAGES)) in xdr_buf_pages_fill_sparse()
510 if (buflen <= buf->head->iov_len) in xdr_buf_pages_fill_sparse()
512 pagelen = buflen - buf->head->iov_len; in xdr_buf_pages_fill_sparse()
513 if (pagelen > buf->page_len) in xdr_buf_pages_fill_sparse()
514 pagelen = buf->page_len; in xdr_buf_pages_fill_sparse()
515 npages = (pagelen + buf->page_base + PAGE_SIZE - 1) >> PAGE_SHIFT; in xdr_buf_pages_fill_sparse()
517 if (!buf->pages[i]) in xdr_buf_pages_fill_sparse()
519 buf->pages[i] = alloc_page(gfp); in xdr_buf_pages_fill_sparse()
520 if (likely(buf->pages[i])) in xdr_buf_pages_fill_sparse()
522 buflen -= pagelen; in xdr_buf_pages_fill_sparse()
524 if (pagelen > buf->page_base) in xdr_buf_pages_fill_sparse()
525 buflen += pagelen - buf->page_base; in xdr_buf_pages_fill_sparse()
533 struct kvec *head = buf->head; in xdr_buf_try_expand()
534 struct kvec *tail = buf->tail; in xdr_buf_try_expand()
535 unsigned int sum = head->iov_len + buf->page_len + tail->iov_len; in xdr_buf_try_expand()
538 if (sum > buf->len) { in xdr_buf_try_expand()
539 free_space = min_t(unsigned int, sum - buf->len, len); in xdr_buf_try_expand()
540 newlen = xdr_buf_pages_fill_sparse(buf, buf->len + free_space, in xdr_buf_try_expand()
542 free_space = newlen - buf->len; in xdr_buf_try_expand()
543 buf->len = newlen; in xdr_buf_try_expand()
544 len -= free_space; in xdr_buf_try_expand()
549 if (buf->buflen > sum) { in xdr_buf_try_expand()
551 free_space = min_t(unsigned int, buf->buflen - sum, len); in xdr_buf_try_expand()
552 tail->iov_len += free_space; in xdr_buf_try_expand()
553 buf->len += free_space; in xdr_buf_try_expand()
561 const struct kvec *tail = buf->tail; in xdr_buf_tail_copy_right()
564 if (to >= tail->iov_len) in xdr_buf_tail_copy_right()
566 if (len + to > tail->iov_len) in xdr_buf_tail_copy_right()
567 len = tail->iov_len - to; in xdr_buf_tail_copy_right()
568 memmove(tail->iov_base + to, tail->iov_base + base, len); in xdr_buf_tail_copy_right()
575 const struct kvec *tail = buf->tail; in xdr_buf_pages_copy_right()
580 if (base >= buf->page_len) in xdr_buf_pages_copy_right()
582 if (len > buf->page_len - base) in xdr_buf_pages_copy_right()
583 len = buf->page_len - base; in xdr_buf_pages_copy_right()
584 if (to >= buf->page_len) { in xdr_buf_pages_copy_right()
585 tato = to - buf->page_len; in xdr_buf_pages_copy_right()
586 if (tail->iov_len >= len + tato) in xdr_buf_pages_copy_right()
588 else if (tail->iov_len > tato) in xdr_buf_pages_copy_right()
589 talen = tail->iov_len - tato; in xdr_buf_pages_copy_right()
590 } else if (len + to >= buf->page_len) { in xdr_buf_pages_copy_right()
591 pglen = buf->page_len - to; in xdr_buf_pages_copy_right()
592 talen = len - pglen; in xdr_buf_pages_copy_right()
593 if (talen > tail->iov_len) in xdr_buf_pages_copy_right()
594 talen = tail->iov_len; in xdr_buf_pages_copy_right()
598 _copy_from_pages(tail->iov_base + tato, buf->pages, in xdr_buf_pages_copy_right()
599 buf->page_base + base + pglen, talen); in xdr_buf_pages_copy_right()
600 _shift_data_right_pages(buf->pages, buf->page_base + to, in xdr_buf_pages_copy_right()
601 buf->page_base + base, pglen); in xdr_buf_pages_copy_right()
608 const struct kvec *head = buf->head; in xdr_buf_head_copy_right()
609 const struct kvec *tail = buf->tail; in xdr_buf_head_copy_right()
614 if (base >= head->iov_len) in xdr_buf_head_copy_right()
616 if (len > head->iov_len - base) in xdr_buf_head_copy_right()
617 len = head->iov_len - base; in xdr_buf_head_copy_right()
618 if (to >= buf->page_len + head->iov_len) { in xdr_buf_head_copy_right()
619 tato = to - buf->page_len - head->iov_len; in xdr_buf_head_copy_right()
621 } else if (to >= head->iov_len) { in xdr_buf_head_copy_right()
622 pgto = to - head->iov_len; in xdr_buf_head_copy_right()
624 if (pgto + pglen > buf->page_len) { in xdr_buf_head_copy_right()
625 talen = pgto + pglen - buf->page_len; in xdr_buf_head_copy_right()
626 pglen -= talen; in xdr_buf_head_copy_right()
629 pglen = len - to; in xdr_buf_head_copy_right()
630 if (pglen > buf->page_len) { in xdr_buf_head_copy_right()
631 talen = pglen - buf->page_len; in xdr_buf_head_copy_right()
632 pglen = buf->page_len; in xdr_buf_head_copy_right()
636 len -= talen; in xdr_buf_head_copy_right()
638 if (talen + tato > tail->iov_len) in xdr_buf_head_copy_right()
639 talen = tail->iov_len > tato ? tail->iov_len - tato : 0; in xdr_buf_head_copy_right()
640 memcpy(tail->iov_base + tato, head->iov_base + base, talen); in xdr_buf_head_copy_right()
642 len -= pglen; in xdr_buf_head_copy_right()
643 base -= pglen; in xdr_buf_head_copy_right()
644 _copy_to_pages(buf->pages, buf->page_base + pgto, head->iov_base + base, in xdr_buf_head_copy_right()
647 base -= len; in xdr_buf_head_copy_right()
648 memmove(head->iov_base + to, head->iov_base + base, len); in xdr_buf_head_copy_right()
655 const struct kvec *tail = buf->tail; in xdr_buf_tail_shift_right()
657 if (base >= tail->iov_len || !shift || !len) in xdr_buf_tail_shift_right()
668 if (base >= buf->page_len) { in xdr_buf_pages_shift_right()
669 xdr_buf_tail_shift_right(buf, base - buf->page_len, len, shift); in xdr_buf_pages_shift_right()
672 if (base + len > buf->page_len) in xdr_buf_pages_shift_right()
673 xdr_buf_tail_shift_right(buf, 0, base + len - buf->page_len, in xdr_buf_pages_shift_right()
682 const struct kvec *head = buf->head; in xdr_buf_head_shift_right()
686 if (base >= head->iov_len) { in xdr_buf_head_shift_right()
687 xdr_buf_pages_shift_right(buf, head->iov_len - base, len, in xdr_buf_head_shift_right()
691 if (base + len > head->iov_len) in xdr_buf_head_shift_right()
692 xdr_buf_pages_shift_right(buf, 0, base + len - head->iov_len, in xdr_buf_head_shift_right()
700 const struct kvec *tail = buf->tail; in xdr_buf_tail_copy_left()
702 if (base >= tail->iov_len) in xdr_buf_tail_copy_left()
704 if (len > tail->iov_len - base) in xdr_buf_tail_copy_left()
705 len = tail->iov_len - base; in xdr_buf_tail_copy_left()
706 /* Shift data into head */ in xdr_buf_tail_copy_left()
707 if (shift > buf->page_len + base) { in xdr_buf_tail_copy_left()
708 const struct kvec *head = buf->head; in xdr_buf_tail_copy_left()
710 head->iov_len + buf->page_len + base - shift; in xdr_buf_tail_copy_left()
713 if (WARN_ONCE(shift > head->iov_len + buf->page_len + base, in xdr_buf_tail_copy_left()
714 "SUNRPC: Misaligned data.\n")) in xdr_buf_tail_copy_left()
716 if (hdto + hdlen > head->iov_len) in xdr_buf_tail_copy_left()
717 hdlen = head->iov_len - hdto; in xdr_buf_tail_copy_left()
718 memcpy(head->iov_base + hdto, tail->iov_base + base, hdlen); in xdr_buf_tail_copy_left()
720 len -= hdlen; in xdr_buf_tail_copy_left()
724 /* Shift data into pages */ in xdr_buf_tail_copy_left()
726 unsigned int pgto = buf->page_len + base - shift; in xdr_buf_tail_copy_left()
729 if (pgto + pglen > buf->page_len) in xdr_buf_tail_copy_left()
730 pglen = buf->page_len - pgto; in xdr_buf_tail_copy_left()
731 _copy_to_pages(buf->pages, buf->page_base + pgto, in xdr_buf_tail_copy_left()
732 tail->iov_base + base, pglen); in xdr_buf_tail_copy_left()
734 len -= pglen; in xdr_buf_tail_copy_left()
738 memmove(tail->iov_base + base - shift, tail->iov_base + base, len); in xdr_buf_tail_copy_left()
747 if (base >= buf->page_len) in xdr_buf_pages_copy_left()
749 if (len > buf->page_len - base) in xdr_buf_pages_copy_left()
750 len = buf->page_len - base; in xdr_buf_pages_copy_left()
751 /* Shift data into head */ in xdr_buf_pages_copy_left()
753 const struct kvec *head = buf->head; in xdr_buf_pages_copy_left()
754 unsigned int hdto = head->iov_len + base - shift; in xdr_buf_pages_copy_left()
757 if (WARN_ONCE(shift > head->iov_len + base, in xdr_buf_pages_copy_left()
758 "SUNRPC: Misaligned data.\n")) in xdr_buf_pages_copy_left()
760 if (hdto + hdlen > head->iov_len) in xdr_buf_pages_copy_left()
761 hdlen = head->iov_len - hdto; in xdr_buf_pages_copy_left()
762 _copy_from_pages(head->iov_base + hdto, buf->pages, in xdr_buf_pages_copy_left()
763 buf->page_base + base, hdlen); in xdr_buf_pages_copy_left()
765 len -= hdlen; in xdr_buf_pages_copy_left()
769 pgto = base - shift; in xdr_buf_pages_copy_left()
770 _shift_data_left_pages(buf->pages, buf->page_base + pgto, in xdr_buf_pages_copy_left()
771 buf->page_base + base, len); in xdr_buf_pages_copy_left()
789 if (base >= buf->page_len) { in xdr_buf_pages_shift_left()
790 xdr_buf_tail_shift_left(buf, base - buf->page_len, len, shift); in xdr_buf_pages_shift_left()
795 if (len <= buf->page_len) in xdr_buf_pages_shift_left()
797 xdr_buf_tail_copy_left(buf, 0, len - buf->page_len, shift); in xdr_buf_pages_shift_left()
804 const struct kvec *head = buf->head; in xdr_buf_head_shift_left()
811 bytes = (shift - base); in xdr_buf_head_shift_left()
815 len -= bytes; in xdr_buf_head_shift_left()
818 if (base < head->iov_len) { in xdr_buf_head_shift_left()
819 bytes = min_t(unsigned int, len, head->iov_len - base); in xdr_buf_head_shift_left()
820 memmove(head->iov_base + (base - shift), in xdr_buf_head_shift_left()
821 head->iov_base + base, bytes); in xdr_buf_head_shift_left()
823 len -= bytes; in xdr_buf_head_shift_left()
825 xdr_buf_pages_shift_left(buf, base - head->iov_len, len, shift); in xdr_buf_head_shift_left()
831 * @len: new length of buf->head[0]
833 * Shrinks XDR buffer's header kvec buf->head[0], setting it to
834 * 'len' bytes. The extra data is not lost, but is instead
839 struct kvec *head = buf->head; in xdr_shrink_bufhead()
840 unsigned int shift, buflen = max(buf->len, len); in xdr_shrink_bufhead()
842 WARN_ON_ONCE(len > head->iov_len); in xdr_shrink_bufhead()
843 if (head->iov_len > buflen) { in xdr_shrink_bufhead()
844 buf->buflen -= head->iov_len - buflen; in xdr_shrink_bufhead()
845 head->iov_len = buflen; in xdr_shrink_bufhead()
847 if (len >= head->iov_len) in xdr_shrink_bufhead()
849 shift = head->iov_len - len; in xdr_shrink_bufhead()
851 xdr_buf_head_shift_right(buf, len, buflen - len, shift); in xdr_shrink_bufhead()
852 head->iov_len = len; in xdr_shrink_bufhead()
853 buf->buflen -= shift; in xdr_shrink_bufhead()
854 buf->len -= shift; in xdr_shrink_bufhead()
859 * xdr_shrink_pagelen - shrinks buf->pages to @len bytes
863 * The extra data is not lost, but is instead moved into buf->tail.
868 unsigned int shift, buflen = buf->len - buf->head->iov_len; in xdr_shrink_pagelen()
870 WARN_ON_ONCE(len > buf->page_len); in xdr_shrink_pagelen()
871 if (buf->head->iov_len >= buf->len || len > buflen) in xdr_shrink_pagelen()
873 if (buf->page_len > buflen) { in xdr_shrink_pagelen()
874 buf->buflen -= buf->page_len - buflen; in xdr_shrink_pagelen()
875 buf->page_len = buflen; in xdr_shrink_pagelen()
877 if (len >= buf->page_len) in xdr_shrink_pagelen()
879 shift = buf->page_len - len; in xdr_shrink_pagelen()
881 xdr_buf_pages_shift_right(buf, len, buflen - len, shift); in xdr_shrink_pagelen()
882 buf->page_len = len; in xdr_shrink_pagelen()
883 buf->len -= shift; in xdr_shrink_pagelen()
884 buf->buflen -= shift; in xdr_shrink_pagelen()
889 * xdr_stream_pos - Return the current offset from the start of the xdr_stream
894 return (unsigned int)(XDR_QUADLEN(xdr->buf->len) - xdr->nwords) << 2; in xdr_stream_pos()
900 unsigned int blen = xdr->buf->len; in xdr_stream_set_pos()
902 xdr->nwords = blen > pos ? XDR_QUADLEN(blen) - XDR_QUADLEN(pos) : 0; in xdr_stream_set_pos()
907 xdr_stream_set_pos(xdr, pos + xdr->buf->head[0].iov_len); in xdr_stream_page_set_pos()
911 * xdr_page_pos - Return the current offset from the start of the xdr pages
918 WARN_ON(pos < xdr->buf->head[0].iov_len); in xdr_page_pos()
919 return pos - xdr->buf->head[0].iov_len; in xdr_page_pos()
924 * xdr_init_encode - Initialize a struct xdr_stream for sending data.
926 * @buf: pointer to XDR buffer in which to encode data
933 * data. With the new scheme, the xdr_stream manages the details
940 struct kvec *iov = buf->head; in xdr_init_encode()
941 int scratch_len = buf->buflen - buf->page_len - buf->tail[0].iov_len; in xdr_init_encode()
945 xdr->buf = buf; in xdr_init_encode()
946 xdr->iov = iov; in xdr_init_encode()
947 xdr->p = (__be32 *)((char *)iov->iov_base + iov->iov_len); in xdr_init_encode()
948 xdr->end = (__be32 *)((char *)iov->iov_base + scratch_len); in xdr_init_encode()
949 BUG_ON(iov->iov_len > scratch_len); in xdr_init_encode()
951 if (p != xdr->p && p != NULL) { in xdr_init_encode()
954 BUG_ON(p < xdr->p || p > xdr->end); in xdr_init_encode()
955 len = (char *)p - (char *)xdr->p; in xdr_init_encode()
956 xdr->p = p; in xdr_init_encode()
957 buf->len += len; in xdr_init_encode()
958 iov->iov_len += len; in xdr_init_encode()
960 xdr->rqst = rqst; in xdr_init_encode()
965 * xdr_init_encode_pages - Initialize an xdr_stream for encoding into pages
967 * @buf: pointer to XDR buffer into which to encode data
974 xdr->buf = buf; in xdr_init_encode_pages()
975 xdr->page_ptr = buf->pages; in xdr_init_encode_pages()
976 xdr->iov = NULL; in xdr_init_encode_pages()
977 xdr->p = page_address(*xdr->page_ptr); in xdr_init_encode_pages()
978 xdr->end = (void *)xdr->p + min_t(u32, buf->buflen, PAGE_SIZE); in xdr_init_encode_pages()
979 xdr->rqst = NULL; in xdr_init_encode_pages()
984 * __xdr_commit_encode - Ensure all data is written to buffer
988 * temporary location to write to, then later copying the data into
994 * data might be read.
998 size_t shift = xdr->scratch.iov_len; in __xdr_commit_encode()
1001 page = page_address(*xdr->page_ptr); in __xdr_commit_encode()
1002 memcpy(xdr->scratch.iov_base, page, shift); in __xdr_commit_encode()
1003 memmove(page, page + shift, (void *)xdr->p - page); in __xdr_commit_encode()
1010 * xdr->buf->head and xdr->buf->pages, or between two pages
1011 * in xdr->buf->pages.
1022 if (xdr->buf->len + nbytes > xdr->buf->buflen) in xdr_get_next_encode_buffer()
1024 frag1bytes = (xdr->end - xdr->p) << 2; in xdr_get_next_encode_buffer()
1025 frag2bytes = nbytes - frag1bytes; in xdr_get_next_encode_buffer()
1026 if (xdr->iov) in xdr_get_next_encode_buffer()
1027 xdr->iov->iov_len += frag1bytes; in xdr_get_next_encode_buffer()
1029 xdr->buf->page_len += frag1bytes; in xdr_get_next_encode_buffer()
1030 xdr->page_ptr++; in xdr_get_next_encode_buffer()
1031 xdr->iov = NULL; in xdr_get_next_encode_buffer()
1040 xdr_set_scratch_buffer(xdr, xdr->p, frag1bytes); in xdr_get_next_encode_buffer()
1043 * xdr->p is where the next encode will start after in xdr_get_next_encode_buffer()
1046 p = page_address(*xdr->page_ptr); in xdr_get_next_encode_buffer()
1047 xdr->p = p + frag2bytes; in xdr_get_next_encode_buffer()
1048 space_left = xdr->buf->buflen - xdr->buf->len; in xdr_get_next_encode_buffer()
1049 if (space_left - frag1bytes >= PAGE_SIZE) in xdr_get_next_encode_buffer()
1050 xdr->end = p + PAGE_SIZE; in xdr_get_next_encode_buffer()
1052 xdr->end = p + space_left - frag1bytes; in xdr_get_next_encode_buffer()
1054 xdr->buf->page_len += frag2bytes; in xdr_get_next_encode_buffer()
1055 xdr->buf->len += nbytes; in xdr_get_next_encode_buffer()
1063 * xdr_reserve_space - Reserve buffer space for sending
1068 * bytes of data. If so, update the total xdr_buf length, and
1071 * The returned pointer is valid only until the next call to
1074 * four-byte data item remains valid until @xdr is destroyed, but
1079 __be32 *p = xdr->p; in xdr_reserve_space()
1083 /* align nbytes on the next 32-bit boundary */ in xdr_reserve_space()
1087 if (unlikely(q > xdr->end || q < p)) in xdr_reserve_space()
1089 xdr->p = q; in xdr_reserve_space()
1090 if (xdr->iov) in xdr_reserve_space()
1091 xdr->iov->iov_len += nbytes; in xdr_reserve_space()
1093 xdr->buf->page_len += nbytes; in xdr_reserve_space()
1094 xdr->buf->len += nbytes; in xdr_reserve_space()
1100 * xdr_reserve_space_vec - Reserves a large amount of buffer space for sending
1110 * %-EMSGSIZE: not enough space is available in @xdr
1119 * in xdr->pages. in xdr_reserve_space_vec()
1121 if (xdr->iov == xdr->buf->head) { in xdr_reserve_space_vec()
1122 xdr->iov = NULL; in xdr_reserve_space_vec()
1123 xdr->end = xdr->p; in xdr_reserve_space_vec()
1128 thislen = xdr->buf->page_len % PAGE_SIZE; in xdr_reserve_space_vec()
1129 thislen = min_t(size_t, nbytes, PAGE_SIZE - thislen); in xdr_reserve_space_vec()
1133 return -EMSGSIZE; in xdr_reserve_space_vec()
1135 nbytes -= thislen; in xdr_reserve_space_vec()
1143 * xdr_truncate_encode - truncate an encode buffer
1147 * Truncates the xdr stream, so that xdr->buf->len == len,
1148 * and xdr->p points at offset len from the start of the buffer, and
1151 * If this means moving xdr->p to a different buffer, we assume that
1157 * cache pages (as in a zero-copy server read reply), except for the
1163 struct xdr_buf *buf = xdr->buf; in xdr_truncate_encode()
1164 struct kvec *head = buf->head; in xdr_truncate_encode()
1165 struct kvec *tail = buf->tail; in xdr_truncate_encode()
1169 if (len > buf->len) { in xdr_truncate_encode()
1175 fraglen = min_t(int, buf->len - len, tail->iov_len); in xdr_truncate_encode()
1176 tail->iov_len -= fraglen; in xdr_truncate_encode()
1177 buf->len -= fraglen; in xdr_truncate_encode()
1178 if (tail->iov_len) { in xdr_truncate_encode()
1179 xdr->p = tail->iov_base + tail->iov_len; in xdr_truncate_encode()
1180 WARN_ON_ONCE(!xdr->end); in xdr_truncate_encode()
1181 WARN_ON_ONCE(!xdr->iov); in xdr_truncate_encode()
1185 fraglen = min_t(int, buf->len - len, buf->page_len); in xdr_truncate_encode()
1186 buf->page_len -= fraglen; in xdr_truncate_encode()
1187 buf->len -= fraglen; in xdr_truncate_encode()
1189 new = buf->page_base + buf->page_len; in xdr_truncate_encode()
1191 xdr->page_ptr = buf->pages + (new >> PAGE_SHIFT); in xdr_truncate_encode()
1193 if (buf->page_len) { in xdr_truncate_encode()
1194 xdr->p = page_address(*xdr->page_ptr); in xdr_truncate_encode()
1195 xdr->end = (void *)xdr->p + PAGE_SIZE; in xdr_truncate_encode()
1196 xdr->p = (void *)xdr->p + (new % PAGE_SIZE); in xdr_truncate_encode()
1197 WARN_ON_ONCE(xdr->iov); in xdr_truncate_encode()
1201 xdr->end = head->iov_base + head->iov_len; in xdr_truncate_encode()
1202 /* (otherwise assume xdr->end is already set) */ in xdr_truncate_encode()
1203 xdr->page_ptr--; in xdr_truncate_encode()
1204 head->iov_len = len; in xdr_truncate_encode()
1205 buf->len = len; in xdr_truncate_encode()
1206 xdr->p = head->iov_base + head->iov_len; in xdr_truncate_encode()
1207 xdr->iov = buf->head; in xdr_truncate_encode()
1212 * xdr_truncate_decode - Truncate a decoding stream
1221 xdr->buf->len -= nbytes; in xdr_truncate_decode()
1222 xdr->nwords -= XDR_QUADLEN(nbytes); in xdr_truncate_decode()
1227 * xdr_restrict_buflen - decrease available buffer space
1232 * If we've already used too much space in the buffer, returns -1.
1234 * and does nothing. Otherwise, adjusts xdr->buf->buflen to newbuflen
1235 * and ensures xdr->end is set at most offset newbuflen from the start
1240 struct xdr_buf *buf = xdr->buf; in xdr_restrict_buflen()
1241 int left_in_this_buf = (void *)xdr->end - (void *)xdr->p; in xdr_restrict_buflen()
1242 int end_offset = buf->len + left_in_this_buf; in xdr_restrict_buflen()
1244 if (newbuflen < 0 || newbuflen < buf->len) in xdr_restrict_buflen()
1245 return -1; in xdr_restrict_buflen()
1246 if (newbuflen > buf->buflen) in xdr_restrict_buflen()
1249 xdr->end = (void *)xdr->end + newbuflen - end_offset; in xdr_restrict_buflen()
1250 buf->buflen = newbuflen; in xdr_restrict_buflen()
1256 * xdr_write_pages - Insert a list of pages into an XDR buffer for sending
1259 * @base: starting offset of first data byte in @pages
1260 * @len: number of data bytes in @pages to insert
1269 struct xdr_buf *buf = xdr->buf; in xdr_write_pages()
1270 struct kvec *tail = buf->tail; in xdr_write_pages()
1272 buf->pages = pages; in xdr_write_pages()
1273 buf->page_base = base; in xdr_write_pages()
1274 buf->page_len = len; in xdr_write_pages()
1276 tail->iov_base = xdr->p; in xdr_write_pages()
1277 tail->iov_len = 0; in xdr_write_pages()
1278 xdr->iov = tail; in xdr_write_pages()
1281 unsigned int pad = 4 - (len & 3); in xdr_write_pages()
1283 BUG_ON(xdr->p >= xdr->end); in xdr_write_pages()
1284 tail->iov_base = (char *)xdr->p + (len & 3); in xdr_write_pages()
1285 tail->iov_len += pad; in xdr_write_pages()
1287 *xdr->p++ = 0; in xdr_write_pages()
1289 buf->buflen += len; in xdr_write_pages()
1290 buf->len += len; in xdr_write_pages()
1297 if (len > iov->iov_len) in xdr_set_iov()
1298 len = iov->iov_len; in xdr_set_iov()
1301 xdr->p = (__be32*)(iov->iov_base + base); in xdr_set_iov()
1302 xdr->end = (__be32*)(iov->iov_base + len); in xdr_set_iov()
1303 xdr->iov = iov; in xdr_set_iov()
1304 xdr->page_ptr = NULL; in xdr_set_iov()
1305 return len - base; in xdr_set_iov()
1311 struct xdr_buf *buf = xdr->buf; in xdr_set_tail_base()
1313 xdr_stream_set_pos(xdr, base + buf->page_len + buf->head->iov_len); in xdr_set_tail_base()
1314 return xdr_set_iov(xdr, buf->tail, base, len); in xdr_set_tail_base()
1319 if (xdr->page_kaddr) { in xdr_stream_unmap_current_page()
1320 kunmap_local(xdr->page_kaddr); in xdr_stream_unmap_current_page()
1321 xdr->page_kaddr = NULL; in xdr_stream_unmap_current_page()
1334 maxlen = xdr->buf->page_len; in xdr_set_page_base()
1338 maxlen -= base; in xdr_set_page_base()
1344 base += xdr->buf->page_base; in xdr_set_page_base()
1347 xdr->page_ptr = &xdr->buf->pages[pgnr]; in xdr_set_page_base()
1349 if (PageHighMem(*xdr->page_ptr)) { in xdr_set_page_base()
1350 xdr->page_kaddr = kmap_local_page(*xdr->page_ptr); in xdr_set_page_base()
1351 kaddr = xdr->page_kaddr; in xdr_set_page_base()
1353 kaddr = page_address(*xdr->page_ptr); in xdr_set_page_base()
1356 xdr->p = (__be32*)(kaddr + pgoff); in xdr_set_page_base()
1361 xdr->end = (__be32*)(kaddr + pgend); in xdr_set_page_base()
1362 xdr->iov = NULL; in xdr_set_page_base()
1370 base -= xdr->buf->page_len; in xdr_set_page()
1379 newbase = (1 + xdr->page_ptr - xdr->buf->pages) << PAGE_SHIFT; in xdr_set_next_page()
1380 newbase -= xdr->buf->page_base; in xdr_set_next_page()
1381 if (newbase < xdr->buf->page_len) in xdr_set_next_page()
1389 if (xdr->page_ptr != NULL) in xdr_set_next_buffer()
1391 else if (xdr->iov == xdr->buf->head) in xdr_set_next_buffer()
1393 return xdr->p != xdr->end; in xdr_set_next_buffer()
1397 * xdr_init_decode - Initialize an xdr_stream for decoding data.
1399 * @buf: pointer to XDR buffer from which to decode data
1406 xdr->buf = buf; in xdr_init_decode()
1407 xdr->page_kaddr = NULL; in xdr_init_decode()
1409 xdr->nwords = XDR_QUADLEN(buf->len); in xdr_init_decode()
1410 if (xdr_set_iov(xdr, buf->head, 0, buf->len) == 0 && in xdr_init_decode()
1411 xdr_set_page_base(xdr, 0, buf->len) == 0) in xdr_init_decode()
1412 xdr_set_iov(xdr, buf->tail, 0, buf->len); in xdr_init_decode()
1413 if (p != NULL && p > xdr->p && xdr->end >= p) { in xdr_init_decode()
1414 xdr->nwords -= p - xdr->p; in xdr_init_decode()
1415 xdr->p = p; in xdr_init_decode()
1417 xdr->rqst = rqst; in xdr_init_decode()
1422 * xdr_init_decode_pages - Initialize an xdr_stream for decoding into pages
1424 * @buf: pointer to XDR buffer from which to decode data
1432 buf->pages = pages; in xdr_init_decode_pages()
1433 buf->page_len = len; in xdr_init_decode_pages()
1434 buf->buflen = len; in xdr_init_decode_pages()
1435 buf->len = len; in xdr_init_decode_pages()
1441 * xdr_finish_decode - Clean up the xdr_stream after decoding data.
1453 __be32 *p = xdr->p; in __xdr_inline_decode()
1456 if (unlikely(nwords > xdr->nwords || q > xdr->end || q < p)) in __xdr_inline_decode()
1458 xdr->p = q; in __xdr_inline_decode()
1459 xdr->nwords -= nwords; in __xdr_inline_decode()
1466 char *cpdest = xdr->scratch.iov_base; in xdr_copy_to_scratch()
1467 size_t cplen = (char *)xdr->end - (char *)xdr->p; in xdr_copy_to_scratch()
1469 if (nbytes > xdr->scratch.iov_len) in xdr_copy_to_scratch()
1478 nbytes -= cplen; in xdr_copy_to_scratch()
1483 return xdr->scratch.iov_base; in xdr_copy_to_scratch()
1490 * xdr_inline_decode - Retrieve XDR data to decode
1492 * @nbytes: number of bytes of data to decode
1495 * 'nbytes' more bytes of data starting at the current position.
1504 return xdr->p; in xdr_inline_decode()
1505 if (xdr->p == xdr->end && !xdr_set_next_buffer(xdr)) in xdr_inline_decode()
1519 struct xdr_buf *buf = xdr->buf; in xdr_realign_pages()
1520 struct kvec *iov = buf->head; in xdr_realign_pages()
1525 if (iov->iov_len > cur) { in xdr_realign_pages()
1528 xdr_set_page(xdr, 0, buf->page_len); in xdr_realign_pages()
1534 struct xdr_buf *buf = xdr->buf; in xdr_align_pages()
1538 if (xdr->nwords == 0) in xdr_align_pages()
1542 if (nwords > xdr->nwords) { in xdr_align_pages()
1543 nwords = xdr->nwords; in xdr_align_pages()
1546 if (buf->page_len <= len) in xdr_align_pages()
1547 len = buf->page_len; in xdr_align_pages()
1548 else if (nwords < xdr->nwords) { in xdr_align_pages()
1549 /* Truncate page data and move it into the tail */ in xdr_align_pages()
1557 * xdr_read_pages - align page-based XDR data to current pointer position
1559 * @len: number of bytes of page data
1561 * Moves data beyond the current pointer position from the XDR head[] buffer
1562 * into the page list. Any data that lies beyond current position + @len
1564 * then advanced past that data to align to the next XDR object in the tail.
1577 base = (nwords << 2) - pglen; in xdr_read_pages()
1578 end = xdr_stream_remaining(xdr) - pglen; in xdr_read_pages()
1586 * xdr_set_pagelen - Sets the length of the XDR pages
1588 * @len: new length of the XDR page data
1591 * @len bytes. When shrinking, any extra data is moved into buf->tail, whereas
1592 * when growing any data beyond the current pointer is moved into the tail.
1598 struct xdr_buf *buf = xdr->buf; in xdr_set_pagelen()
1602 if (len < buf->page_len) { in xdr_set_pagelen()
1603 base = buf->page_len - len; in xdr_set_pagelen()
1607 buf->page_len, remaining); in xdr_set_pagelen()
1608 if (len > buf->page_len) in xdr_set_pagelen()
1609 xdr_buf_try_expand(buf, len - buf->page_len); in xdr_set_pagelen()
1616 * xdr_enter_page - decode data from the XDR page
1618 * @len: number of bytes of page data
1620 * Moves data beyond the current pointer position from the XDR head[] buffer
1621 * into the page list. Any data that lies beyond current position + "len"
1641 buf->head[0] = *iov; in xdr_buf_from_iov()
1642 buf->tail[0] = empty_iov; in xdr_buf_from_iov()
1643 buf->page_len = 0; in xdr_buf_from_iov()
1644 buf->buflen = buf->len = iov->iov_len; in xdr_buf_from_iov()
1649 * xdr_buf_subsegment - set subbuf to a portion of buf
1660 * Returns -1 if base or length are out of bounds.
1665 subbuf->buflen = subbuf->len = len; in xdr_buf_subsegment()
1666 if (base < buf->head[0].iov_len) { in xdr_buf_subsegment()
1667 subbuf->head[0].iov_base = buf->head[0].iov_base + base; in xdr_buf_subsegment()
1668 subbuf->head[0].iov_len = min_t(unsigned int, len, in xdr_buf_subsegment()
1669 buf->head[0].iov_len - base); in xdr_buf_subsegment()
1670 len -= subbuf->head[0].iov_len; in xdr_buf_subsegment()
1673 base -= buf->head[0].iov_len; in xdr_buf_subsegment()
1674 subbuf->head[0].iov_base = buf->head[0].iov_base; in xdr_buf_subsegment()
1675 subbuf->head[0].iov_len = 0; in xdr_buf_subsegment()
1678 if (base < buf->page_len) { in xdr_buf_subsegment()
1679 subbuf->page_len = min(buf->page_len - base, len); in xdr_buf_subsegment()
1680 base += buf->page_base; in xdr_buf_subsegment()
1681 subbuf->page_base = base & ~PAGE_MASK; in xdr_buf_subsegment()
1682 subbuf->pages = &buf->pages[base >> PAGE_SHIFT]; in xdr_buf_subsegment()
1683 len -= subbuf->page_len; in xdr_buf_subsegment()
1686 base -= buf->page_len; in xdr_buf_subsegment()
1687 subbuf->pages = buf->pages; in xdr_buf_subsegment()
1688 subbuf->page_base = 0; in xdr_buf_subsegment()
1689 subbuf->page_len = 0; in xdr_buf_subsegment()
1692 if (base < buf->tail[0].iov_len) { in xdr_buf_subsegment()
1693 subbuf->tail[0].iov_base = buf->tail[0].iov_base + base; in xdr_buf_subsegment()
1694 subbuf->tail[0].iov_len = min_t(unsigned int, len, in xdr_buf_subsegment()
1695 buf->tail[0].iov_len - base); in xdr_buf_subsegment()
1696 len -= subbuf->tail[0].iov_len; in xdr_buf_subsegment()
1699 base -= buf->tail[0].iov_len; in xdr_buf_subsegment()
1700 subbuf->tail[0].iov_base = buf->tail[0].iov_base; in xdr_buf_subsegment()
1701 subbuf->tail[0].iov_len = 0; in xdr_buf_subsegment()
1705 return -1; in xdr_buf_subsegment()
1711 * xdr_stream_subsegment - set @subbuf to a portion of @xdr
1719 * XDR data item following that portion.
1731 /* Extract @subbuf and bounds-check the fn arguments */ in xdr_stream_subsegment()
1732 if (xdr_buf_subsegment(xdr->buf, subbuf, start, nbytes)) in xdr_stream_subsegment()
1737 if (xdr->p == xdr->end && !xdr_set_next_buffer(xdr)) in xdr_stream_subsegment()
1740 len = (char *)xdr->end - (char *)xdr->p; in xdr_stream_subsegment()
1742 xdr->p = (__be32 *)((char *)xdr->p + in xdr_stream_subsegment()
1747 xdr->p = (__be32 *)((char *)xdr->p + len); in xdr_stream_subsegment()
1748 xdr->end = xdr->p; in xdr_stream_subsegment()
1749 remaining -= len; in xdr_stream_subsegment()
1758 * xdr_stream_move_subsegment - Move part of a stream to another position
1774 shift = target - offset; in xdr_stream_move_subsegment()
1775 if (xdr_buf_subsegment(xdr->buf, &buf, offset, shift + length) < 0) in xdr_stream_move_subsegment()
1779 shift = offset - target; in xdr_stream_move_subsegment()
1780 if (xdr_buf_subsegment(xdr->buf, &buf, target, shift + length) < 0) in xdr_stream_move_subsegment()
1789 * xdr_stream_zero - zero out a portion of an xdr_stream
1799 if (xdr_buf_subsegment(xdr->buf, &buf, offset, length) < 0) in xdr_stream_zero()
1812 * xdr_buf_trim - lop at most "len" bytes off the end of "buf"
1816 * Trim an xdr_buf by the given number of bytes by fixing up the lengths. Note
1817 * that it's possible that we'll trim less than that amount if the xdr_buf is
1824 unsigned int trim = len; in xdr_buf_trim() local
1826 if (buf->tail[0].iov_len) { in xdr_buf_trim()
1827 cur = min_t(size_t, buf->tail[0].iov_len, trim); in xdr_buf_trim()
1828 buf->tail[0].iov_len -= cur; in xdr_buf_trim()
1829 trim -= cur; in xdr_buf_trim()
1830 if (!trim) in xdr_buf_trim()
1834 if (buf->page_len) { in xdr_buf_trim()
1835 cur = min_t(unsigned int, buf->page_len, trim); in xdr_buf_trim()
1836 buf->page_len -= cur; in xdr_buf_trim()
1837 trim -= cur; in xdr_buf_trim()
1838 if (!trim) in xdr_buf_trim()
1842 if (buf->head[0].iov_len) { in xdr_buf_trim()
1843 cur = min_t(size_t, buf->head[0].iov_len, trim); in xdr_buf_trim()
1844 buf->head[0].iov_len -= cur; in xdr_buf_trim()
1845 trim -= cur; in xdr_buf_trim()
1848 buf->len -= (len - trim); in xdr_buf_trim()
1857 this_len = min_t(unsigned int, len, subbuf->head[0].iov_len); in __read_bytes_from_xdr_buf()
1858 memcpy(obj, subbuf->head[0].iov_base, this_len); in __read_bytes_from_xdr_buf()
1859 len -= this_len; in __read_bytes_from_xdr_buf()
1861 this_len = min_t(unsigned int, len, subbuf->page_len); in __read_bytes_from_xdr_buf()
1862 _copy_from_pages(obj, subbuf->pages, subbuf->page_base, this_len); in __read_bytes_from_xdr_buf()
1863 len -= this_len; in __read_bytes_from_xdr_buf()
1865 this_len = min_t(unsigned int, len, subbuf->tail[0].iov_len); in __read_bytes_from_xdr_buf()
1866 memcpy(obj, subbuf->tail[0].iov_base, this_len); in __read_bytes_from_xdr_buf()
1889 this_len = min_t(unsigned int, len, subbuf->head[0].iov_len); in __write_bytes_to_xdr_buf()
1890 memcpy(subbuf->head[0].iov_base, obj, this_len); in __write_bytes_to_xdr_buf()
1891 len -= this_len; in __write_bytes_to_xdr_buf()
1893 this_len = min_t(unsigned int, len, subbuf->page_len); in __write_bytes_to_xdr_buf()
1894 _copy_to_pages(subbuf->pages, subbuf->page_base, obj, this_len); in __write_bytes_to_xdr_buf()
1895 len -= this_len; in __write_bytes_to_xdr_buf()
1897 this_len = min_t(unsigned int, len, subbuf->tail[0].iov_len); in __write_bytes_to_xdr_buf()
1898 memcpy(subbuf->tail[0].iov_base, obj, this_len); in __write_bytes_to_xdr_buf()
1947 if (xdr_encode_word(buf, base, desc->array_len) != 0) in xdr_xcode_array2()
1948 return -EINVAL; in xdr_xcode_array2()
1950 if (xdr_decode_word(buf, base, &desc->array_len) != 0 || in xdr_xcode_array2()
1951 desc->array_len > desc->array_maxlen || in xdr_xcode_array2()
1952 (unsigned long) base + 4 + desc->array_len * in xdr_xcode_array2()
1953 desc->elem_size > buf->len) in xdr_xcode_array2()
1954 return -EINVAL; in xdr_xcode_array2()
1958 if (!desc->xcode) in xdr_xcode_array2()
1961 todo = desc->array_len * desc->elem_size; in xdr_xcode_array2()
1964 if (todo && base < buf->head->iov_len) { in xdr_xcode_array2()
1965 c = buf->head->iov_base + base; in xdr_xcode_array2()
1967 buf->head->iov_len - base); in xdr_xcode_array2()
1968 todo -= avail_here; in xdr_xcode_array2()
1970 while (avail_here >= desc->elem_size) { in xdr_xcode_array2()
1971 err = desc->xcode(desc, c); in xdr_xcode_array2()
1974 c += desc->elem_size; in xdr_xcode_array2()
1975 avail_here -= desc->elem_size; in xdr_xcode_array2()
1979 elem = kmalloc(desc->elem_size, GFP_KERNEL); in xdr_xcode_array2()
1980 err = -ENOMEM; in xdr_xcode_array2()
1985 err = desc->xcode(desc, elem); in xdr_xcode_array2()
1993 base = buf->head->iov_len; /* align to start of pages */ in xdr_xcode_array2()
1997 base -= buf->head->iov_len; in xdr_xcode_array2()
1998 if (todo && base < buf->page_len) { in xdr_xcode_array2()
2001 avail_here = min(todo, buf->page_len - base); in xdr_xcode_array2()
2002 todo -= avail_here; in xdr_xcode_array2()
2004 base += buf->page_base; in xdr_xcode_array2()
2005 ppages = buf->pages + (base >> PAGE_SHIFT); in xdr_xcode_array2()
2007 avail_page = min_t(unsigned int, PAGE_SIZE - base, in xdr_xcode_array2()
2012 avail_here -= avail_page; in xdr_xcode_array2()
2013 if (copied || avail_page < desc->elem_size) { in xdr_xcode_array2()
2015 desc->elem_size - copied); in xdr_xcode_array2()
2017 elem = kmalloc(desc->elem_size, in xdr_xcode_array2()
2019 err = -ENOMEM; in xdr_xcode_array2()
2025 err = desc->xcode(desc, elem); in xdr_xcode_array2()
2031 if (copied == desc->elem_size) in xdr_xcode_array2()
2036 if (copied == desc->elem_size) { in xdr_xcode_array2()
2037 err = desc->xcode(desc, elem); in xdr_xcode_array2()
2043 avail_page -= l; in xdr_xcode_array2()
2046 while (avail_page >= desc->elem_size) { in xdr_xcode_array2()
2047 err = desc->xcode(desc, c); in xdr_xcode_array2()
2050 c += desc->elem_size; in xdr_xcode_array2()
2051 avail_page -= desc->elem_size; in xdr_xcode_array2()
2055 desc->elem_size - copied); in xdr_xcode_array2()
2057 elem = kmalloc(desc->elem_size, in xdr_xcode_array2()
2059 err = -ENOMEM; in xdr_xcode_array2()
2065 err = desc->xcode(desc, elem); in xdr_xcode_array2()
2071 if (copied == desc->elem_size) in xdr_xcode_array2()
2076 if (copied == desc->elem_size) { in xdr_xcode_array2()
2077 err = desc->xcode(desc, elem); in xdr_xcode_array2()
2093 base = buf->page_len; /* align to start of tail */ in xdr_xcode_array2()
2097 base -= buf->page_len; in xdr_xcode_array2()
2099 c = buf->tail->iov_base + base; in xdr_xcode_array2()
2101 unsigned int l = desc->elem_size - copied; in xdr_xcode_array2()
2107 err = desc->xcode(desc, elem); in xdr_xcode_array2()
2111 todo -= l; in xdr_xcode_array2()
2115 err = desc->xcode(desc, c); in xdr_xcode_array2()
2118 c += desc->elem_size; in xdr_xcode_array2()
2119 todo -= desc->elem_size; in xdr_xcode_array2()
2134 if (base >= buf->len) in xdr_decode_array2()
2135 return -EINVAL; in xdr_decode_array2()
2144 if ((unsigned long) base + 4 + desc->array_len * desc->elem_size > in xdr_encode_array2()
2145 buf->head->iov_len + buf->page_len + buf->tail->iov_len) in xdr_encode_array2()
2146 return -EINVAL; in xdr_encode_array2()
2154 int (*actor)(struct scatterlist *, void *), void *data) in xdr_process_buf() argument
2162 if (offset >= buf->head[0].iov_len) { in xdr_process_buf()
2163 offset -= buf->head[0].iov_len; in xdr_process_buf()
2165 thislen = buf->head[0].iov_len - offset; in xdr_process_buf()
2168 sg_set_buf(sg, buf->head[0].iov_base + offset, thislen); in xdr_process_buf()
2169 ret = actor(sg, data); in xdr_process_buf()
2173 len -= thislen; in xdr_process_buf()
2178 if (offset >= buf->page_len) { in xdr_process_buf()
2179 offset -= buf->page_len; in xdr_process_buf()
2181 page_len = buf->page_len - offset; in xdr_process_buf()
2184 len -= page_len; in xdr_process_buf()
2185 page_offset = (offset + buf->page_base) & (PAGE_SIZE - 1); in xdr_process_buf()
2186 i = (offset + buf->page_base) >> PAGE_SHIFT; in xdr_process_buf()
2187 thislen = PAGE_SIZE - page_offset; in xdr_process_buf()
2191 sg_set_page(sg, buf->pages[i], thislen, page_offset); in xdr_process_buf()
2192 ret = actor(sg, data); in xdr_process_buf()
2195 page_len -= thislen; in xdr_process_buf()
2204 if (offset < buf->tail[0].iov_len) { in xdr_process_buf()
2205 thislen = buf->tail[0].iov_len - offset; in xdr_process_buf()
2208 sg_set_buf(sg, buf->tail[0].iov_base + offset, thislen); in xdr_process_buf()
2209 ret = actor(sg, data); in xdr_process_buf()
2210 len -= thislen; in xdr_process_buf()
2213 ret = -EINVAL; in xdr_process_buf()
2220 * xdr_stream_decode_string_dup - Decode and duplicate variable length string
2227 * On success, returns length of NUL-terminated string stored in *@ptr
2228 * %-EBADMSG on XDR buffer overflow
2229 * %-EMSGSIZE if the size of the string would exceed @maxlen
2230 * %-ENOMEM on memory allocation failure
2245 ret = -ENOMEM; in xdr_stream_decode_string_dup()
2253 * xdr_stream_decode_opaque_auth - Decode struct opaque_auth (RFC5531 S8.2)
2261 * %-EBADMSG on XDR buffer overflow
2262 * %-EMSGSIZE if the decoded size of the body field exceeds 400 octets
2281 * xdr_stream_encode_opaque_auth - Encode struct opaque_auth (RFC5531 S8.2)
2289 * %-EBADMSG on XDR buffer overflow
2290 * %-EMSGSIZE if the size of @body exceeds 400 octets
2298 return -EMSGSIZE; in xdr_stream_encode_opaque_auth()