blob: aaf08cdd19f09fad9b9a36e7cdd8041606dbfd6e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Chuck Levera246b012005-08-11 16:25:23 -04009#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include <linux/types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/string.h>
12#include <linux/kernel.h>
13#include <linux/pagemap.h>
14#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/sunrpc/xdr.h>
16#include <linux/sunrpc/msg_prot.h>
17
18/*
19 * XDR functions for basic NFS types
20 */
21u32 *
22xdr_encode_netobj(u32 *p, const struct xdr_netobj *obj)
23{
24 unsigned int quadlen = XDR_QUADLEN(obj->len);
25
26 p[quadlen] = 0; /* zero trailing bytes */
27 *p++ = htonl(obj->len);
28 memcpy(p, obj->data, obj->len);
29 return p + XDR_QUADLEN(obj->len);
30}
31
32u32 *
33xdr_decode_netobj(u32 *p, struct xdr_netobj *obj)
34{
35 unsigned int len;
36
37 if ((len = ntohl(*p++)) > XDR_MAX_NETOBJ)
38 return NULL;
39 obj->len = len;
40 obj->data = (u8 *) p;
41 return p + XDR_QUADLEN(len);
42}
43
44/**
45 * xdr_encode_opaque_fixed - Encode fixed length opaque data
Pavel Pisa4dc3b162005-05-01 08:59:25 -070046 * @p: pointer to current position in XDR buffer.
47 * @ptr: pointer to data to encode (or NULL)
48 * @nbytes: size of data.
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 *
50 * Copy the array of data of length nbytes at ptr to the XDR buffer
51 * at position p, then align to the next 32-bit boundary by padding
52 * with zero bytes (see RFC1832).
53 * Note: if ptr is NULL, only the padding is performed.
54 *
55 * Returns the updated current XDR buffer position
56 *
57 */
58u32 *xdr_encode_opaque_fixed(u32 *p, const void *ptr, unsigned int nbytes)
59{
60 if (likely(nbytes != 0)) {
61 unsigned int quadlen = XDR_QUADLEN(nbytes);
62 unsigned int padding = (quadlen << 2) - nbytes;
63
64 if (ptr != NULL)
65 memcpy(p, ptr, nbytes);
66 if (padding != 0)
67 memset((char *)p + nbytes, 0, padding);
68 p += quadlen;
69 }
70 return p;
71}
72EXPORT_SYMBOL(xdr_encode_opaque_fixed);
73
74/**
75 * xdr_encode_opaque - Encode variable length opaque data
Pavel Pisa4dc3b162005-05-01 08:59:25 -070076 * @p: pointer to current position in XDR buffer.
77 * @ptr: pointer to data to encode (or NULL)
78 * @nbytes: size of data.
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 *
80 * Returns the updated current XDR buffer position
81 */
82u32 *xdr_encode_opaque(u32 *p, const void *ptr, unsigned int nbytes)
83{
84 *p++ = htonl(nbytes);
85 return xdr_encode_opaque_fixed(p, ptr, nbytes);
86}
87EXPORT_SYMBOL(xdr_encode_opaque);
88
89u32 *
90xdr_encode_string(u32 *p, const char *string)
91{
92 return xdr_encode_array(p, string, strlen(string));
93}
94
95u32 *
96xdr_decode_string(u32 *p, char **sp, int *lenp, int maxlen)
97{
98 unsigned int len;
99 char *string;
100
101 if ((len = ntohl(*p++)) > maxlen)
102 return NULL;
103 if (lenp)
104 *lenp = len;
105 if ((len % 4) != 0) {
106 string = (char *) p;
107 } else {
108 string = (char *) (p - 1);
109 memmove(string, p, len);
110 }
111 string[len] = '\0';
112 *sp = string;
113 return p + XDR_QUADLEN(len);
114}
115
116u32 *
117xdr_decode_string_inplace(u32 *p, char **sp, int *lenp, int maxlen)
118{
119 unsigned int len;
120
121 if ((len = ntohl(*p++)) > maxlen)
122 return NULL;
123 *lenp = len;
124 *sp = (char *) p;
125 return p + XDR_QUADLEN(len);
126}
127
128void
129xdr_encode_pages(struct xdr_buf *xdr, struct page **pages, unsigned int base,
130 unsigned int len)
131{
132 struct kvec *tail = xdr->tail;
133 u32 *p;
134
135 xdr->pages = pages;
136 xdr->page_base = base;
137 xdr->page_len = len;
138
139 p = (u32 *)xdr->head[0].iov_base + XDR_QUADLEN(xdr->head[0].iov_len);
140 tail->iov_base = p;
141 tail->iov_len = 0;
142
143 if (len & 3) {
144 unsigned int pad = 4 - (len & 3);
145
146 *p = 0;
147 tail->iov_base = (char *)p + (len & 3);
148 tail->iov_len = pad;
149 len += pad;
150 }
151 xdr->buflen += len;
152 xdr->len += len;
153}
154
155void
156xdr_inline_pages(struct xdr_buf *xdr, unsigned int offset,
157 struct page **pages, unsigned int base, unsigned int len)
158{
159 struct kvec *head = xdr->head;
160 struct kvec *tail = xdr->tail;
161 char *buf = (char *)head->iov_base;
162 unsigned int buflen = head->iov_len;
163
164 head->iov_len = offset;
165
166 xdr->pages = pages;
167 xdr->page_base = base;
168 xdr->page_len = len;
169
170 tail->iov_base = buf + offset;
171 tail->iov_len = buflen - offset;
172
173 xdr->buflen += len;
174}
175
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177/*
178 * Helper routines for doing 'memmove' like operations on a struct xdr_buf
179 *
180 * _shift_data_right_pages
181 * @pages: vector of pages containing both the source and dest memory area.
182 * @pgto_base: page vector address of destination
183 * @pgfrom_base: page vector address of source
184 * @len: number of bytes to copy
185 *
186 * Note: the addresses pgto_base and pgfrom_base are both calculated in
187 * the same way:
188 * if a memory area starts at byte 'base' in page 'pages[i]',
189 * then its address is given as (i << PAGE_CACHE_SHIFT) + base
190 * Also note: pgfrom_base must be < pgto_base, but the memory areas
191 * they point to may overlap.
192 */
193static void
194_shift_data_right_pages(struct page **pages, size_t pgto_base,
195 size_t pgfrom_base, size_t len)
196{
197 struct page **pgfrom, **pgto;
198 char *vfrom, *vto;
199 size_t copy;
200
201 BUG_ON(pgto_base <= pgfrom_base);
202
203 pgto_base += len;
204 pgfrom_base += len;
205
206 pgto = pages + (pgto_base >> PAGE_CACHE_SHIFT);
207 pgfrom = pages + (pgfrom_base >> PAGE_CACHE_SHIFT);
208
209 pgto_base &= ~PAGE_CACHE_MASK;
210 pgfrom_base &= ~PAGE_CACHE_MASK;
211
212 do {
213 /* Are any pointers crossing a page boundary? */
214 if (pgto_base == 0) {
215 flush_dcache_page(*pgto);
216 pgto_base = PAGE_CACHE_SIZE;
217 pgto--;
218 }
219 if (pgfrom_base == 0) {
220 pgfrom_base = PAGE_CACHE_SIZE;
221 pgfrom--;
222 }
223
224 copy = len;
225 if (copy > pgto_base)
226 copy = pgto_base;
227 if (copy > pgfrom_base)
228 copy = pgfrom_base;
229 pgto_base -= copy;
230 pgfrom_base -= copy;
231
232 vto = kmap_atomic(*pgto, KM_USER0);
233 vfrom = kmap_atomic(*pgfrom, KM_USER1);
234 memmove(vto + pgto_base, vfrom + pgfrom_base, copy);
235 kunmap_atomic(vfrom, KM_USER1);
236 kunmap_atomic(vto, KM_USER0);
237
238 } while ((len -= copy) != 0);
239 flush_dcache_page(*pgto);
240}
241
242/*
243 * _copy_to_pages
244 * @pages: array of pages
245 * @pgbase: page vector address of destination
246 * @p: pointer to source data
247 * @len: length
248 *
249 * Copies data from an arbitrary memory location into an array of pages
250 * The copy is assumed to be non-overlapping.
251 */
252static void
253_copy_to_pages(struct page **pages, size_t pgbase, const char *p, size_t len)
254{
255 struct page **pgto;
256 char *vto;
257 size_t copy;
258
259 pgto = pages + (pgbase >> PAGE_CACHE_SHIFT);
260 pgbase &= ~PAGE_CACHE_MASK;
261
262 do {
263 copy = PAGE_CACHE_SIZE - pgbase;
264 if (copy > len)
265 copy = len;
266
267 vto = kmap_atomic(*pgto, KM_USER0);
268 memcpy(vto + pgbase, p, copy);
269 kunmap_atomic(vto, KM_USER0);
270
271 pgbase += copy;
272 if (pgbase == PAGE_CACHE_SIZE) {
273 flush_dcache_page(*pgto);
274 pgbase = 0;
275 pgto++;
276 }
277 p += copy;
278
279 } while ((len -= copy) != 0);
280 flush_dcache_page(*pgto);
281}
282
283/*
284 * _copy_from_pages
285 * @p: pointer to destination
286 * @pages: array of pages
287 * @pgbase: offset of source data
288 * @len: length
289 *
290 * Copies data into an arbitrary memory location from an array of pages
291 * The copy is assumed to be non-overlapping.
292 */
293static void
294_copy_from_pages(char *p, struct page **pages, size_t pgbase, size_t len)
295{
296 struct page **pgfrom;
297 char *vfrom;
298 size_t copy;
299
300 pgfrom = pages + (pgbase >> PAGE_CACHE_SHIFT);
301 pgbase &= ~PAGE_CACHE_MASK;
302
303 do {
304 copy = PAGE_CACHE_SIZE - pgbase;
305 if (copy > len)
306 copy = len;
307
308 vfrom = kmap_atomic(*pgfrom, KM_USER0);
309 memcpy(p, vfrom + pgbase, copy);
310 kunmap_atomic(vfrom, KM_USER0);
311
312 pgbase += copy;
313 if (pgbase == PAGE_CACHE_SIZE) {
314 pgbase = 0;
315 pgfrom++;
316 }
317 p += copy;
318
319 } while ((len -= copy) != 0);
320}
321
322/*
323 * xdr_shrink_bufhead
324 * @buf: xdr_buf
325 * @len: bytes to remove from buf->head[0]
326 *
327 * Shrinks XDR buffer's header kvec buf->head[0] by
328 * 'len' bytes. The extra data is not lost, but is instead
329 * moved into the inlined pages and/or the tail.
330 */
331static void
332xdr_shrink_bufhead(struct xdr_buf *buf, size_t len)
333{
334 struct kvec *head, *tail;
335 size_t copy, offs;
336 unsigned int pglen = buf->page_len;
337
338 tail = buf->tail;
339 head = buf->head;
340 BUG_ON (len > head->iov_len);
341
342 /* Shift the tail first */
343 if (tail->iov_len != 0) {
344 if (tail->iov_len > len) {
345 copy = tail->iov_len - len;
346 memmove((char *)tail->iov_base + len,
347 tail->iov_base, copy);
348 }
349 /* Copy from the inlined pages into the tail */
350 copy = len;
351 if (copy > pglen)
352 copy = pglen;
353 offs = len - copy;
354 if (offs >= tail->iov_len)
355 copy = 0;
356 else if (copy > tail->iov_len - offs)
357 copy = tail->iov_len - offs;
358 if (copy != 0)
359 _copy_from_pages((char *)tail->iov_base + offs,
360 buf->pages,
361 buf->page_base + pglen + offs - len,
362 copy);
363 /* Do we also need to copy data from the head into the tail ? */
364 if (len > pglen) {
365 offs = copy = len - pglen;
366 if (copy > tail->iov_len)
367 copy = tail->iov_len;
368 memcpy(tail->iov_base,
369 (char *)head->iov_base +
370 head->iov_len - offs,
371 copy);
372 }
373 }
374 /* Now handle pages */
375 if (pglen != 0) {
376 if (pglen > len)
377 _shift_data_right_pages(buf->pages,
378 buf->page_base + len,
379 buf->page_base,
380 pglen - len);
381 copy = len;
382 if (len > pglen)
383 copy = pglen;
384 _copy_to_pages(buf->pages, buf->page_base,
385 (char *)head->iov_base + head->iov_len - len,
386 copy);
387 }
388 head->iov_len -= len;
389 buf->buflen -= len;
390 /* Have we truncated the message? */
391 if (buf->len > buf->buflen)
392 buf->len = buf->buflen;
393}
394
395/*
396 * xdr_shrink_pagelen
397 * @buf: xdr_buf
398 * @len: bytes to remove from buf->pages
399 *
400 * Shrinks XDR buffer's page array buf->pages by
401 * 'len' bytes. The extra data is not lost, but is instead
402 * moved into the tail.
403 */
404static void
405xdr_shrink_pagelen(struct xdr_buf *buf, size_t len)
406{
407 struct kvec *tail;
408 size_t copy;
409 char *p;
410 unsigned int pglen = buf->page_len;
411
412 tail = buf->tail;
413 BUG_ON (len > pglen);
414
415 /* Shift the tail first */
416 if (tail->iov_len != 0) {
417 p = (char *)tail->iov_base + len;
418 if (tail->iov_len > len) {
419 copy = tail->iov_len - len;
420 memmove(p, tail->iov_base, copy);
421 } else
422 buf->buflen -= len;
423 /* Copy from the inlined pages into the tail */
424 copy = len;
425 if (copy > tail->iov_len)
426 copy = tail->iov_len;
427 _copy_from_pages((char *)tail->iov_base,
428 buf->pages, buf->page_base + pglen - len,
429 copy);
430 }
431 buf->page_len -= len;
432 buf->buflen -= len;
433 /* Have we truncated the message? */
434 if (buf->len > buf->buflen)
435 buf->len = buf->buflen;
436}
437
438void
439xdr_shift_buf(struct xdr_buf *buf, size_t len)
440{
441 xdr_shrink_bufhead(buf, len);
442}
443
444/**
445 * xdr_init_encode - Initialize a struct xdr_stream for sending data.
446 * @xdr: pointer to xdr_stream struct
447 * @buf: pointer to XDR buffer in which to encode data
448 * @p: current pointer inside XDR buffer
449 *
450 * Note: at the moment the RPC client only passes the length of our
451 * scratch buffer in the xdr_buf's header kvec. Previously this
452 * meant we needed to call xdr_adjust_iovec() after encoding the
453 * data. With the new scheme, the xdr_stream manages the details
454 * of the buffer length, and takes care of adjusting the kvec
455 * length for us.
456 */
457void xdr_init_encode(struct xdr_stream *xdr, struct xdr_buf *buf, uint32_t *p)
458{
459 struct kvec *iov = buf->head;
Trond Myklebust334ccfd2005-06-22 17:16:19 +0000460 int scratch_len = buf->buflen - buf->page_len - buf->tail[0].iov_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461
Trond Myklebust334ccfd2005-06-22 17:16:19 +0000462 BUG_ON(scratch_len < 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 xdr->buf = buf;
464 xdr->iov = iov;
Trond Myklebust334ccfd2005-06-22 17:16:19 +0000465 xdr->p = (uint32_t *)((char *)iov->iov_base + iov->iov_len);
466 xdr->end = (uint32_t *)((char *)iov->iov_base + scratch_len);
467 BUG_ON(iov->iov_len > scratch_len);
468
469 if (p != xdr->p && p != NULL) {
470 size_t len;
471
472 BUG_ON(p < xdr->p || p > xdr->end);
473 len = (char *)p - (char *)xdr->p;
474 xdr->p = p;
475 buf->len += len;
476 iov->iov_len += len;
477 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478}
479EXPORT_SYMBOL(xdr_init_encode);
480
481/**
482 * xdr_reserve_space - Reserve buffer space for sending
483 * @xdr: pointer to xdr_stream
484 * @nbytes: number of bytes to reserve
485 *
486 * Checks that we have enough buffer space to encode 'nbytes' more
487 * bytes of data. If so, update the total xdr_buf length, and
488 * adjust the length of the current kvec.
489 */
490uint32_t * xdr_reserve_space(struct xdr_stream *xdr, size_t nbytes)
491{
492 uint32_t *p = xdr->p;
493 uint32_t *q;
494
495 /* align nbytes on the next 32-bit boundary */
496 nbytes += 3;
497 nbytes &= ~3;
498 q = p + (nbytes >> 2);
499 if (unlikely(q > xdr->end || q < p))
500 return NULL;
501 xdr->p = q;
502 xdr->iov->iov_len += nbytes;
503 xdr->buf->len += nbytes;
504 return p;
505}
506EXPORT_SYMBOL(xdr_reserve_space);
507
508/**
509 * xdr_write_pages - Insert a list of pages into an XDR buffer for sending
510 * @xdr: pointer to xdr_stream
511 * @pages: list of pages
512 * @base: offset of first byte
513 * @len: length of data in bytes
514 *
515 */
516void xdr_write_pages(struct xdr_stream *xdr, struct page **pages, unsigned int base,
517 unsigned int len)
518{
519 struct xdr_buf *buf = xdr->buf;
520 struct kvec *iov = buf->tail;
521 buf->pages = pages;
522 buf->page_base = base;
523 buf->page_len = len;
524
525 iov->iov_base = (char *)xdr->p;
526 iov->iov_len = 0;
527 xdr->iov = iov;
528
529 if (len & 3) {
530 unsigned int pad = 4 - (len & 3);
531
532 BUG_ON(xdr->p >= xdr->end);
533 iov->iov_base = (char *)xdr->p + (len & 3);
534 iov->iov_len += pad;
535 len += pad;
536 *xdr->p++ = 0;
537 }
538 buf->buflen += len;
539 buf->len += len;
540}
541EXPORT_SYMBOL(xdr_write_pages);
542
543/**
544 * xdr_init_decode - Initialize an xdr_stream for decoding data.
545 * @xdr: pointer to xdr_stream struct
546 * @buf: pointer to XDR buffer from which to decode data
547 * @p: current pointer inside XDR buffer
548 */
549void xdr_init_decode(struct xdr_stream *xdr, struct xdr_buf *buf, uint32_t *p)
550{
551 struct kvec *iov = buf->head;
552 unsigned int len = iov->iov_len;
553
554 if (len > buf->len)
555 len = buf->len;
556 xdr->buf = buf;
557 xdr->iov = iov;
558 xdr->p = p;
559 xdr->end = (uint32_t *)((char *)iov->iov_base + len);
560}
561EXPORT_SYMBOL(xdr_init_decode);
562
563/**
564 * xdr_inline_decode - Retrieve non-page XDR data to decode
565 * @xdr: pointer to xdr_stream struct
566 * @nbytes: number of bytes of data to decode
567 *
568 * Check if the input buffer is long enough to enable us to decode
569 * 'nbytes' more bytes of data starting at the current position.
570 * If so return the current pointer, then update the current
571 * pointer position.
572 */
573uint32_t * xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes)
574{
575 uint32_t *p = xdr->p;
576 uint32_t *q = p + XDR_QUADLEN(nbytes);
577
578 if (unlikely(q > xdr->end || q < p))
579 return NULL;
580 xdr->p = q;
581 return p;
582}
583EXPORT_SYMBOL(xdr_inline_decode);
584
585/**
586 * xdr_read_pages - Ensure page-based XDR data to decode is aligned at current pointer position
587 * @xdr: pointer to xdr_stream struct
588 * @len: number of bytes of page data
589 *
590 * Moves data beyond the current pointer position from the XDR head[] buffer
591 * into the page list. Any data that lies beyond current position + "len"
592 * bytes is moved into the XDR tail[]. The current pointer is then
593 * repositioned at the beginning of the XDR tail.
594 */
595void xdr_read_pages(struct xdr_stream *xdr, unsigned int len)
596{
597 struct xdr_buf *buf = xdr->buf;
598 struct kvec *iov;
599 ssize_t shift;
600 unsigned int end;
601 int padding;
602
603 /* Realign pages to current pointer position */
604 iov = buf->head;
605 shift = iov->iov_len + (char *)iov->iov_base - (char *)xdr->p;
606 if (shift > 0)
607 xdr_shrink_bufhead(buf, shift);
608
609 /* Truncate page data and move it into the tail */
610 if (buf->page_len > len)
611 xdr_shrink_pagelen(buf, buf->page_len - len);
612 padding = (XDR_QUADLEN(len) << 2) - len;
613 xdr->iov = iov = buf->tail;
614 /* Compute remaining message length. */
615 end = iov->iov_len;
616 shift = buf->buflen - buf->len;
617 if (shift < end)
618 end -= shift;
619 else if (shift > 0)
620 end = 0;
621 /*
622 * Position current pointer at beginning of tail, and
623 * set remaining message length.
624 */
625 xdr->p = (uint32_t *)((char *)iov->iov_base + padding);
626 xdr->end = (uint32_t *)((char *)iov->iov_base + end);
627}
628EXPORT_SYMBOL(xdr_read_pages);
629
630static struct kvec empty_iov = {.iov_base = NULL, .iov_len = 0};
631
632void
633xdr_buf_from_iov(struct kvec *iov, struct xdr_buf *buf)
634{
635 buf->head[0] = *iov;
636 buf->tail[0] = empty_iov;
637 buf->page_len = 0;
638 buf->buflen = buf->len = iov->iov_len;
639}
640
641/* Sets subiov to the intersection of iov with the buffer of length len
642 * starting base bytes after iov. Indicates empty intersection by setting
643 * length of subiov to zero. Decrements len by length of subiov, sets base
644 * to zero (or decrements it by length of iov if subiov is empty). */
645static void
646iov_subsegment(struct kvec *iov, struct kvec *subiov, int *base, int *len)
647{
648 if (*base > iov->iov_len) {
649 subiov->iov_base = NULL;
650 subiov->iov_len = 0;
651 *base -= iov->iov_len;
652 } else {
653 subiov->iov_base = iov->iov_base + *base;
654 subiov->iov_len = min(*len, (int)iov->iov_len - *base);
655 *base = 0;
656 }
657 *len -= subiov->iov_len;
658}
659
660/* Sets subbuf to the portion of buf of length len beginning base bytes
661 * from the start of buf. Returns -1 if base of length are out of bounds. */
662int
663xdr_buf_subsegment(struct xdr_buf *buf, struct xdr_buf *subbuf,
664 int base, int len)
665{
666 int i;
667
668 subbuf->buflen = subbuf->len = len;
669 iov_subsegment(buf->head, subbuf->head, &base, &len);
670
671 if (base < buf->page_len) {
672 i = (base + buf->page_base) >> PAGE_CACHE_SHIFT;
673 subbuf->pages = &buf->pages[i];
674 subbuf->page_base = (base + buf->page_base) & ~PAGE_CACHE_MASK;
675 subbuf->page_len = min((int)buf->page_len - base, len);
676 len -= subbuf->page_len;
677 base = 0;
678 } else {
679 base -= buf->page_len;
680 subbuf->page_len = 0;
681 }
682
683 iov_subsegment(buf->tail, subbuf->tail, &base, &len);
684 if (base || len)
685 return -1;
686 return 0;
687}
688
689/* obj is assumed to point to allocated memory of size at least len: */
690int
691read_bytes_from_xdr_buf(struct xdr_buf *buf, int base, void *obj, int len)
692{
693 struct xdr_buf subbuf;
694 int this_len;
695 int status;
696
697 status = xdr_buf_subsegment(buf, &subbuf, base, len);
698 if (status)
699 goto out;
700 this_len = min(len, (int)subbuf.head[0].iov_len);
701 memcpy(obj, subbuf.head[0].iov_base, this_len);
702 len -= this_len;
703 obj += this_len;
704 this_len = min(len, (int)subbuf.page_len);
705 if (this_len)
706 _copy_from_pages(obj, subbuf.pages, subbuf.page_base, this_len);
707 len -= this_len;
708 obj += this_len;
709 this_len = min(len, (int)subbuf.tail[0].iov_len);
710 memcpy(obj, subbuf.tail[0].iov_base, this_len);
711out:
712 return status;
713}
714
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000715/* obj is assumed to point to allocated memory of size at least len: */
716int
717write_bytes_to_xdr_buf(struct xdr_buf *buf, int base, void *obj, int len)
718{
719 struct xdr_buf subbuf;
720 int this_len;
721 int status;
722
723 status = xdr_buf_subsegment(buf, &subbuf, base, len);
724 if (status)
725 goto out;
726 this_len = min(len, (int)subbuf.head[0].iov_len);
727 memcpy(subbuf.head[0].iov_base, obj, this_len);
728 len -= this_len;
729 obj += this_len;
730 this_len = min(len, (int)subbuf.page_len);
731 if (this_len)
732 _copy_to_pages(subbuf.pages, subbuf.page_base, obj, this_len);
733 len -= this_len;
734 obj += this_len;
735 this_len = min(len, (int)subbuf.tail[0].iov_len);
736 memcpy(subbuf.tail[0].iov_base, obj, this_len);
737out:
738 return status;
739}
740
741int
742xdr_decode_word(struct xdr_buf *buf, int base, u32 *obj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743{
744 u32 raw;
745 int status;
746
747 status = read_bytes_from_xdr_buf(buf, base, &raw, sizeof(*obj));
748 if (status)
749 return status;
750 *obj = ntohl(raw);
751 return 0;
752}
753
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000754int
755xdr_encode_word(struct xdr_buf *buf, int base, u32 obj)
756{
757 u32 raw = htonl(obj);
758
759 return write_bytes_to_xdr_buf(buf, base, &raw, sizeof(obj));
760}
761
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762/* If the netobj starting offset bytes from the start of xdr_buf is contained
763 * entirely in the head or the tail, set object to point to it; otherwise
764 * try to find space for it at the end of the tail, copy it there, and
765 * set obj to point to it. */
766int
767xdr_buf_read_netobj(struct xdr_buf *buf, struct xdr_netobj *obj, int offset)
768{
769 u32 tail_offset = buf->head[0].iov_len + buf->page_len;
770 u32 obj_end_offset;
771
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000772 if (xdr_decode_word(buf, offset, &obj->len))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 goto out;
774 obj_end_offset = offset + 4 + obj->len;
775
776 if (obj_end_offset <= buf->head[0].iov_len) {
777 /* The obj is contained entirely in the head: */
778 obj->data = buf->head[0].iov_base + offset + 4;
779 } else if (offset + 4 >= tail_offset) {
780 if (obj_end_offset - tail_offset
781 > buf->tail[0].iov_len)
782 goto out;
783 /* The obj is contained entirely in the tail: */
784 obj->data = buf->tail[0].iov_base
785 + offset - tail_offset + 4;
786 } else {
787 /* use end of tail as storage for obj:
788 * (We don't copy to the beginning because then we'd have
789 * to worry about doing a potentially overlapping copy.
790 * This assumes the object is at most half the length of the
791 * tail.) */
792 if (obj->len > buf->tail[0].iov_len)
793 goto out;
794 obj->data = buf->tail[0].iov_base + buf->tail[0].iov_len -
795 obj->len;
796 if (read_bytes_from_xdr_buf(buf, offset + 4,
797 obj->data, obj->len))
798 goto out;
799
800 }
801 return 0;
802out:
803 return -1;
804}
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000805
806/* Returns 0 on success, or else a negative error code. */
807static int
808xdr_xcode_array2(struct xdr_buf *buf, unsigned int base,
809 struct xdr_array2_desc *desc, int encode)
810{
811 char *elem = NULL, *c;
812 unsigned int copied = 0, todo, avail_here;
813 struct page **ppages = NULL;
814 int err;
815
816 if (encode) {
817 if (xdr_encode_word(buf, base, desc->array_len) != 0)
818 return -EINVAL;
819 } else {
820 if (xdr_decode_word(buf, base, &desc->array_len) != 0 ||
Trond Myklebust58fcb8d2005-08-10 18:15:12 -0400821 desc->array_len > desc->array_maxlen ||
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000822 (unsigned long) base + 4 + desc->array_len *
823 desc->elem_size > buf->len)
824 return -EINVAL;
825 }
826 base += 4;
827
828 if (!desc->xcode)
829 return 0;
830
831 todo = desc->array_len * desc->elem_size;
832
833 /* process head */
834 if (todo && base < buf->head->iov_len) {
835 c = buf->head->iov_base + base;
836 avail_here = min_t(unsigned int, todo,
837 buf->head->iov_len - base);
838 todo -= avail_here;
839
840 while (avail_here >= desc->elem_size) {
841 err = desc->xcode(desc, c);
842 if (err)
843 goto out;
844 c += desc->elem_size;
845 avail_here -= desc->elem_size;
846 }
847 if (avail_here) {
848 if (!elem) {
849 elem = kmalloc(desc->elem_size, GFP_KERNEL);
850 err = -ENOMEM;
851 if (!elem)
852 goto out;
853 }
854 if (encode) {
855 err = desc->xcode(desc, elem);
856 if (err)
857 goto out;
858 memcpy(c, elem, avail_here);
859 } else
860 memcpy(elem, c, avail_here);
861 copied = avail_here;
862 }
863 base = buf->head->iov_len; /* align to start of pages */
864 }
865
866 /* process pages array */
867 base -= buf->head->iov_len;
868 if (todo && base < buf->page_len) {
869 unsigned int avail_page;
870
871 avail_here = min(todo, buf->page_len - base);
872 todo -= avail_here;
873
874 base += buf->page_base;
875 ppages = buf->pages + (base >> PAGE_CACHE_SHIFT);
876 base &= ~PAGE_CACHE_MASK;
877 avail_page = min_t(unsigned int, PAGE_CACHE_SIZE - base,
878 avail_here);
879 c = kmap(*ppages) + base;
880
881 while (avail_here) {
882 avail_here -= avail_page;
883 if (copied || avail_page < desc->elem_size) {
884 unsigned int l = min(avail_page,
885 desc->elem_size - copied);
886 if (!elem) {
887 elem = kmalloc(desc->elem_size,
888 GFP_KERNEL);
889 err = -ENOMEM;
890 if (!elem)
891 goto out;
892 }
893 if (encode) {
894 if (!copied) {
895 err = desc->xcode(desc, elem);
896 if (err)
897 goto out;
898 }
899 memcpy(c, elem + copied, l);
900 copied += l;
901 if (copied == desc->elem_size)
902 copied = 0;
903 } else {
904 memcpy(elem + copied, c, l);
905 copied += l;
906 if (copied == desc->elem_size) {
907 err = desc->xcode(desc, elem);
908 if (err)
909 goto out;
910 copied = 0;
911 }
912 }
913 avail_page -= l;
914 c += l;
915 }
916 while (avail_page >= desc->elem_size) {
917 err = desc->xcode(desc, c);
918 if (err)
919 goto out;
920 c += desc->elem_size;
921 avail_page -= desc->elem_size;
922 }
923 if (avail_page) {
924 unsigned int l = min(avail_page,
925 desc->elem_size - copied);
926 if (!elem) {
927 elem = kmalloc(desc->elem_size,
928 GFP_KERNEL);
929 err = -ENOMEM;
930 if (!elem)
931 goto out;
932 }
933 if (encode) {
934 if (!copied) {
935 err = desc->xcode(desc, elem);
936 if (err)
937 goto out;
938 }
939 memcpy(c, elem + copied, l);
940 copied += l;
941 if (copied == desc->elem_size)
942 copied = 0;
943 } else {
944 memcpy(elem + copied, c, l);
945 copied += l;
946 if (copied == desc->elem_size) {
947 err = desc->xcode(desc, elem);
948 if (err)
949 goto out;
950 copied = 0;
951 }
952 }
953 }
954 if (avail_here) {
955 kunmap(*ppages);
956 ppages++;
957 c = kmap(*ppages);
958 }
959
960 avail_page = min(avail_here,
961 (unsigned int) PAGE_CACHE_SIZE);
962 }
963 base = buf->page_len; /* align to start of tail */
964 }
965
966 /* process tail */
967 base -= buf->page_len;
968 if (todo) {
969 c = buf->tail->iov_base + base;
970 if (copied) {
971 unsigned int l = desc->elem_size - copied;
972
973 if (encode)
974 memcpy(c, elem + copied, l);
975 else {
976 memcpy(elem + copied, c, l);
977 err = desc->xcode(desc, elem);
978 if (err)
979 goto out;
980 }
981 todo -= l;
982 c += l;
983 }
984 while (todo) {
985 err = desc->xcode(desc, c);
986 if (err)
987 goto out;
988 c += desc->elem_size;
989 todo -= desc->elem_size;
990 }
991 }
992 err = 0;
993
994out:
Jesper Juhla51482b2005-11-08 09:41:34 -0800995 kfree(elem);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000996 if (ppages)
997 kunmap(*ppages);
998 return err;
999}
1000
1001int
1002xdr_decode_array2(struct xdr_buf *buf, unsigned int base,
1003 struct xdr_array2_desc *desc)
1004{
1005 if (base >= buf->len)
1006 return -EINVAL;
1007
1008 return xdr_xcode_array2(buf, base, desc, 0);
1009}
1010
1011int
1012xdr_encode_array2(struct xdr_buf *buf, unsigned int base,
1013 struct xdr_array2_desc *desc)
1014{
1015 if ((unsigned long) base + 4 + desc->array_len * desc->elem_size >
1016 buf->head->iov_len + buf->page_len + buf->tail->iov_len)
1017 return -EINVAL;
1018
1019 return xdr_xcode_array2(buf, base, desc, 1);
1020}