~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/sunrpc/xdr.c

Version: ~ [ linux-5.6-rc7 ] ~ [ linux-5.5.11 ] ~ [ linux-5.4.27 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.112 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.174 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.217 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.217 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 #include <linux/bvec.h>
 19 
 20 /*
 21  * XDR functions for basic NFS types
 22  */
 23 __be32 *
 24 xdr_encode_netobj(__be32 *p, const struct xdr_netobj *obj)
 25 {
 26         unsigned int    quadlen = XDR_QUADLEN(obj->len);
 27 
 28         p[quadlen] = 0;         /* zero trailing bytes */
 29         *p++ = cpu_to_be32(obj->len);
 30         memcpy(p, obj->data, obj->len);
 31         return p + XDR_QUADLEN(obj->len);
 32 }
 33 EXPORT_SYMBOL_GPL(xdr_encode_netobj);
 34 
 35 __be32 *
 36 xdr_decode_netobj(__be32 *p, struct xdr_netobj *obj)
 37 {
 38         unsigned int    len;
 39 
 40         if ((len = be32_to_cpu(*p++)) > XDR_MAX_NETOBJ)
 41                 return NULL;
 42         obj->len  = len;
 43         obj->data = (u8 *) p;
 44         return p + XDR_QUADLEN(len);
 45 }
 46 EXPORT_SYMBOL_GPL(xdr_decode_netobj);
 47 
 48 /**
 49  * xdr_encode_opaque_fixed - Encode fixed length opaque data
 50  * @p: pointer to current position in XDR buffer.
 51  * @ptr: pointer to data to encode (or NULL)
 52  * @nbytes: size of data.
 53  *
 54  * Copy the array of data of length nbytes at ptr to the XDR buffer
 55  * at position p, then align to the next 32-bit boundary by padding
 56  * with zero bytes (see RFC1832).
 57  * Note: if ptr is NULL, only the padding is performed.
 58  *
 59  * Returns the updated current XDR buffer position
 60  *
 61  */
 62 __be32 *xdr_encode_opaque_fixed(__be32 *p, const void *ptr, unsigned int nbytes)
 63 {
 64         if (likely(nbytes != 0)) {
 65                 unsigned int quadlen = XDR_QUADLEN(nbytes);
 66                 unsigned int padding = (quadlen << 2) - nbytes;
 67 
 68                 if (ptr != NULL)
 69                         memcpy(p, ptr, nbytes);
 70                 if (padding != 0)
 71                         memset((char *)p + nbytes, 0, padding);
 72                 p += quadlen;
 73         }
 74         return p;
 75 }
 76 EXPORT_SYMBOL_GPL(xdr_encode_opaque_fixed);
 77 
 78 /**
 79  * xdr_encode_opaque - Encode variable length opaque data
 80  * @p: pointer to current position in XDR buffer.
 81  * @ptr: pointer to data to encode (or NULL)
 82  * @nbytes: size of data.
 83  *
 84  * Returns the updated current XDR buffer position
 85  */
 86 __be32 *xdr_encode_opaque(__be32 *p, const void *ptr, unsigned int nbytes)
 87 {
 88         *p++ = cpu_to_be32(nbytes);
 89         return xdr_encode_opaque_fixed(p, ptr, nbytes);
 90 }
 91 EXPORT_SYMBOL_GPL(xdr_encode_opaque);
 92 
 93 __be32 *
 94 xdr_encode_string(__be32 *p, const char *string)
 95 {
 96         return xdr_encode_array(p, string, strlen(string));
 97 }
 98 EXPORT_SYMBOL_GPL(xdr_encode_string);
 99 
100 __be32 *
101 xdr_decode_string_inplace(__be32 *p, char **sp,
102                           unsigned int *lenp, unsigned int maxlen)
103 {
104         u32 len;
105 
106         len = be32_to_cpu(*p++);
107         if (len > maxlen)
108                 return NULL;
109         *lenp = len;
110         *sp = (char *) p;
111         return p + XDR_QUADLEN(len);
112 }
113 EXPORT_SYMBOL_GPL(xdr_decode_string_inplace);
114 
115 /**
116  * xdr_terminate_string - '\0'-terminate a string residing in an xdr_buf
117  * @buf: XDR buffer where string resides
118  * @len: length of string, in bytes
119  *
120  */
121 void
122 xdr_terminate_string(struct xdr_buf *buf, const u32 len)
123 {
124         char *kaddr;
125 
126         kaddr = kmap_atomic(buf->pages[0]);
127         kaddr[buf->page_base + len] = '\0';
128         kunmap_atomic(kaddr);
129 }
130 EXPORT_SYMBOL_GPL(xdr_terminate_string);
131 
132 size_t
133 xdr_buf_pagecount(struct xdr_buf *buf)
134 {
135         if (!buf->page_len)
136                 return 0;
137         return (buf->page_base + buf->page_len + PAGE_SIZE - 1) >> PAGE_SHIFT;
138 }
139 
140 int
141 xdr_alloc_bvec(struct xdr_buf *buf, gfp_t gfp)
142 {
143         size_t i, n = xdr_buf_pagecount(buf);
144 
145         if (n != 0 && buf->bvec == NULL) {
146                 buf->bvec = kmalloc_array(n, sizeof(buf->bvec[0]), gfp);
147                 if (!buf->bvec)
148                         return -ENOMEM;
149                 for (i = 0; i < n; i++) {
150                         buf->bvec[i].bv_page = buf->pages[i];
151                         buf->bvec[i].bv_len = PAGE_SIZE;
152                         buf->bvec[i].bv_offset = 0;
153                 }
154         }
155         return 0;
156 }
157 
158 void
159 xdr_free_bvec(struct xdr_buf *buf)
160 {
161         kfree(buf->bvec);
162         buf->bvec = NULL;
163 }
164 
165 void
166 xdr_inline_pages(struct xdr_buf *xdr, unsigned int offset,
167                  struct page **pages, unsigned int base, unsigned int len)
168 {
169         struct kvec *head = xdr->head;
170         struct kvec *tail = xdr->tail;
171         char *buf = (char *)head->iov_base;
172         unsigned int buflen = head->iov_len;
173 
174         head->iov_len  = offset;
175 
176         xdr->pages = pages;
177         xdr->page_base = base;
178         xdr->page_len = len;
179 
180         tail->iov_base = buf + offset;
181         tail->iov_len = buflen - offset;
182 
183         xdr->buflen += len;
184 }
185 EXPORT_SYMBOL_GPL(xdr_inline_pages);
186 
187 /*
188  * Helper routines for doing 'memmove' like operations on a struct xdr_buf
189  */
190 
191 /**
192  * _shift_data_right_pages
193  * @pages: vector of pages containing both the source and dest memory area.
194  * @pgto_base: page vector address of destination
195  * @pgfrom_base: page vector address of source
196  * @len: number of bytes to copy
197  *
198  * Note: the addresses pgto_base and pgfrom_base are both calculated in
199  *       the same way:
200  *            if a memory area starts at byte 'base' in page 'pages[i]',
201  *            then its address is given as (i << PAGE_SHIFT) + base
202  * Also note: pgfrom_base must be < pgto_base, but the memory areas
203  *      they point to may overlap.
204  */
205 static void
206 _shift_data_right_pages(struct page **pages, size_t pgto_base,
207                 size_t pgfrom_base, size_t len)
208 {
209         struct page **pgfrom, **pgto;
210         char *vfrom, *vto;
211         size_t copy;
212 
213         BUG_ON(pgto_base <= pgfrom_base);
214 
215         pgto_base += len;
216         pgfrom_base += len;
217 
218         pgto = pages + (pgto_base >> PAGE_SHIFT);
219         pgfrom = pages + (pgfrom_base >> PAGE_SHIFT);
220 
221         pgto_base &= ~PAGE_MASK;
222         pgfrom_base &= ~PAGE_MASK;
223 
224         do {
225                 /* Are any pointers crossing a page boundary? */
226                 if (pgto_base == 0) {
227                         pgto_base = PAGE_SIZE;
228                         pgto--;
229                 }
230                 if (pgfrom_base == 0) {
231                         pgfrom_base = PAGE_SIZE;
232                         pgfrom--;
233                 }
234 
235                 copy = len;
236                 if (copy > pgto_base)
237                         copy = pgto_base;
238                 if (copy > pgfrom_base)
239                         copy = pgfrom_base;
240                 pgto_base -= copy;
241                 pgfrom_base -= copy;
242 
243                 vto = kmap_atomic(*pgto);
244                 if (*pgto != *pgfrom) {
245                         vfrom = kmap_atomic(*pgfrom);
246                         memcpy(vto + pgto_base, vfrom + pgfrom_base, copy);
247                         kunmap_atomic(vfrom);
248                 } else
249                         memmove(vto + pgto_base, vto + pgfrom_base, copy);
250                 flush_dcache_page(*pgto);
251                 kunmap_atomic(vto);
252 
253         } while ((len -= copy) != 0);
254 }
255 
256 /**
257  * _copy_to_pages
258  * @pages: array of pages
259  * @pgbase: page vector address of destination
260  * @p: pointer to source data
261  * @len: length
262  *
263  * Copies data from an arbitrary memory location into an array of pages
264  * The copy is assumed to be non-overlapping.
265  */
266 static void
267 _copy_to_pages(struct page **pages, size_t pgbase, const char *p, size_t len)
268 {
269         struct page **pgto;
270         char *vto;
271         size_t copy;
272 
273         pgto = pages + (pgbase >> PAGE_SHIFT);
274         pgbase &= ~PAGE_MASK;
275 
276         for (;;) {
277                 copy = PAGE_SIZE - pgbase;
278                 if (copy > len)
279                         copy = len;
280 
281                 vto = kmap_atomic(*pgto);
282                 memcpy(vto + pgbase, p, copy);
283                 kunmap_atomic(vto);
284 
285                 len -= copy;
286                 if (len == 0)
287                         break;
288 
289                 pgbase += copy;
290                 if (pgbase == PAGE_SIZE) {
291                         flush_dcache_page(*pgto);
292                         pgbase = 0;
293                         pgto++;
294                 }
295                 p += copy;
296         }
297         flush_dcache_page(*pgto);
298 }
299 
300 /**
301  * _copy_from_pages
302  * @p: pointer to destination
303  * @pages: array of pages
304  * @pgbase: offset of source data
305  * @len: length
306  *
307  * Copies data into an arbitrary memory location from an array of pages
308  * The copy is assumed to be non-overlapping.
309  */
310 void
311 _copy_from_pages(char *p, struct page **pages, size_t pgbase, size_t len)
312 {
313         struct page **pgfrom;
314         char *vfrom;
315         size_t copy;
316 
317         pgfrom = pages + (pgbase >> PAGE_SHIFT);
318         pgbase &= ~PAGE_MASK;
319 
320         do {
321                 copy = PAGE_SIZE - pgbase;
322                 if (copy > len)
323                         copy = len;
324 
325                 vfrom = kmap_atomic(*pgfrom);
326                 memcpy(p, vfrom + pgbase, copy);
327                 kunmap_atomic(vfrom);
328 
329                 pgbase += copy;
330                 if (pgbase == PAGE_SIZE) {
331                         pgbase = 0;
332                         pgfrom++;
333                 }
334                 p += copy;
335 
336         } while ((len -= copy) != 0);
337 }
338 EXPORT_SYMBOL_GPL(_copy_from_pages);
339 
340 /**
341  * xdr_shrink_bufhead
342  * @buf: xdr_buf
343  * @len: bytes to remove from buf->head[0]
344  *
345  * Shrinks XDR buffer's header kvec buf->head[0] by
346  * 'len' bytes. The extra data is not lost, but is instead
347  * moved into the inlined pages and/or the tail.
348  */
349 static void
350 xdr_shrink_bufhead(struct xdr_buf *buf, size_t len)
351 {
352         struct kvec *head, *tail;
353         size_t copy, offs;
354         unsigned int pglen = buf->page_len;
355 
356         tail = buf->tail;
357         head = buf->head;
358 
359         WARN_ON_ONCE(len > head->iov_len);
360         if (len > head->iov_len)
361                 len = head->iov_len;
362 
363         /* Shift the tail first */
364         if (tail->iov_len != 0) {
365                 if (tail->iov_len > len) {
366                         copy = tail->iov_len - len;
367                         memmove((char *)tail->iov_base + len,
368                                         tail->iov_base, copy);
369                 }
370                 /* Copy from the inlined pages into the tail */
371                 copy = len;
372                 if (copy > pglen)
373                         copy = pglen;
374                 offs = len - copy;
375                 if (offs >= tail->iov_len)
376                         copy = 0;
377                 else if (copy > tail->iov_len - offs)
378                         copy = tail->iov_len - offs;
379                 if (copy != 0)
380                         _copy_from_pages((char *)tail->iov_base + offs,
381                                         buf->pages,
382                                         buf->page_base + pglen + offs - len,
383                                         copy);
384                 /* Do we also need to copy data from the head into the tail ? */
385                 if (len > pglen) {
386                         offs = copy = len - pglen;
387                         if (copy > tail->iov_len)
388                                 copy = tail->iov_len;
389                         memcpy(tail->iov_base,
390                                         (char *)head->iov_base +
391                                         head->iov_len - offs,
392                                         copy);
393                 }
394         }
395         /* Now handle pages */
396         if (pglen != 0) {
397                 if (pglen > len)
398                         _shift_data_right_pages(buf->pages,
399                                         buf->page_base + len,
400                                         buf->page_base,
401                                         pglen - len);
402                 copy = len;
403                 if (len > pglen)
404                         copy = pglen;
405                 _copy_to_pages(buf->pages, buf->page_base,
406                                 (char *)head->iov_base + head->iov_len - len,
407                                 copy);
408         }
409         head->iov_len -= len;
410         buf->buflen -= len;
411         /* Have we truncated the message? */
412         if (buf->len > buf->buflen)
413                 buf->len = buf->buflen;
414 }
415 
416 /**
417  * xdr_shrink_pagelen
418  * @buf: xdr_buf
419  * @len: bytes to remove from buf->pages
420  *
421  * Shrinks XDR buffer's page array buf->pages by
422  * 'len' bytes. The extra data is not lost, but is instead
423  * moved into the tail.
424  */
425 static void
426 xdr_shrink_pagelen(struct xdr_buf *buf, size_t len)
427 {
428         struct kvec *tail;
429         size_t copy;
430         unsigned int pglen = buf->page_len;
431         unsigned int tailbuf_len;
432 
433         tail = buf->tail;
434         BUG_ON (len > pglen);
435 
436         tailbuf_len = buf->buflen - buf->head->iov_len - buf->page_len;
437 
438         /* Shift the tail first */
439         if (tailbuf_len != 0) {
440                 unsigned int free_space = tailbuf_len - tail->iov_len;
441 
442                 if (len < free_space)
443                         free_space = len;
444                 tail->iov_len += free_space;
445 
446                 copy = len;
447                 if (tail->iov_len > len) {
448                         char *p = (char *)tail->iov_base + len;
449                         memmove(p, tail->iov_base, tail->iov_len - len);
450                 } else
451                         copy = tail->iov_len;
452                 /* Copy from the inlined pages into the tail */
453                 _copy_from_pages((char *)tail->iov_base,
454                                 buf->pages, buf->page_base + pglen - len,
455                                 copy);
456         }
457         buf->page_len -= len;
458         buf->buflen -= len;
459         /* Have we truncated the message? */
460         if (buf->len > buf->buflen)
461                 buf->len = buf->buflen;
462 }
463 
464 void
465 xdr_shift_buf(struct xdr_buf *buf, size_t len)
466 {
467         xdr_shrink_bufhead(buf, len);
468 }
469 EXPORT_SYMBOL_GPL(xdr_shift_buf);
470 
471 /**
472  * xdr_stream_pos - Return the current offset from the start of the xdr_stream
473  * @xdr: pointer to struct xdr_stream
474  */
475 unsigned int xdr_stream_pos(const struct xdr_stream *xdr)
476 {
477         return (unsigned int)(XDR_QUADLEN(xdr->buf->len) - xdr->nwords) << 2;
478 }
479 EXPORT_SYMBOL_GPL(xdr_stream_pos);
480 
481 /**
482  * xdr_init_encode - Initialize a struct xdr_stream for sending data.
483  * @xdr: pointer to xdr_stream struct
484  * @buf: pointer to XDR buffer in which to encode data
485  * @p: current pointer inside XDR buffer
486  *
487  * Note: at the moment the RPC client only passes the length of our
488  *       scratch buffer in the xdr_buf's header kvec. Previously this
489  *       meant we needed to call xdr_adjust_iovec() after encoding the
490  *       data. With the new scheme, the xdr_stream manages the details
491  *       of the buffer length, and takes care of adjusting the kvec
492  *       length for us.
493  */
494 void xdr_init_encode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p)
495 {
496         struct kvec *iov = buf->head;
497         int scratch_len = buf->buflen - buf->page_len - buf->tail[0].iov_len;
498 
499         xdr_set_scratch_buffer(xdr, NULL, 0);
500         BUG_ON(scratch_len < 0);
501         xdr->buf = buf;
502         xdr->iov = iov;
503         xdr->p = (__be32 *)((char *)iov->iov_base + iov->iov_len);
504         xdr->end = (__be32 *)((char *)iov->iov_base + scratch_len);
505         BUG_ON(iov->iov_len > scratch_len);
506 
507         if (p != xdr->p && p != NULL) {
508                 size_t len;
509 
510                 BUG_ON(p < xdr->p || p > xdr->end);
511                 len = (char *)p - (char *)xdr->p;
512                 xdr->p = p;
513                 buf->len += len;
514                 iov->iov_len += len;
515         }
516 }
517 EXPORT_SYMBOL_GPL(xdr_init_encode);
518 
519 /**
520  * xdr_commit_encode - Ensure all data is written to buffer
521  * @xdr: pointer to xdr_stream
522  *
523  * We handle encoding across page boundaries by giving the caller a
524  * temporary location to write to, then later copying the data into
525  * place; xdr_commit_encode does that copying.
526  *
527  * Normally the caller doesn't need to call this directly, as the
528  * following xdr_reserve_space will do it.  But an explicit call may be
529  * required at the end of encoding, or any other time when the xdr_buf
530  * data might be read.
531  */
532 void xdr_commit_encode(struct xdr_stream *xdr)
533 {
534         int shift = xdr->scratch.iov_len;
535         void *page;
536 
537         if (shift == 0)
538                 return;
539         page = page_address(*xdr->page_ptr);
540         memcpy(xdr->scratch.iov_base, page, shift);
541         memmove(page, page + shift, (void *)xdr->p - page);
542         xdr->scratch.iov_len = 0;
543 }
544 EXPORT_SYMBOL_GPL(xdr_commit_encode);
545 
546 static __be32 *xdr_get_next_encode_buffer(struct xdr_stream *xdr,
547                 size_t nbytes)
548 {
549         __be32 *p;
550         int space_left;
551         int frag1bytes, frag2bytes;
552 
553         if (nbytes > PAGE_SIZE)
554                 return NULL; /* Bigger buffers require special handling */
555         if (xdr->buf->len + nbytes > xdr->buf->buflen)
556                 return NULL; /* Sorry, we're totally out of space */
557         frag1bytes = (xdr->end - xdr->p) << 2;
558         frag2bytes = nbytes - frag1bytes;
559         if (xdr->iov)
560                 xdr->iov->iov_len += frag1bytes;
561         else
562                 xdr->buf->page_len += frag1bytes;
563         xdr->page_ptr++;
564         xdr->iov = NULL;
565         /*
566          * If the last encode didn't end exactly on a page boundary, the
567          * next one will straddle boundaries.  Encode into the next
568          * page, then copy it back later in xdr_commit_encode.  We use
569          * the "scratch" iov to track any temporarily unused fragment of
570          * space at the end of the previous buffer:
571          */
572         xdr->scratch.iov_base = xdr->p;
573         xdr->scratch.iov_len = frag1bytes;
574         p = page_address(*xdr->page_ptr);
575         /*
576          * Note this is where the next encode will start after we've
577          * shifted this one back:
578          */
579         xdr->p = (void *)p + frag2bytes;
580         space_left = xdr->buf->buflen - xdr->buf->len;
581         xdr->end = (void *)p + min_t(int, space_left, PAGE_SIZE);
582         xdr->buf->page_len += frag2bytes;
583         xdr->buf->len += nbytes;
584         return p;
585 }
586 
587 /**
588  * xdr_reserve_space - Reserve buffer space for sending
589  * @xdr: pointer to xdr_stream
590  * @nbytes: number of bytes to reserve
591  *
592  * Checks that we have enough buffer space to encode 'nbytes' more
593  * bytes of data. If so, update the total xdr_buf length, and
594  * adjust the length of the current kvec.
595  */
596 __be32 * xdr_reserve_space(struct xdr_stream *xdr, size_t nbytes)
597 {
598         __be32 *p = xdr->p;
599         __be32 *q;
600 
601         xdr_commit_encode(xdr);
602         /* align nbytes on the next 32-bit boundary */
603         nbytes += 3;
604         nbytes &= ~3;
605         q = p + (nbytes >> 2);
606         if (unlikely(q > xdr->end || q < p))
607                 return xdr_get_next_encode_buffer(xdr, nbytes);
608         xdr->p = q;
609         if (xdr->iov)
610                 xdr->iov->iov_len += nbytes;
611         else
612                 xdr->buf->page_len += nbytes;
613         xdr->buf->len += nbytes;
614         return p;
615 }
616 EXPORT_SYMBOL_GPL(xdr_reserve_space);
617 
618 /**
619  * xdr_truncate_encode - truncate an encode buffer
620  * @xdr: pointer to xdr_stream
621  * @len: new length of buffer
622  *
623  * Truncates the xdr stream, so that xdr->buf->len == len,
624  * and xdr->p points at offset len from the start of the buffer, and
625  * head, tail, and page lengths are adjusted to correspond.
626  *
627  * If this means moving xdr->p to a different buffer, we assume that
628  * that the end pointer should be set to the end of the current page,
629  * except in the case of the head buffer when we assume the head
630  * buffer's current length represents the end of the available buffer.
631  *
632  * This is *not* safe to use on a buffer that already has inlined page
633  * cache pages (as in a zero-copy server read reply), except for the
634  * simple case of truncating from one position in the tail to another.
635  *
636  */
637 void xdr_truncate_encode(struct xdr_stream *xdr, size_t len)
638 {
639         struct xdr_buf *buf = xdr->buf;
640         struct kvec *head = buf->head;
641         struct kvec *tail = buf->tail;
642         int fraglen;
643         int new;
644 
645         if (len > buf->len) {
646                 WARN_ON_ONCE(1);
647                 return;
648         }
649         xdr_commit_encode(xdr);
650 
651         fraglen = min_t(int, buf->len - len, tail->iov_len);
652         tail->iov_len -= fraglen;
653         buf->len -= fraglen;
654         if (tail->iov_len) {
655                 xdr->p = tail->iov_base + tail->iov_len;
656                 WARN_ON_ONCE(!xdr->end);
657                 WARN_ON_ONCE(!xdr->iov);
658                 return;
659         }
660         WARN_ON_ONCE(fraglen);
661         fraglen = min_t(int, buf->len - len, buf->page_len);
662         buf->page_len -= fraglen;
663         buf->len -= fraglen;
664 
665         new = buf->page_base + buf->page_len;
666 
667         xdr->page_ptr = buf->pages + (new >> PAGE_SHIFT);
668 
669         if (buf->page_len) {
670                 xdr->p = page_address(*xdr->page_ptr);
671                 xdr->end = (void *)xdr->p + PAGE_SIZE;
672                 xdr->p = (void *)xdr->p + (new % PAGE_SIZE);
673                 WARN_ON_ONCE(xdr->iov);
674                 return;
675         }
676         if (fraglen)
677                 xdr->end = head->iov_base + head->iov_len;
678         /* (otherwise assume xdr->end is already set) */
679         xdr->page_ptr--;
680         head->iov_len = len;
681         buf->len = len;
682         xdr->p = head->iov_base + head->iov_len;
683         xdr->iov = buf->head;
684 }
685 EXPORT_SYMBOL(xdr_truncate_encode);
686 
687 /**
688  * xdr_restrict_buflen - decrease available buffer space
689  * @xdr: pointer to xdr_stream
690  * @newbuflen: new maximum number of bytes available
691  *
692  * Adjust our idea of how much space is available in the buffer.
693  * If we've already used too much space in the buffer, returns -1.
694  * If the available space is already smaller than newbuflen, returns 0
695  * and does nothing.  Otherwise, adjusts xdr->buf->buflen to newbuflen
696  * and ensures xdr->end is set at most offset newbuflen from the start
697  * of the buffer.
698  */
699 int xdr_restrict_buflen(struct xdr_stream *xdr, int newbuflen)
700 {
701         struct xdr_buf *buf = xdr->buf;
702         int left_in_this_buf = (void *)xdr->end - (void *)xdr->p;
703         int end_offset = buf->len + left_in_this_buf;
704 
705         if (newbuflen < 0 || newbuflen < buf->len)
706                 return -1;
707         if (newbuflen > buf->buflen)
708                 return 0;
709         if (newbuflen < end_offset)
710                 xdr->end = (void *)xdr->end + newbuflen - end_offset;
711         buf->buflen = newbuflen;
712         return 0;
713 }
714 EXPORT_SYMBOL(xdr_restrict_buflen);
715 
716 /**
717  * xdr_write_pages - Insert a list of pages into an XDR buffer for sending
718  * @xdr: pointer to xdr_stream
719  * @pages: list of pages
720  * @base: offset of first byte
721  * @len: length of data in bytes
722  *
723  */
724 void xdr_write_pages(struct xdr_stream *xdr, struct page **pages, unsigned int base,
725                  unsigned int len)
726 {
727         struct xdr_buf *buf = xdr->buf;
728         struct kvec *iov = buf->tail;
729         buf->pages = pages;
730         buf->page_base = base;
731         buf->page_len = len;
732 
733         iov->iov_base = (char *)xdr->p;
734         iov->iov_len  = 0;
735         xdr->iov = iov;
736 
737         if (len & 3) {
738                 unsigned int pad = 4 - (len & 3);
739 
740                 BUG_ON(xdr->p >= xdr->end);
741                 iov->iov_base = (char *)xdr->p + (len & 3);
742                 iov->iov_len  += pad;
743                 len += pad;
744                 *xdr->p++ = 0;
745         }
746         buf->buflen += len;
747         buf->len += len;
748 }
749 EXPORT_SYMBOL_GPL(xdr_write_pages);
750 
751 static void xdr_set_iov(struct xdr_stream *xdr, struct kvec *iov,
752                 unsigned int len)
753 {
754         if (len > iov->iov_len)
755                 len = iov->iov_len;
756         xdr->p = (__be32*)iov->iov_base;
757         xdr->end = (__be32*)(iov->iov_base + len);
758         xdr->iov = iov;
759         xdr->page_ptr = NULL;
760 }
761 
762 static int xdr_set_page_base(struct xdr_stream *xdr,
763                 unsigned int base, unsigned int len)
764 {
765         unsigned int pgnr;
766         unsigned int maxlen;
767         unsigned int pgoff;
768         unsigned int pgend;
769         void *kaddr;
770 
771         maxlen = xdr->buf->page_len;
772         if (base >= maxlen)
773                 return -EINVAL;
774         maxlen -= base;
775         if (len > maxlen)
776                 len = maxlen;
777 
778         base += xdr->buf->page_base;
779 
780         pgnr = base >> PAGE_SHIFT;
781         xdr->page_ptr = &xdr->buf->pages[pgnr];
782         kaddr = page_address(*xdr->page_ptr);
783 
784         pgoff = base & ~PAGE_MASK;
785         xdr->p = (__be32*)(kaddr + pgoff);
786 
787         pgend = pgoff + len;
788         if (pgend > PAGE_SIZE)
789                 pgend = PAGE_SIZE;
790         xdr->end = (__be32*)(kaddr + pgend);
791         xdr->iov = NULL;
792         return 0;
793 }
794 
795 static void xdr_set_next_page(struct xdr_stream *xdr)
796 {
797         unsigned int newbase;
798 
799         newbase = (1 + xdr->page_ptr - xdr->buf->pages) << PAGE_SHIFT;
800         newbase -= xdr->buf->page_base;
801 
802         if (xdr_set_page_base(xdr, newbase, PAGE_SIZE) < 0)
803                 xdr_set_iov(xdr, xdr->buf->tail, xdr->nwords << 2);
804 }
805 
806 static bool xdr_set_next_buffer(struct xdr_stream *xdr)
807 {
808         if (xdr->page_ptr != NULL)
809                 xdr_set_next_page(xdr);
810         else if (xdr->iov == xdr->buf->head) {
811                 if (xdr_set_page_base(xdr, 0, PAGE_SIZE) < 0)
812                         xdr_set_iov(xdr, xdr->buf->tail, xdr->nwords << 2);
813         }
814         return xdr->p != xdr->end;
815 }
816 
817 /**
818  * xdr_init_decode - Initialize an xdr_stream for decoding data.
819  * @xdr: pointer to xdr_stream struct
820  * @buf: pointer to XDR buffer from which to decode data
821  * @p: current pointer inside XDR buffer
822  */
823 void xdr_init_decode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p)
824 {
825         xdr->buf = buf;
826         xdr->scratch.iov_base = NULL;
827         xdr->scratch.iov_len = 0;
828         xdr->nwords = XDR_QUADLEN(buf->len);
829         if (buf->head[0].iov_len != 0)
830                 xdr_set_iov(xdr, buf->head, buf->len);
831         else if (buf->page_len != 0)
832                 xdr_set_page_base(xdr, 0, buf->len);
833         else
834                 xdr_set_iov(xdr, buf->head, buf->len);
835         if (p != NULL && p > xdr->p && xdr->end >= p) {
836                 xdr->nwords -= p - xdr->p;
837                 xdr->p = p;
838         }
839 }
840 EXPORT_SYMBOL_GPL(xdr_init_decode);
841 
842 /**
843  * xdr_init_decode_pages - Initialize an xdr_stream for decoding into pages
844  * @xdr: pointer to xdr_stream struct
845  * @buf: pointer to XDR buffer from which to decode data
846  * @pages: list of pages to decode into
847  * @len: length in bytes of buffer in pages
848  */
849 void xdr_init_decode_pages(struct xdr_stream *xdr, struct xdr_buf *buf,
850                            struct page **pages, unsigned int len)
851 {
852         memset(buf, 0, sizeof(*buf));
853         buf->pages =  pages;
854         buf->page_len =  len;
855         buf->buflen =  len;
856         buf->len = len;
857         xdr_init_decode(xdr, buf, NULL);
858 }
859 EXPORT_SYMBOL_GPL(xdr_init_decode_pages);
860 
861 static __be32 * __xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes)
862 {
863         unsigned int nwords = XDR_QUADLEN(nbytes);
864         __be32 *p = xdr->p;
865         __be32 *q = p + nwords;
866 
867         if (unlikely(nwords > xdr->nwords || q > xdr->end || q < p))
868                 return NULL;
869         xdr->p = q;
870         xdr->nwords -= nwords;
871         return p;
872 }
873 
874 /**
875  * xdr_set_scratch_buffer - Attach a scratch buffer for decoding data.
876  * @xdr: pointer to xdr_stream struct
877  * @buf: pointer to an empty buffer
878  * @buflen: size of 'buf'
879  *
880  * The scratch buffer is used when decoding from an array of pages.
881  * If an xdr_inline_decode() call spans across page boundaries, then
882  * we copy the data into the scratch buffer in order to allow linear
883  * access.
884  */
885 void xdr_set_scratch_buffer(struct xdr_stream *xdr, void *buf, size_t buflen)
886 {
887         xdr->scratch.iov_base = buf;
888         xdr->scratch.iov_len = buflen;
889 }
890 EXPORT_SYMBOL_GPL(xdr_set_scratch_buffer);
891 
892 static __be32 *xdr_copy_to_scratch(struct xdr_stream *xdr, size_t nbytes)
893 {
894         __be32 *p;
895         char *cpdest = xdr->scratch.iov_base;
896         size_t cplen = (char *)xdr->end - (char *)xdr->p;
897 
898         if (nbytes > xdr->scratch.iov_len)
899                 return NULL;
900         p = __xdr_inline_decode(xdr, cplen);
901         if (p == NULL)
902                 return NULL;
903         memcpy(cpdest, p, cplen);
904         cpdest += cplen;
905         nbytes -= cplen;
906         if (!xdr_set_next_buffer(xdr))
907                 return NULL;
908         p = __xdr_inline_decode(xdr, nbytes);
909         if (p == NULL)
910                 return NULL;
911         memcpy(cpdest, p, nbytes);
912         return xdr->scratch.iov_base;
913 }
914 
915 /**
916  * xdr_inline_decode - Retrieve XDR data to decode
917  * @xdr: pointer to xdr_stream struct
918  * @nbytes: number of bytes of data to decode
919  *
920  * Check if the input buffer is long enough to enable us to decode
921  * 'nbytes' more bytes of data starting at the current position.
922  * If so return the current pointer, then update the current
923  * pointer position.
924  */
925 __be32 * xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes)
926 {
927         __be32 *p;
928 
929         if (nbytes == 0)
930                 return xdr->p;
931         if (xdr->p == xdr->end && !xdr_set_next_buffer(xdr))
932                 return NULL;
933         p = __xdr_inline_decode(xdr, nbytes);
934         if (p != NULL)
935                 return p;
936         return xdr_copy_to_scratch(xdr, nbytes);
937 }
938 EXPORT_SYMBOL_GPL(xdr_inline_decode);
939 
940 static unsigned int xdr_align_pages(struct xdr_stream *xdr, unsigned int len)
941 {
942         struct xdr_buf *buf = xdr->buf;
943         struct kvec *iov;
944         unsigned int nwords = XDR_QUADLEN(len);
945         unsigned int cur = xdr_stream_pos(xdr);
946 
947         if (xdr->nwords == 0)
948                 return 0;
949         /* Realign pages to current pointer position */
950         iov  = buf->head;
951         if (iov->iov_len > cur) {
952                 xdr_shrink_bufhead(buf, iov->iov_len - cur);
953                 xdr->nwords = XDR_QUADLEN(buf->len - cur);
954         }
955 
956         if (nwords > xdr->nwords) {
957                 nwords = xdr->nwords;
958                 len = nwords << 2;
959         }
960         if (buf->page_len <= len)
961                 len = buf->page_len;
962         else if (nwords < xdr->nwords) {
963                 /* Truncate page data and move it into the tail */
964                 xdr_shrink_pagelen(buf, buf->page_len - len);
965                 xdr->nwords = XDR_QUADLEN(buf->len - cur);
966         }
967         return len;
968 }
969 
970 /**
971  * xdr_read_pages - Ensure page-based XDR data to decode is aligned at current pointer position
972  * @xdr: pointer to xdr_stream struct
973  * @len: number of bytes of page data
974  *
975  * Moves data beyond the current pointer position from the XDR head[] buffer
976  * into the page list. Any data that lies beyond current position + "len"
977  * bytes is moved into the XDR tail[].
978  *
979  * Returns the number of XDR encoded bytes now contained in the pages
980  */
981 unsigned int xdr_read_pages(struct xdr_stream *xdr, unsigned int len)
982 {
983         struct xdr_buf *buf = xdr->buf;
984         struct kvec *iov;
985         unsigned int nwords;
986         unsigned int end;
987         unsigned int padding;
988 
989         len = xdr_align_pages(xdr, len);
990         if (len == 0)
991                 return 0;
992         nwords = XDR_QUADLEN(len);
993         padding = (nwords << 2) - len;
994         xdr->iov = iov = buf->tail;
995         /* Compute remaining message length.  */
996         end = ((xdr->nwords - nwords) << 2) + padding;
997         if (end > iov->iov_len)
998                 end = iov->iov_len;
999 
1000         /*
1001          * Position current pointer at beginning of tail, and
1002          * set remaining message length.
1003          */
1004         xdr->p = (__be32 *)((char *)iov->iov_base + padding);
1005         xdr->end = (__be32 *)((char *)iov->iov_base + end);
1006         xdr->page_ptr = NULL;
1007         xdr->nwords = XDR_QUADLEN(end - padding);
1008         return len;
1009 }
1010 EXPORT_SYMBOL_GPL(xdr_read_pages);
1011 
1012 /**
1013  * xdr_enter_page - decode data from the XDR page
1014  * @xdr: pointer to xdr_stream struct
1015  * @len: number of bytes of page data
1016  *
1017  * Moves data beyond the current pointer position from the XDR head[] buffer
1018  * into the page list. Any data that lies beyond current position + "len"
1019  * bytes is moved into the XDR tail[]. The current pointer is then
1020  * repositioned at the beginning of the first XDR page.
1021  */
1022 void xdr_enter_page(struct xdr_stream *xdr, unsigned int len)
1023 {
1024         len = xdr_align_pages(xdr, len);
1025         /*
1026          * Position current pointer at beginning of tail, and
1027          * set remaining message length.
1028          */
1029         if (len != 0)
1030                 xdr_set_page_base(xdr, 0, len);
1031 }
1032 EXPORT_SYMBOL_GPL(xdr_enter_page);
1033 
1034 static struct kvec empty_iov = {.iov_base = NULL, .iov_len = 0};
1035 
1036 void
1037 xdr_buf_from_iov(struct kvec *iov, struct xdr_buf *buf)
1038 {
1039         buf->head[0] = *iov;
1040         buf->tail[0] = empty_iov;
1041         buf->page_len = 0;
1042         buf->buflen = buf->len = iov->iov_len;
1043 }
1044 EXPORT_SYMBOL_GPL(xdr_buf_from_iov);
1045 
1046 /**
1047  * xdr_buf_subsegment - set subbuf to a portion of buf
1048  * @buf: an xdr buffer
1049  * @subbuf: the result buffer
1050  * @base: beginning of range in bytes
1051  * @len: length of range in bytes
1052  *
1053  * sets @subbuf to an xdr buffer representing the portion of @buf of
1054  * length @len starting at offset @base.
1055  *
1056  * @buf and @subbuf may be pointers to the same struct xdr_buf.
1057  *
1058  * Returns -1 if base of length are out of bounds.
1059  */
1060 int
1061 xdr_buf_subsegment(struct xdr_buf *buf, struct xdr_buf *subbuf,
1062                         unsigned int base, unsigned int len)
1063 {
1064         subbuf->buflen = subbuf->len = len;
1065         if (base < buf->head[0].iov_len) {
1066                 subbuf->head[0].iov_base = buf->head[0].iov_base + base;
1067                 subbuf->head[0].iov_len = min_t(unsigned int, len,
1068                                                 buf->head[0].iov_len - base);
1069                 len -= subbuf->head[0].iov_len;
1070                 base = 0;
1071         } else {
1072                 base -= buf->head[0].iov_len;
1073                 subbuf->head[0].iov_len = 0;
1074         }
1075 
1076         if (base < buf->page_len) {
1077                 subbuf->page_len = min(buf->page_len - base, len);
1078                 base += buf->page_base;
1079                 subbuf->page_base = base & ~PAGE_MASK;
1080                 subbuf->pages = &buf->pages[base >> PAGE_SHIFT];
1081                 len -= subbuf->page_len;
1082                 base = 0;
1083         } else {
1084                 base -= buf->page_len;
1085                 subbuf->page_len = 0;
1086         }
1087 
1088         if (base < buf->tail[0].iov_len) {
1089                 subbuf->tail[0].iov_base = buf->tail[0].iov_base + base;
1090                 subbuf->tail[0].iov_len = min_t(unsigned int, len,
1091                                                 buf->tail[0].iov_len - base);
1092                 len -= subbuf->tail[0].iov_len;
1093                 base = 0;
1094         } else {
1095                 base -= buf->tail[0].iov_len;
1096                 subbuf->tail[0].iov_len = 0;
1097         }
1098 
1099         if (base || len)
1100                 return -1;
1101         return 0;
1102 }
1103 EXPORT_SYMBOL_GPL(xdr_buf_subsegment);
1104 
1105 /**
1106  * xdr_buf_trim - lop at most "len" bytes off the end of "buf"
1107  * @buf: buf to be trimmed
1108  * @len: number of bytes to reduce "buf" by
1109  *
1110  * Trim an xdr_buf by the given number of bytes by fixing up the lengths. Note
1111  * that it's possible that we'll trim less than that amount if the xdr_buf is
1112  * too small, or if (for instance) it's all in the head and the parser has
1113  * already read too far into it.
1114  */
1115 void xdr_buf_trim(struct xdr_buf *buf, unsigned int len)
1116 {
1117         size_t cur;
1118         unsigned int trim = len;
1119 
1120         if (buf->tail[0].iov_len) {
1121                 cur = min_t(size_t, buf->tail[0].iov_len, trim);
1122                 buf->tail[0].iov_len -= cur;
1123                 trim -= cur;
1124                 if (!trim)
1125                         goto fix_len;
1126         }
1127 
1128         if (buf->page_len) {
1129                 cur = min_t(unsigned int, buf->page_len, trim);
1130                 buf->page_len -= cur;
1131                 trim -= cur;
1132                 if (!trim)
1133                         goto fix_len;
1134         }
1135 
1136         if (buf->head[0].iov_len) {
1137                 cur = min_t(size_t, buf->head[0].iov_len, trim);
1138                 buf->head[0].iov_len -= cur;
1139                 trim -= cur;
1140         }
1141 fix_len:
1142         buf->len -= (len - trim);
1143 }
1144 EXPORT_SYMBOL_GPL(xdr_buf_trim);
1145 
1146 static void __read_bytes_from_xdr_buf(struct xdr_buf *subbuf, void *obj, unsigned int len)
1147 {
1148         unsigned int this_len;
1149 
1150         this_len = min_t(unsigned int, len, subbuf->head[0].iov_len);
1151         memcpy(obj, subbuf->head[0].iov_base, this_len);
1152         len -= this_len;
1153         obj += this_len;
1154         this_len = min_t(unsigned int, len, subbuf->page_len);
1155         if (this_len)
1156                 _copy_from_pages(obj, subbuf->pages, subbuf->page_base, this_len);
1157         len -= this_len;
1158         obj += this_len;
1159         this_len = min_t(unsigned int, len, subbuf->tail[0].iov_len);
1160         memcpy(obj, subbuf->tail[0].iov_base, this_len);
1161 }
1162 
1163 /* obj is assumed to point to allocated memory of size at least len: */
1164 int read_bytes_from_xdr_buf(struct xdr_buf *buf, unsigned int base, void *obj, unsigned int len)
1165 {
1166         struct xdr_buf subbuf;
1167         int status;
1168 
1169         status = xdr_buf_subsegment(buf, &subbuf, base, len);
1170         if (status != 0)
1171                 return status;
1172         __read_bytes_from_xdr_buf(&subbuf, obj, len);
1173         return 0;
1174 }
1175 EXPORT_SYMBOL_GPL(read_bytes_from_xdr_buf);
1176 
1177 static void __write_bytes_to_xdr_buf(struct xdr_buf *subbuf, void *obj, unsigned int len)
1178 {
1179         unsigned int this_len;
1180 
1181         this_len = min_t(unsigned int, len, subbuf->head[0].iov_len);
1182         memcpy(subbuf->head[0].iov_base, obj, this_len);
1183         len -= this_len;
1184         obj += this_len;
1185         this_len = min_t(unsigned int, len, subbuf->page_len);
1186         if (this_len)
1187                 _copy_to_pages(subbuf->pages, subbuf->page_base, obj, this_len);
1188         len -= this_len;
1189         obj += this_len;
1190         this_len = min_t(unsigned int, len, subbuf->tail[0].iov_len);
1191         memcpy(subbuf->tail[0].iov_base, obj, this_len);
1192 }
1193 
1194 /* obj is assumed to point to allocated memory of size at least len: */
1195 int write_bytes_to_xdr_buf(struct xdr_buf *buf, unsigned int base, void *obj, unsigned int len)
1196 {
1197         struct xdr_buf subbuf;
1198         int status;
1199 
1200         status = xdr_buf_subsegment(buf, &subbuf, base, len);
1201         if (status != 0)
1202                 return status;
1203         __write_bytes_to_xdr_buf(&subbuf, obj, len);
1204         return 0;
1205 }
1206 EXPORT_SYMBOL_GPL(write_bytes_to_xdr_buf);
1207 
1208 int
1209 xdr_decode_word(struct xdr_buf *buf, unsigned int base, u32 *obj)
1210 {
1211         __be32  raw;
1212         int     status;
1213 
1214         status = read_bytes_from_xdr_buf(buf, base, &raw, sizeof(*obj));
1215         if (status)
1216                 return status;
1217         *obj = be32_to_cpu(raw);
1218         return 0;
1219 }
1220 EXPORT_SYMBOL_GPL(xdr_decode_word);
1221 
1222 int
1223 xdr_encode_word(struct xdr_buf *buf, unsigned int base, u32 obj)
1224 {
1225         __be32  raw = cpu_to_be32(obj);
1226 
1227         return write_bytes_to_xdr_buf(buf, base, &raw, sizeof(obj));
1228 }
1229 EXPORT_SYMBOL_GPL(xdr_encode_word);
1230 
1231 /* If the netobj starting offset bytes from the start of xdr_buf is contained
1232  * entirely in the head or the tail, set object to point to it; otherwise
1233  * try to find space for it at the end of the tail, copy it there, and
1234  * set obj to point to it. */
1235 int xdr_buf_read_netobj(struct xdr_buf *buf, struct xdr_netobj *obj, unsigned int offset)
1236 {
1237         struct xdr_buf subbuf;
1238 
1239         if (xdr_decode_word(buf, offset, &obj->len))
1240                 return -EFAULT;
1241         if (xdr_buf_subsegment(buf, &subbuf, offset + 4, obj->len))
1242                 return -EFAULT;
1243 
1244         /* Is the obj contained entirely in the head? */
1245         obj->data = subbuf.head[0].iov_base;
1246         if (subbuf.head[0].iov_len == obj->len)
1247                 return 0;
1248         /* ..or is the obj contained entirely in the tail? */
1249         obj->data = subbuf.tail[0].iov_base;
1250         if (subbuf.tail[0].iov_len == obj->len)
1251                 return 0;
1252 
1253         /* use end of tail as storage for obj:
1254          * (We don't copy to the beginning because then we'd have
1255          * to worry about doing a potentially overlapping copy.
1256          * This assumes the object is at most half the length of the
1257          * tail.) */
1258         if (obj->len > buf->buflen - buf->len)
1259                 return -ENOMEM;
1260         if (buf->tail[0].iov_len != 0)
1261                 obj->data = buf->tail[0].iov_base + buf->tail[0].iov_len;
1262         else
1263                 obj->data = buf->head[0].iov_base + buf->head[0].iov_len;
1264         __read_bytes_from_xdr_buf(&subbuf, obj->data, obj->len);
1265         return 0;
1266 }
1267 EXPORT_SYMBOL_GPL(xdr_buf_read_netobj);
1268 
1269 /* Returns 0 on success, or else a negative error code. */
1270 static int
1271 xdr_xcode_array2(struct xdr_buf *buf, unsigned int base,
1272                  struct xdr_array2_desc *desc, int encode)
1273 {
1274         char *elem = NULL, *c;
1275         unsigned int copied = 0, todo, avail_here;
1276         struct page **ppages = NULL;
1277         int err;
1278 
1279         if (encode) {
1280                 if (xdr_encode_word(buf, base, desc->array_len) != 0)
1281                         return -EINVAL;
1282         } else {
1283                 if (xdr_decode_word(buf, base, &desc->array_len) != 0 ||
1284                     desc->array_len > desc->array_maxlen ||
1285                     (unsigned long) base + 4 + desc->array_len *
1286                                     desc->elem_size > buf->len)
1287                         return -EINVAL;
1288         }
1289         base += 4;
1290 
1291         if (!desc->xcode)
1292                 return 0;
1293 
1294         todo = desc->array_len * desc->elem_size;
1295 
1296         /* process head */
1297         if (todo && base < buf->head->iov_len) {
1298                 c = buf->head->iov_base + base;
1299                 avail_here = min_t(unsigned int, todo,
1300                                    buf->head->iov_len - base);
1301                 todo -= avail_here;
1302 
1303                 while (avail_here >= desc->elem_size) {
1304                         err = desc->xcode(desc, c);
1305                         if (err)
1306                                 goto out;
1307                         c += desc->elem_size;
1308                         avail_here -= desc->elem_size;
1309                 }
1310                 if (avail_here) {
1311                         if (!elem) {
1312                                 elem = kmalloc(desc->elem_size, GFP_KERNEL);
1313                                 err = -ENOMEM;
1314                                 if (!elem)
1315                                         goto out;
1316                         }
1317                         if (encode) {
1318                                 err = desc->xcode(desc, elem);
1319                                 if (err)
1320                                         goto out;
1321                                 memcpy(c, elem, avail_here);
1322                         } else
1323                                 memcpy(elem, c, avail_here);
1324                         copied = avail_here;
1325                 }
1326                 base = buf->head->iov_len;  /* align to start of pages */
1327         }
1328 
1329         /* process pages array */
1330         base -= buf->head->iov_len;
1331         if (todo && base < buf->page_len) {
1332                 unsigned int avail_page;
1333 
1334                 avail_here = min(todo, buf->page_len - base);
1335                 todo -= avail_here;
1336 
1337                 base += buf->page_base;
1338                 ppages = buf->pages + (base >> PAGE_SHIFT);
1339                 base &= ~PAGE_MASK;
1340                 avail_page = min_t(unsigned int, PAGE_SIZE - base,
1341                                         avail_here);
1342                 c = kmap(*ppages) + base;
1343 
1344                 while (avail_here) {
1345                         avail_here -= avail_page;
1346                         if (copied || avail_page < desc->elem_size) {
1347                                 unsigned int l = min(avail_page,
1348                                         desc->elem_size - copied);
1349                                 if (!elem) {
1350                                         elem = kmalloc(desc->elem_size,
1351                                                        GFP_KERNEL);
1352                                         err = -ENOMEM;
1353                                         if (!elem)
1354                                                 goto out;
1355                                 }
1356                                 if (encode) {
1357                                         if (!copied) {
1358                                                 err = desc->xcode(desc, elem);
1359                                                 if (err)
1360                                                         goto out;
1361                                         }
1362                                         memcpy(c, elem + copied, l);
1363                                         copied += l;
1364                                         if (copied == desc->elem_size)
1365                                                 copied = 0;
1366                                 } else {
1367                                         memcpy(elem + copied, c, l);
1368                                         copied += l;
1369                                         if (copied == desc->elem_size) {
1370                                                 err = desc->xcode(desc, elem);
1371                                                 if (err)
1372                                                         goto out;
1373                                                 copied = 0;
1374                                         }
1375                                 }
1376                                 avail_page -= l;
1377                                 c += l;
1378                         }
1379                         while (avail_page >= desc->elem_size) {
1380                                 err = desc->xcode(desc, c);
1381                                 if (err)
1382                                         goto out;
1383                                 c += desc->elem_size;
1384                                 avail_page -= desc->elem_size;
1385                         }
1386                         if (avail_page) {
1387                                 unsigned int l = min(avail_page,
1388                                             desc->elem_size - copied);
1389                                 if (!elem) {
1390                                         elem = kmalloc(desc->elem_size,
1391                                                        GFP_KERNEL);
1392                                         err = -ENOMEM;
1393                                         if (!elem)
1394                                                 goto out;
1395                                 }
1396                                 if (encode) {
1397                                         if (!copied) {
1398                                                 err = desc->xcode(desc, elem);
1399                                                 if (err)
1400                                                         goto out;
1401                                         }
1402                                         memcpy(c, elem + copied, l);
1403                                         copied += l;
1404                                         if (copied == desc->elem_size)
1405                                                 copied = 0;
1406                                 } else {
1407                                         memcpy(elem + copied, c, l);
1408                                         copied += l;
1409                                         if (copied == desc->elem_size) {
1410                                                 err = desc->xcode(desc, elem);
1411                                                 if (err)
1412                                                         goto out;
1413                                                 copied = 0;
1414                                         }
1415                                 }
1416                         }
1417                         if (avail_here) {
1418                                 kunmap(*ppages);
1419                                 ppages++;
1420                                 c = kmap(*ppages);
1421                         }
1422 
1423                         avail_page = min(avail_here,
1424                                  (unsigned int) PAGE_SIZE);
1425                 }
1426                 base = buf->page_len;  /* align to start of tail */
1427         }
1428 
1429         /* process tail */
1430         base -= buf->page_len;
1431         if (todo) {
1432                 c = buf->tail->iov_base + base;
1433                 if (copied) {
1434                         unsigned int l = desc->elem_size - copied;
1435 
1436                         if (encode)
1437                                 memcpy(c, elem + copied, l);
1438                         else {
1439                                 memcpy(elem + copied, c, l);
1440                                 err = desc->xcode(desc, elem);
1441                                 if (err)
1442                                         goto out;
1443                         }
1444                         todo -= l;
1445                         c += l;
1446                 }
1447                 while (todo) {
1448                         err = desc->xcode(desc, c);
1449                         if (err)
1450                                 goto out;
1451                         c += desc->elem_size;
1452                         todo -= desc->elem_size;
1453                 }
1454         }
1455         err = 0;
1456 
1457 out:
1458         kfree(elem);
1459         if (ppages)
1460                 kunmap(*ppages);
1461         return err;
1462 }
1463 
1464 int
1465 xdr_decode_array2(struct xdr_buf *buf, unsigned int base,
1466                   struct xdr_array2_desc *desc)
1467 {
1468         if (base >= buf->len)
1469                 return -EINVAL;
1470 
1471         return xdr_xcode_array2(buf, base, desc, 0);
1472 }
1473 EXPORT_SYMBOL_GPL(xdr_decode_array2);
1474 
1475 int
1476 xdr_encode_array2(struct xdr_buf *buf, unsigned int base,
1477                   struct xdr_array2_desc *desc)
1478 {
1479         if ((unsigned long) base + 4 + desc->array_len * desc->elem_size >
1480             buf->head->iov_len + buf->page_len + buf->tail->iov_len)
1481                 return -EINVAL;
1482 
1483         return xdr_xcode_array2(buf, base, desc, 1);
1484 }
1485 EXPORT_SYMBOL_GPL(xdr_encode_array2);
1486 
1487 int
1488 xdr_process_buf(struct xdr_buf *buf, unsigned int offset, unsigned int len,
1489                 int (*actor)(struct scatterlist *, void *), void *data)
1490 {
1491         int i, ret = 0;
1492         unsigned int page_len, thislen, page_offset;
1493         struct scatterlist      sg[1];
1494 
1495         sg_init_table(sg, 1);
1496 
1497         if (offset >= buf->head[0].iov_len) {
1498                 offset -= buf->head[0].iov_len;
1499         } else {
1500                 thislen = buf->head[0].iov_len - offset;
1501                 if (thislen > len)
1502                         thislen = len;
1503                 sg_set_buf(sg, buf->head[0].iov_base + offset, thislen);
1504                 ret = actor(sg, data);
1505                 if (ret)
1506                         goto out;
1507                 offset = 0;
1508                 len -= thislen;
1509         }
1510         if (len == 0)
1511                 goto out;
1512 
1513         if (offset >= buf->page_len) {
1514                 offset -= buf->page_len;
1515         } else {
1516                 page_len = buf->page_len - offset;
1517                 if (page_len > len)
1518                         page_len = len;
1519                 len -= page_len;
1520                 page_offset = (offset + buf->page_base) & (PAGE_SIZE - 1);
1521                 i = (offset + buf->page_base) >> PAGE_SHIFT;
1522                 thislen = PAGE_SIZE - page_offset;
1523                 do {
1524                         if (thislen > page_len)
1525                                 thislen = page_len;
1526                         sg_set_page(sg, buf->pages[i], thislen, page_offset);
1527                         ret = actor(sg, data);
1528                         if (ret)
1529                                 goto out;
1530                         page_len -= thislen;
1531                         i++;
1532                         page_offset = 0;
1533                         thislen = PAGE_SIZE;
1534                 } while (page_len != 0);
1535                 offset = 0;
1536         }
1537         if (len == 0)
1538                 goto out;
1539         if (offset < buf->tail[0].iov_len) {
1540                 thislen = buf->tail[0].iov_len - offset;
1541                 if (thislen > len)
1542                         thislen = len;
1543                 sg_set_buf(sg, buf->tail[0].iov_base + offset, thislen);
1544                 ret = actor(sg, data);
1545                 len -= thislen;
1546         }
1547         if (len != 0)
1548                 ret = -EINVAL;
1549 out:
1550         return ret;
1551 }
1552 EXPORT_SYMBOL_GPL(xdr_process_buf);
1553 
1554 /**
1555  * xdr_stream_decode_opaque - Decode variable length opaque
1556  * @xdr: pointer to xdr_stream
1557  * @ptr: location to store opaque data
1558  * @size: size of storage buffer @ptr
1559  *
1560  * Return values:
1561  *   On success, returns size of object stored in *@ptr
1562  *   %-EBADMSG on XDR buffer overflow
1563  *   %-EMSGSIZE on overflow of storage buffer @ptr
1564  */
1565 ssize_t xdr_stream_decode_opaque(struct xdr_stream *xdr, void *ptr, size_t size)
1566 {
1567         ssize_t ret;
1568         void *p;
1569 
1570         ret = xdr_stream_decode_opaque_inline(xdr, &p, size);
1571         if (ret <= 0)
1572                 return ret;
1573         memcpy(ptr, p, ret);
1574         return ret;
1575 }
1576 EXPORT_SYMBOL_GPL(xdr_stream_decode_opaque);
1577 
1578 /**
1579  * xdr_stream_decode_opaque_dup - Decode and duplicate variable length opaque
1580  * @xdr: pointer to xdr_stream
1581  * @ptr: location to store pointer to opaque data
1582  * @maxlen: maximum acceptable object size
1583  * @gfp_flags: GFP mask to use
1584  *
1585  * Return values:
1586  *   On success, returns size of object stored in *@ptr
1587  *   %-EBADMSG on XDR buffer overflow
1588  *   %-EMSGSIZE if the size of the object would exceed @maxlen
1589  *   %-ENOMEM on memory allocation failure
1590  */
1591 ssize_t xdr_stream_decode_opaque_dup(struct xdr_stream *xdr, void **ptr,
1592                 size_t maxlen, gfp_t gfp_flags)
1593 {
1594         ssize_t ret;
1595         void *p;
1596 
1597         ret = xdr_stream_decode_opaque_inline(xdr, &p, maxlen);
1598         if (ret > 0) {
1599                 *ptr = kmemdup(p, ret, gfp_flags);
1600                 if (*ptr != NULL)
1601                         return ret;
1602                 ret = -ENOMEM;
1603         }
1604         *ptr = NULL;
1605         return ret;
1606 }
1607 EXPORT_SYMBOL_GPL(xdr_stream_decode_opaque_dup);
1608 
1609 /**
1610  * xdr_stream_decode_string - Decode variable length string
1611  * @xdr: pointer to xdr_stream
1612  * @str: location to store string
1613  * @size: size of storage buffer @str
1614  *
1615  * Return values:
1616  *   On success, returns length of NUL-terminated string stored in *@str
1617  *   %-EBADMSG on XDR buffer overflow
1618  *   %-EMSGSIZE on overflow of storage buffer @str
1619  */
1620 ssize_t xdr_stream_decode_string(struct xdr_stream *xdr, char *str, size_t size)
1621 {
1622         ssize_t ret;
1623         void *p;
1624 
1625         ret = xdr_stream_decode_opaque_inline(xdr, &p, size);
1626         if (ret > 0) {
1627                 memcpy(str, p, ret);
1628                 str[ret] = '\0';
1629                 return strlen(str);
1630         }
1631         *str = '\0';
1632         return ret;
1633 }
1634 EXPORT_SYMBOL_GPL(xdr_stream_decode_string);
1635 
1636 /**
1637  * xdr_stream_decode_string_dup - Decode and duplicate variable length string
1638  * @xdr: pointer to xdr_stream
1639  * @str: location to store pointer to string
1640  * @maxlen: maximum acceptable string length
1641  * @gfp_flags: GFP mask to use
1642  *
1643  * Return values:
1644  *   On success, returns length of NUL-terminated string stored in *@ptr
1645  *   %-EBADMSG on XDR buffer overflow
1646  *   %-EMSGSIZE if the size of the string would exceed @maxlen
1647  *   %-ENOMEM on memory allocation failure
1648  */
1649 ssize_t xdr_stream_decode_string_dup(struct xdr_stream *xdr, char **str,
1650                 size_t maxlen, gfp_t gfp_flags)
1651 {
1652         void *p;
1653         ssize_t ret;
1654 
1655         ret = xdr_stream_decode_opaque_inline(xdr, &p, maxlen);
1656         if (ret > 0) {
1657                 char *s = kmalloc(ret + 1, gfp_flags);
1658                 if (s != NULL) {
1659                         memcpy(s, p, ret);
1660                         s[ret] = '\0';
1661                         *str = s;
1662                         return strlen(s);
1663                 }
1664                 ret = -ENOMEM;
1665         }
1666         *str = NULL;
1667         return ret;
1668 }
1669 EXPORT_SYMBOL_GPL(xdr_stream_decode_string_dup);
1670 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp