blob: 54264062ea695d59f85da1d712f53cd0ff45952a [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 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -070021__be32 *
22xdr_encode_netobj(__be32 *p, const struct xdr_netobj *obj)
Linus Torvalds1da177e2005-04-16 15:20:36 -070023{
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}
Trond Myklebusta6eaf8b2007-07-14 15:39:58 -040031EXPORT_SYMBOL(xdr_encode_netobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Alexey Dobriyand8ed0292006-09-26 22:29:38 -070033__be32 *
34xdr_decode_netobj(__be32 *p, struct xdr_netobj *obj)
Linus Torvalds1da177e2005-04-16 15:20:36 -070035{
36 unsigned int len;
37
38 if ((len = ntohl(*p++)) > XDR_MAX_NETOBJ)
39 return NULL;
40 obj->len = len;
41 obj->data = (u8 *) p;
42 return p + XDR_QUADLEN(len);
43}
Trond Myklebusta6eaf8b2007-07-14 15:39:58 -040044EXPORT_SYMBOL(xdr_decode_netobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
46/**
47 * xdr_encode_opaque_fixed - Encode fixed length opaque data
Pavel Pisa4dc3b162005-05-01 08:59:25 -070048 * @p: pointer to current position in XDR buffer.
49 * @ptr: pointer to data to encode (or NULL)
50 * @nbytes: size of data.
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 *
52 * Copy the array of data of length nbytes at ptr to the XDR buffer
53 * at position p, then align to the next 32-bit boundary by padding
54 * with zero bytes (see RFC1832).
55 * Note: if ptr is NULL, only the padding is performed.
56 *
57 * Returns the updated current XDR buffer position
58 *
59 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -070060__be32 *xdr_encode_opaque_fixed(__be32 *p, const void *ptr, unsigned int nbytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -070061{
62 if (likely(nbytes != 0)) {
63 unsigned int quadlen = XDR_QUADLEN(nbytes);
64 unsigned int padding = (quadlen << 2) - nbytes;
65
66 if (ptr != NULL)
67 memcpy(p, ptr, nbytes);
68 if (padding != 0)
69 memset((char *)p + nbytes, 0, padding);
70 p += quadlen;
71 }
72 return p;
73}
74EXPORT_SYMBOL(xdr_encode_opaque_fixed);
75
76/**
77 * xdr_encode_opaque - Encode variable length opaque data
Pavel Pisa4dc3b162005-05-01 08:59:25 -070078 * @p: pointer to current position in XDR buffer.
79 * @ptr: pointer to data to encode (or NULL)
80 * @nbytes: size of data.
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 *
82 * Returns the updated current XDR buffer position
83 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -070084__be32 *xdr_encode_opaque(__be32 *p, const void *ptr, unsigned int nbytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -070085{
86 *p++ = htonl(nbytes);
87 return xdr_encode_opaque_fixed(p, ptr, nbytes);
88}
89EXPORT_SYMBOL(xdr_encode_opaque);
90
Alexey Dobriyand8ed0292006-09-26 22:29:38 -070091__be32 *
92xdr_encode_string(__be32 *p, const char *string)
Linus Torvalds1da177e2005-04-16 15:20:36 -070093{
94 return xdr_encode_array(p, string, strlen(string));
95}
Trond Myklebusta6eaf8b2007-07-14 15:39:58 -040096EXPORT_SYMBOL(xdr_encode_string);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
Alexey Dobriyand8ed0292006-09-26 22:29:38 -070098__be32 *
99xdr_decode_string_inplace(__be32 *p, char **sp, int *lenp, int maxlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100{
101 unsigned int len;
102
103 if ((len = ntohl(*p++)) > maxlen)
104 return NULL;
105 *lenp = len;
106 *sp = (char *) p;
107 return p + XDR_QUADLEN(len);
108}
Trond Myklebusta6eaf8b2007-07-14 15:39:58 -0400109EXPORT_SYMBOL(xdr_decode_string_inplace);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
111void
112xdr_encode_pages(struct xdr_buf *xdr, struct page **pages, unsigned int base,
113 unsigned int len)
114{
115 struct kvec *tail = xdr->tail;
116 u32 *p;
117
118 xdr->pages = pages;
119 xdr->page_base = base;
120 xdr->page_len = len;
121
122 p = (u32 *)xdr->head[0].iov_base + XDR_QUADLEN(xdr->head[0].iov_len);
123 tail->iov_base = p;
124 tail->iov_len = 0;
125
126 if (len & 3) {
127 unsigned int pad = 4 - (len & 3);
128
129 *p = 0;
130 tail->iov_base = (char *)p + (len & 3);
131 tail->iov_len = pad;
132 len += pad;
133 }
134 xdr->buflen += len;
135 xdr->len += len;
136}
Trond Myklebusta6eaf8b2007-07-14 15:39:58 -0400137EXPORT_SYMBOL(xdr_encode_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
139void
140xdr_inline_pages(struct xdr_buf *xdr, unsigned int offset,
141 struct page **pages, unsigned int base, unsigned int len)
142{
143 struct kvec *head = xdr->head;
144 struct kvec *tail = xdr->tail;
145 char *buf = (char *)head->iov_base;
146 unsigned int buflen = head->iov_len;
147
148 head->iov_len = offset;
149
150 xdr->pages = pages;
151 xdr->page_base = base;
152 xdr->page_len = len;
153
154 tail->iov_base = buf + offset;
155 tail->iov_len = buflen - offset;
156
157 xdr->buflen += len;
158}
Trond Myklebusta6eaf8b2007-07-14 15:39:58 -0400159EXPORT_SYMBOL(xdr_inline_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161/*
162 * Helper routines for doing 'memmove' like operations on a struct xdr_buf
163 *
164 * _shift_data_right_pages
165 * @pages: vector of pages containing both the source and dest memory area.
166 * @pgto_base: page vector address of destination
167 * @pgfrom_base: page vector address of source
168 * @len: number of bytes to copy
169 *
170 * Note: the addresses pgto_base and pgfrom_base are both calculated in
171 * the same way:
172 * if a memory area starts at byte 'base' in page 'pages[i]',
173 * then its address is given as (i << PAGE_CACHE_SHIFT) + base
174 * Also note: pgfrom_base must be < pgto_base, but the memory areas
175 * they point to may overlap.
176 */
177static void
178_shift_data_right_pages(struct page **pages, size_t pgto_base,
179 size_t pgfrom_base, size_t len)
180{
181 struct page **pgfrom, **pgto;
182 char *vfrom, *vto;
183 size_t copy;
184
185 BUG_ON(pgto_base <= pgfrom_base);
186
187 pgto_base += len;
188 pgfrom_base += len;
189
190 pgto = pages + (pgto_base >> PAGE_CACHE_SHIFT);
191 pgfrom = pages + (pgfrom_base >> PAGE_CACHE_SHIFT);
192
193 pgto_base &= ~PAGE_CACHE_MASK;
194 pgfrom_base &= ~PAGE_CACHE_MASK;
195
196 do {
197 /* Are any pointers crossing a page boundary? */
198 if (pgto_base == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 pgto_base = PAGE_CACHE_SIZE;
200 pgto--;
201 }
202 if (pgfrom_base == 0) {
203 pgfrom_base = PAGE_CACHE_SIZE;
204 pgfrom--;
205 }
206
207 copy = len;
208 if (copy > pgto_base)
209 copy = pgto_base;
210 if (copy > pgfrom_base)
211 copy = pgfrom_base;
212 pgto_base -= copy;
213 pgfrom_base -= copy;
214
215 vto = kmap_atomic(*pgto, KM_USER0);
216 vfrom = kmap_atomic(*pgfrom, KM_USER1);
217 memmove(vto + pgto_base, vfrom + pgfrom_base, copy);
Trond Myklebustbce34812006-07-05 13:17:12 -0400218 flush_dcache_page(*pgto);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 kunmap_atomic(vfrom, KM_USER1);
220 kunmap_atomic(vto, KM_USER0);
221
222 } while ((len -= copy) != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223}
224
225/*
226 * _copy_to_pages
227 * @pages: array of pages
228 * @pgbase: page vector address of destination
229 * @p: pointer to source data
230 * @len: length
231 *
232 * Copies data from an arbitrary memory location into an array of pages
233 * The copy is assumed to be non-overlapping.
234 */
235static void
236_copy_to_pages(struct page **pages, size_t pgbase, const char *p, size_t len)
237{
238 struct page **pgto;
239 char *vto;
240 size_t copy;
241
242 pgto = pages + (pgbase >> PAGE_CACHE_SHIFT);
243 pgbase &= ~PAGE_CACHE_MASK;
244
245 do {
246 copy = PAGE_CACHE_SIZE - pgbase;
247 if (copy > len)
248 copy = len;
249
250 vto = kmap_atomic(*pgto, KM_USER0);
251 memcpy(vto + pgbase, p, copy);
252 kunmap_atomic(vto, KM_USER0);
253
254 pgbase += copy;
255 if (pgbase == PAGE_CACHE_SIZE) {
256 flush_dcache_page(*pgto);
257 pgbase = 0;
258 pgto++;
259 }
260 p += copy;
261
262 } while ((len -= copy) != 0);
263 flush_dcache_page(*pgto);
264}
265
266/*
267 * _copy_from_pages
268 * @p: pointer to destination
269 * @pages: array of pages
270 * @pgbase: offset of source data
271 * @len: length
272 *
273 * Copies data into an arbitrary memory location from an array of pages
274 * The copy is assumed to be non-overlapping.
275 */
276static void
277_copy_from_pages(char *p, struct page **pages, size_t pgbase, size_t len)
278{
279 struct page **pgfrom;
280 char *vfrom;
281 size_t copy;
282
283 pgfrom = pages + (pgbase >> PAGE_CACHE_SHIFT);
284 pgbase &= ~PAGE_CACHE_MASK;
285
286 do {
287 copy = PAGE_CACHE_SIZE - pgbase;
288 if (copy > len)
289 copy = len;
290
291 vfrom = kmap_atomic(*pgfrom, KM_USER0);
292 memcpy(p, vfrom + pgbase, copy);
293 kunmap_atomic(vfrom, KM_USER0);
294
295 pgbase += copy;
296 if (pgbase == PAGE_CACHE_SIZE) {
297 pgbase = 0;
298 pgfrom++;
299 }
300 p += copy;
301
302 } while ((len -= copy) != 0);
303}
304
305/*
306 * xdr_shrink_bufhead
307 * @buf: xdr_buf
308 * @len: bytes to remove from buf->head[0]
309 *
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800310 * Shrinks XDR buffer's header kvec buf->head[0] by
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 * 'len' bytes. The extra data is not lost, but is instead
312 * moved into the inlined pages and/or the tail.
313 */
314static void
315xdr_shrink_bufhead(struct xdr_buf *buf, size_t len)
316{
317 struct kvec *head, *tail;
318 size_t copy, offs;
319 unsigned int pglen = buf->page_len;
320
321 tail = buf->tail;
322 head = buf->head;
323 BUG_ON (len > head->iov_len);
324
325 /* Shift the tail first */
326 if (tail->iov_len != 0) {
327 if (tail->iov_len > len) {
328 copy = tail->iov_len - len;
329 memmove((char *)tail->iov_base + len,
330 tail->iov_base, copy);
331 }
332 /* Copy from the inlined pages into the tail */
333 copy = len;
334 if (copy > pglen)
335 copy = pglen;
336 offs = len - copy;
337 if (offs >= tail->iov_len)
338 copy = 0;
339 else if (copy > tail->iov_len - offs)
340 copy = tail->iov_len - offs;
341 if (copy != 0)
342 _copy_from_pages((char *)tail->iov_base + offs,
343 buf->pages,
344 buf->page_base + pglen + offs - len,
345 copy);
346 /* Do we also need to copy data from the head into the tail ? */
347 if (len > pglen) {
348 offs = copy = len - pglen;
349 if (copy > tail->iov_len)
350 copy = tail->iov_len;
351 memcpy(tail->iov_base,
352 (char *)head->iov_base +
353 head->iov_len - offs,
354 copy);
355 }
356 }
357 /* Now handle pages */
358 if (pglen != 0) {
359 if (pglen > len)
360 _shift_data_right_pages(buf->pages,
361 buf->page_base + len,
362 buf->page_base,
363 pglen - len);
364 copy = len;
365 if (len > pglen)
366 copy = pglen;
367 _copy_to_pages(buf->pages, buf->page_base,
368 (char *)head->iov_base + head->iov_len - len,
369 copy);
370 }
371 head->iov_len -= len;
372 buf->buflen -= len;
373 /* Have we truncated the message? */
374 if (buf->len > buf->buflen)
375 buf->len = buf->buflen;
376}
377
378/*
379 * xdr_shrink_pagelen
380 * @buf: xdr_buf
381 * @len: bytes to remove from buf->pages
382 *
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800383 * Shrinks XDR buffer's page array buf->pages by
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 * 'len' bytes. The extra data is not lost, but is instead
385 * moved into the tail.
386 */
387static void
388xdr_shrink_pagelen(struct xdr_buf *buf, size_t len)
389{
390 struct kvec *tail;
391 size_t copy;
392 char *p;
393 unsigned int pglen = buf->page_len;
394
395 tail = buf->tail;
396 BUG_ON (len > pglen);
397
398 /* Shift the tail first */
399 if (tail->iov_len != 0) {
400 p = (char *)tail->iov_base + len;
401 if (tail->iov_len > len) {
402 copy = tail->iov_len - len;
403 memmove(p, tail->iov_base, copy);
404 } else
405 buf->buflen -= len;
406 /* Copy from the inlined pages into the tail */
407 copy = len;
408 if (copy > tail->iov_len)
409 copy = tail->iov_len;
410 _copy_from_pages((char *)tail->iov_base,
411 buf->pages, buf->page_base + pglen - len,
412 copy);
413 }
414 buf->page_len -= len;
415 buf->buflen -= len;
416 /* Have we truncated the message? */
417 if (buf->len > buf->buflen)
418 buf->len = buf->buflen;
419}
420
421void
422xdr_shift_buf(struct xdr_buf *buf, size_t len)
423{
424 xdr_shrink_bufhead(buf, len);
425}
Trond Myklebusta6eaf8b2007-07-14 15:39:58 -0400426EXPORT_SYMBOL(xdr_shift_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427
428/**
429 * xdr_init_encode - Initialize a struct xdr_stream for sending data.
430 * @xdr: pointer to xdr_stream struct
431 * @buf: pointer to XDR buffer in which to encode data
432 * @p: current pointer inside XDR buffer
433 *
434 * Note: at the moment the RPC client only passes the length of our
435 * scratch buffer in the xdr_buf's header kvec. Previously this
436 * meant we needed to call xdr_adjust_iovec() after encoding the
437 * data. With the new scheme, the xdr_stream manages the details
438 * of the buffer length, and takes care of adjusting the kvec
439 * length for us.
440 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700441void xdr_init_encode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442{
443 struct kvec *iov = buf->head;
Trond Myklebust334ccfd2005-06-22 17:16:19 +0000444 int scratch_len = buf->buflen - buf->page_len - buf->tail[0].iov_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445
Trond Myklebust334ccfd2005-06-22 17:16:19 +0000446 BUG_ON(scratch_len < 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 xdr->buf = buf;
448 xdr->iov = iov;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700449 xdr->p = (__be32 *)((char *)iov->iov_base + iov->iov_len);
450 xdr->end = (__be32 *)((char *)iov->iov_base + scratch_len);
Trond Myklebust334ccfd2005-06-22 17:16:19 +0000451 BUG_ON(iov->iov_len > scratch_len);
452
453 if (p != xdr->p && p != NULL) {
454 size_t len;
455
456 BUG_ON(p < xdr->p || p > xdr->end);
457 len = (char *)p - (char *)xdr->p;
458 xdr->p = p;
459 buf->len += len;
460 iov->iov_len += len;
461 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462}
463EXPORT_SYMBOL(xdr_init_encode);
464
465/**
466 * xdr_reserve_space - Reserve buffer space for sending
467 * @xdr: pointer to xdr_stream
468 * @nbytes: number of bytes to reserve
469 *
470 * Checks that we have enough buffer space to encode 'nbytes' more
471 * bytes of data. If so, update the total xdr_buf length, and
472 * adjust the length of the current kvec.
473 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700474__be32 * xdr_reserve_space(struct xdr_stream *xdr, size_t nbytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475{
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700476 __be32 *p = xdr->p;
477 __be32 *q;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478
479 /* align nbytes on the next 32-bit boundary */
480 nbytes += 3;
481 nbytes &= ~3;
482 q = p + (nbytes >> 2);
483 if (unlikely(q > xdr->end || q < p))
484 return NULL;
485 xdr->p = q;
486 xdr->iov->iov_len += nbytes;
487 xdr->buf->len += nbytes;
488 return p;
489}
490EXPORT_SYMBOL(xdr_reserve_space);
491
492/**
493 * xdr_write_pages - Insert a list of pages into an XDR buffer for sending
494 * @xdr: pointer to xdr_stream
495 * @pages: list of pages
496 * @base: offset of first byte
497 * @len: length of data in bytes
498 *
499 */
500void xdr_write_pages(struct xdr_stream *xdr, struct page **pages, unsigned int base,
501 unsigned int len)
502{
503 struct xdr_buf *buf = xdr->buf;
504 struct kvec *iov = buf->tail;
505 buf->pages = pages;
506 buf->page_base = base;
507 buf->page_len = len;
508
509 iov->iov_base = (char *)xdr->p;
510 iov->iov_len = 0;
511 xdr->iov = iov;
512
513 if (len & 3) {
514 unsigned int pad = 4 - (len & 3);
515
516 BUG_ON(xdr->p >= xdr->end);
517 iov->iov_base = (char *)xdr->p + (len & 3);
518 iov->iov_len += pad;
519 len += pad;
520 *xdr->p++ = 0;
521 }
522 buf->buflen += len;
523 buf->len += len;
524}
525EXPORT_SYMBOL(xdr_write_pages);
526
527/**
528 * xdr_init_decode - Initialize an xdr_stream for decoding data.
529 * @xdr: pointer to xdr_stream struct
530 * @buf: pointer to XDR buffer from which to decode data
531 * @p: current pointer inside XDR buffer
532 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700533void xdr_init_decode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534{
535 struct kvec *iov = buf->head;
536 unsigned int len = iov->iov_len;
537
538 if (len > buf->len)
539 len = buf->len;
540 xdr->buf = buf;
541 xdr->iov = iov;
542 xdr->p = p;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700543 xdr->end = (__be32 *)((char *)iov->iov_base + len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544}
545EXPORT_SYMBOL(xdr_init_decode);
546
547/**
548 * xdr_inline_decode - Retrieve non-page XDR data to decode
549 * @xdr: pointer to xdr_stream struct
550 * @nbytes: number of bytes of data to decode
551 *
552 * Check if the input buffer is long enough to enable us to decode
553 * 'nbytes' more bytes of data starting at the current position.
554 * If so return the current pointer, then update the current
555 * pointer position.
556 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700557__be32 * xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558{
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700559 __be32 *p = xdr->p;
560 __be32 *q = p + XDR_QUADLEN(nbytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
562 if (unlikely(q > xdr->end || q < p))
563 return NULL;
564 xdr->p = q;
565 return p;
566}
567EXPORT_SYMBOL(xdr_inline_decode);
568
569/**
570 * xdr_read_pages - Ensure page-based XDR data to decode is aligned at current pointer position
571 * @xdr: pointer to xdr_stream struct
572 * @len: number of bytes of page data
573 *
574 * Moves data beyond the current pointer position from the XDR head[] buffer
575 * into the page list. Any data that lies beyond current position + "len"
Trond Myklebust8b23ea72006-06-09 09:34:21 -0400576 * bytes is moved into the XDR tail[].
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 */
578void xdr_read_pages(struct xdr_stream *xdr, unsigned int len)
579{
580 struct xdr_buf *buf = xdr->buf;
581 struct kvec *iov;
582 ssize_t shift;
583 unsigned int end;
584 int padding;
585
586 /* Realign pages to current pointer position */
587 iov = buf->head;
588 shift = iov->iov_len + (char *)iov->iov_base - (char *)xdr->p;
589 if (shift > 0)
590 xdr_shrink_bufhead(buf, shift);
591
592 /* Truncate page data and move it into the tail */
593 if (buf->page_len > len)
594 xdr_shrink_pagelen(buf, buf->page_len - len);
595 padding = (XDR_QUADLEN(len) << 2) - len;
596 xdr->iov = iov = buf->tail;
597 /* Compute remaining message length. */
598 end = iov->iov_len;
599 shift = buf->buflen - buf->len;
600 if (shift < end)
601 end -= shift;
602 else if (shift > 0)
603 end = 0;
604 /*
605 * Position current pointer at beginning of tail, and
606 * set remaining message length.
607 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700608 xdr->p = (__be32 *)((char *)iov->iov_base + padding);
609 xdr->end = (__be32 *)((char *)iov->iov_base + end);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610}
611EXPORT_SYMBOL(xdr_read_pages);
612
Trond Myklebust8b23ea72006-06-09 09:34:21 -0400613/**
614 * xdr_enter_page - decode data from the XDR page
615 * @xdr: pointer to xdr_stream struct
616 * @len: number of bytes of page data
617 *
618 * Moves data beyond the current pointer position from the XDR head[] buffer
619 * into the page list. Any data that lies beyond current position + "len"
620 * bytes is moved into the XDR tail[]. The current pointer is then
621 * repositioned at the beginning of the first XDR page.
622 */
623void xdr_enter_page(struct xdr_stream *xdr, unsigned int len)
624{
625 char * kaddr = page_address(xdr->buf->pages[0]);
626 xdr_read_pages(xdr, len);
627 /*
628 * Position current pointer at beginning of tail, and
629 * set remaining message length.
630 */
631 if (len > PAGE_CACHE_SIZE - xdr->buf->page_base)
632 len = PAGE_CACHE_SIZE - xdr->buf->page_base;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700633 xdr->p = (__be32 *)(kaddr + xdr->buf->page_base);
634 xdr->end = (__be32 *)((char *)xdr->p + len);
Trond Myklebust8b23ea72006-06-09 09:34:21 -0400635}
636EXPORT_SYMBOL(xdr_enter_page);
637
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638static struct kvec empty_iov = {.iov_base = NULL, .iov_len = 0};
639
640void
641xdr_buf_from_iov(struct kvec *iov, struct xdr_buf *buf)
642{
643 buf->head[0] = *iov;
644 buf->tail[0] = empty_iov;
645 buf->page_len = 0;
646 buf->buflen = buf->len = iov->iov_len;
647}
Trond Myklebusta6eaf8b2007-07-14 15:39:58 -0400648EXPORT_SYMBOL(xdr_buf_from_iov);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650/* Sets subbuf to the portion of buf of length len beginning base bytes
651 * from the start of buf. Returns -1 if base of length are out of bounds. */
652int
653xdr_buf_subsegment(struct xdr_buf *buf, struct xdr_buf *subbuf,
Trond Myklebust1e789572006-08-31 15:09:19 -0400654 unsigned int base, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 subbuf->buflen = subbuf->len = len;
Trond Myklebust1e789572006-08-31 15:09:19 -0400657 if (base < buf->head[0].iov_len) {
658 subbuf->head[0].iov_base = buf->head[0].iov_base + base;
659 subbuf->head[0].iov_len = min_t(unsigned int, len,
660 buf->head[0].iov_len - base);
661 len -= subbuf->head[0].iov_len;
662 base = 0;
663 } else {
664 subbuf->head[0].iov_base = NULL;
665 subbuf->head[0].iov_len = 0;
666 base -= buf->head[0].iov_len;
667 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668
669 if (base < buf->page_len) {
Trond Myklebust1e789572006-08-31 15:09:19 -0400670 subbuf->page_len = min(buf->page_len - base, len);
671 base += buf->page_base;
672 subbuf->page_base = base & ~PAGE_CACHE_MASK;
673 subbuf->pages = &buf->pages[base >> PAGE_CACHE_SHIFT];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 len -= subbuf->page_len;
675 base = 0;
676 } else {
677 base -= buf->page_len;
678 subbuf->page_len = 0;
679 }
680
Trond Myklebust1e789572006-08-31 15:09:19 -0400681 if (base < buf->tail[0].iov_len) {
682 subbuf->tail[0].iov_base = buf->tail[0].iov_base + base;
683 subbuf->tail[0].iov_len = min_t(unsigned int, len,
684 buf->tail[0].iov_len - base);
685 len -= subbuf->tail[0].iov_len;
686 base = 0;
687 } else {
688 subbuf->tail[0].iov_base = NULL;
689 subbuf->tail[0].iov_len = 0;
690 base -= buf->tail[0].iov_len;
691 }
692
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 if (base || len)
694 return -1;
695 return 0;
696}
Trond Myklebusta6eaf8b2007-07-14 15:39:58 -0400697EXPORT_SYMBOL(xdr_buf_subsegment);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400699static void __read_bytes_from_xdr_buf(struct xdr_buf *subbuf, void *obj, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700{
Trond Myklebust1e789572006-08-31 15:09:19 -0400701 unsigned int this_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400703 this_len = min_t(unsigned int, len, subbuf->head[0].iov_len);
704 memcpy(obj, subbuf->head[0].iov_base, this_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 len -= this_len;
706 obj += this_len;
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400707 this_len = min_t(unsigned int, len, subbuf->page_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 if (this_len)
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400709 _copy_from_pages(obj, subbuf->pages, subbuf->page_base, this_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 len -= this_len;
711 obj += this_len;
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400712 this_len = min_t(unsigned int, len, subbuf->tail[0].iov_len);
713 memcpy(obj, subbuf->tail[0].iov_base, this_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714}
715
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000716/* obj is assumed to point to allocated memory of size at least len: */
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400717int read_bytes_from_xdr_buf(struct xdr_buf *buf, unsigned int base, void *obj, unsigned int len)
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000718{
719 struct xdr_buf subbuf;
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000720 int status;
721
722 status = xdr_buf_subsegment(buf, &subbuf, base, len);
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400723 if (status != 0)
724 return status;
725 __read_bytes_from_xdr_buf(&subbuf, obj, len);
726 return 0;
727}
Trond Myklebusta6eaf8b2007-07-14 15:39:58 -0400728EXPORT_SYMBOL(read_bytes_from_xdr_buf);
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400729
730static void __write_bytes_to_xdr_buf(struct xdr_buf *subbuf, void *obj, unsigned int len)
731{
732 unsigned int this_len;
733
734 this_len = min_t(unsigned int, len, subbuf->head[0].iov_len);
735 memcpy(subbuf->head[0].iov_base, obj, this_len);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000736 len -= this_len;
737 obj += this_len;
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400738 this_len = min_t(unsigned int, len, subbuf->page_len);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000739 if (this_len)
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400740 _copy_to_pages(subbuf->pages, subbuf->page_base, obj, this_len);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000741 len -= this_len;
742 obj += this_len;
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400743 this_len = min_t(unsigned int, len, subbuf->tail[0].iov_len);
744 memcpy(subbuf->tail[0].iov_base, obj, this_len);
745}
746
747/* obj is assumed to point to allocated memory of size at least len: */
748int write_bytes_to_xdr_buf(struct xdr_buf *buf, unsigned int base, void *obj, unsigned int len)
749{
750 struct xdr_buf subbuf;
751 int status;
752
753 status = xdr_buf_subsegment(buf, &subbuf, base, len);
754 if (status != 0)
755 return status;
756 __write_bytes_to_xdr_buf(&subbuf, obj, len);
757 return 0;
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000758}
759
760int
Trond Myklebust1e789572006-08-31 15:09:19 -0400761xdr_decode_word(struct xdr_buf *buf, unsigned int base, u32 *obj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762{
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700763 __be32 raw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 int status;
765
766 status = read_bytes_from_xdr_buf(buf, base, &raw, sizeof(*obj));
767 if (status)
768 return status;
769 *obj = ntohl(raw);
770 return 0;
771}
Trond Myklebusta6eaf8b2007-07-14 15:39:58 -0400772EXPORT_SYMBOL(xdr_decode_word);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000774int
Trond Myklebust1e789572006-08-31 15:09:19 -0400775xdr_encode_word(struct xdr_buf *buf, unsigned int base, u32 obj)
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000776{
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700777 __be32 raw = htonl(obj);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000778
779 return write_bytes_to_xdr_buf(buf, base, &raw, sizeof(obj));
780}
Trond Myklebusta6eaf8b2007-07-14 15:39:58 -0400781EXPORT_SYMBOL(xdr_encode_word);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000782
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783/* If the netobj starting offset bytes from the start of xdr_buf is contained
784 * entirely in the head or the tail, set object to point to it; otherwise
785 * try to find space for it at the end of the tail, copy it there, and
786 * set obj to point to it. */
Trond Myklebustbee57c92006-10-09 22:08:22 -0400787int xdr_buf_read_netobj(struct xdr_buf *buf, struct xdr_netobj *obj, unsigned int offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788{
Trond Myklebustbee57c92006-10-09 22:08:22 -0400789 struct xdr_buf subbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000791 if (xdr_decode_word(buf, offset, &obj->len))
Trond Myklebustbee57c92006-10-09 22:08:22 -0400792 return -EFAULT;
793 if (xdr_buf_subsegment(buf, &subbuf, offset + 4, obj->len))
794 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795
Trond Myklebustbee57c92006-10-09 22:08:22 -0400796 /* Is the obj contained entirely in the head? */
797 obj->data = subbuf.head[0].iov_base;
798 if (subbuf.head[0].iov_len == obj->len)
799 return 0;
800 /* ..or is the obj contained entirely in the tail? */
801 obj->data = subbuf.tail[0].iov_base;
802 if (subbuf.tail[0].iov_len == obj->len)
803 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
Trond Myklebustbee57c92006-10-09 22:08:22 -0400805 /* use end of tail as storage for obj:
806 * (We don't copy to the beginning because then we'd have
807 * to worry about doing a potentially overlapping copy.
808 * This assumes the object is at most half the length of the
809 * tail.) */
810 if (obj->len > buf->buflen - buf->len)
811 return -ENOMEM;
812 if (buf->tail[0].iov_len != 0)
813 obj->data = buf->tail[0].iov_base + buf->tail[0].iov_len;
814 else
815 obj->data = buf->head[0].iov_base + buf->head[0].iov_len;
816 __read_bytes_from_xdr_buf(&subbuf, obj->data, obj->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818}
Trond Myklebusta6eaf8b2007-07-14 15:39:58 -0400819EXPORT_SYMBOL(xdr_buf_read_netobj);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000820
821/* Returns 0 on success, or else a negative error code. */
822static int
823xdr_xcode_array2(struct xdr_buf *buf, unsigned int base,
824 struct xdr_array2_desc *desc, int encode)
825{
826 char *elem = NULL, *c;
827 unsigned int copied = 0, todo, avail_here;
828 struct page **ppages = NULL;
829 int err;
830
831 if (encode) {
832 if (xdr_encode_word(buf, base, desc->array_len) != 0)
833 return -EINVAL;
834 } else {
835 if (xdr_decode_word(buf, base, &desc->array_len) != 0 ||
Trond Myklebust58fcb8d2005-08-10 18:15:12 -0400836 desc->array_len > desc->array_maxlen ||
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000837 (unsigned long) base + 4 + desc->array_len *
838 desc->elem_size > buf->len)
839 return -EINVAL;
840 }
841 base += 4;
842
843 if (!desc->xcode)
844 return 0;
845
846 todo = desc->array_len * desc->elem_size;
847
848 /* process head */
849 if (todo && base < buf->head->iov_len) {
850 c = buf->head->iov_base + base;
851 avail_here = min_t(unsigned int, todo,
852 buf->head->iov_len - base);
853 todo -= avail_here;
854
855 while (avail_here >= desc->elem_size) {
856 err = desc->xcode(desc, c);
857 if (err)
858 goto out;
859 c += desc->elem_size;
860 avail_here -= desc->elem_size;
861 }
862 if (avail_here) {
863 if (!elem) {
864 elem = kmalloc(desc->elem_size, GFP_KERNEL);
865 err = -ENOMEM;
866 if (!elem)
867 goto out;
868 }
869 if (encode) {
870 err = desc->xcode(desc, elem);
871 if (err)
872 goto out;
873 memcpy(c, elem, avail_here);
874 } else
875 memcpy(elem, c, avail_here);
876 copied = avail_here;
877 }
878 base = buf->head->iov_len; /* align to start of pages */
879 }
880
881 /* process pages array */
882 base -= buf->head->iov_len;
883 if (todo && base < buf->page_len) {
884 unsigned int avail_page;
885
886 avail_here = min(todo, buf->page_len - base);
887 todo -= avail_here;
888
889 base += buf->page_base;
890 ppages = buf->pages + (base >> PAGE_CACHE_SHIFT);
891 base &= ~PAGE_CACHE_MASK;
892 avail_page = min_t(unsigned int, PAGE_CACHE_SIZE - base,
893 avail_here);
894 c = kmap(*ppages) + base;
895
896 while (avail_here) {
897 avail_here -= avail_page;
898 if (copied || avail_page < desc->elem_size) {
899 unsigned int l = min(avail_page,
900 desc->elem_size - copied);
901 if (!elem) {
902 elem = kmalloc(desc->elem_size,
903 GFP_KERNEL);
904 err = -ENOMEM;
905 if (!elem)
906 goto out;
907 }
908 if (encode) {
909 if (!copied) {
910 err = desc->xcode(desc, elem);
911 if (err)
912 goto out;
913 }
914 memcpy(c, elem + copied, l);
915 copied += l;
916 if (copied == desc->elem_size)
917 copied = 0;
918 } else {
919 memcpy(elem + copied, c, l);
920 copied += l;
921 if (copied == desc->elem_size) {
922 err = desc->xcode(desc, elem);
923 if (err)
924 goto out;
925 copied = 0;
926 }
927 }
928 avail_page -= l;
929 c += l;
930 }
931 while (avail_page >= desc->elem_size) {
932 err = desc->xcode(desc, c);
933 if (err)
934 goto out;
935 c += desc->elem_size;
936 avail_page -= desc->elem_size;
937 }
938 if (avail_page) {
939 unsigned int l = min(avail_page,
940 desc->elem_size - copied);
941 if (!elem) {
942 elem = kmalloc(desc->elem_size,
943 GFP_KERNEL);
944 err = -ENOMEM;
945 if (!elem)
946 goto out;
947 }
948 if (encode) {
949 if (!copied) {
950 err = desc->xcode(desc, elem);
951 if (err)
952 goto out;
953 }
954 memcpy(c, elem + copied, l);
955 copied += l;
956 if (copied == desc->elem_size)
957 copied = 0;
958 } else {
959 memcpy(elem + copied, c, l);
960 copied += l;
961 if (copied == desc->elem_size) {
962 err = desc->xcode(desc, elem);
963 if (err)
964 goto out;
965 copied = 0;
966 }
967 }
968 }
969 if (avail_here) {
970 kunmap(*ppages);
971 ppages++;
972 c = kmap(*ppages);
973 }
974
975 avail_page = min(avail_here,
976 (unsigned int) PAGE_CACHE_SIZE);
977 }
978 base = buf->page_len; /* align to start of tail */
979 }
980
981 /* process tail */
982 base -= buf->page_len;
983 if (todo) {
984 c = buf->tail->iov_base + base;
985 if (copied) {
986 unsigned int l = desc->elem_size - copied;
987
988 if (encode)
989 memcpy(c, elem + copied, l);
990 else {
991 memcpy(elem + copied, c, l);
992 err = desc->xcode(desc, elem);
993 if (err)
994 goto out;
995 }
996 todo -= l;
997 c += l;
998 }
999 while (todo) {
1000 err = desc->xcode(desc, c);
1001 if (err)
1002 goto out;
1003 c += desc->elem_size;
1004 todo -= desc->elem_size;
1005 }
1006 }
1007 err = 0;
1008
1009out:
Jesper Juhla51482b2005-11-08 09:41:34 -08001010 kfree(elem);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +00001011 if (ppages)
1012 kunmap(*ppages);
1013 return err;
1014}
1015
1016int
1017xdr_decode_array2(struct xdr_buf *buf, unsigned int base,
1018 struct xdr_array2_desc *desc)
1019{
1020 if (base >= buf->len)
1021 return -EINVAL;
1022
1023 return xdr_xcode_array2(buf, base, desc, 0);
1024}
Trond Myklebusta6eaf8b2007-07-14 15:39:58 -04001025EXPORT_SYMBOL(xdr_decode_array2);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +00001026
1027int
1028xdr_encode_array2(struct xdr_buf *buf, unsigned int base,
1029 struct xdr_array2_desc *desc)
1030{
1031 if ((unsigned long) base + 4 + desc->array_len * desc->elem_size >
1032 buf->head->iov_len + buf->page_len + buf->tail->iov_len)
1033 return -EINVAL;
1034
1035 return xdr_xcode_array2(buf, base, desc, 1);
1036}
Trond Myklebusta6eaf8b2007-07-14 15:39:58 -04001037EXPORT_SYMBOL(xdr_encode_array2);
Olga Kornievskaia37a4e6c2006-12-04 20:22:33 -05001038
1039int
1040xdr_process_buf(struct xdr_buf *buf, unsigned int offset, unsigned int len,
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -08001041 int (*actor)(struct scatterlist *, void *), void *data)
Olga Kornievskaia37a4e6c2006-12-04 20:22:33 -05001042{
1043 int i, ret = 0;
1044 unsigned page_len, thislen, page_offset;
1045 struct scatterlist sg[1];
1046
Herbert Xu68e3f5d2007-10-27 00:52:07 -07001047 sg_init_table(sg, 1);
1048
Olga Kornievskaia37a4e6c2006-12-04 20:22:33 -05001049 if (offset >= buf->head[0].iov_len) {
1050 offset -= buf->head[0].iov_len;
1051 } else {
1052 thislen = buf->head[0].iov_len - offset;
1053 if (thislen > len)
1054 thislen = len;
1055 sg_set_buf(sg, buf->head[0].iov_base + offset, thislen);
1056 ret = actor(sg, data);
1057 if (ret)
1058 goto out;
1059 offset = 0;
1060 len -= thislen;
1061 }
1062 if (len == 0)
1063 goto out;
1064
1065 if (offset >= buf->page_len) {
1066 offset -= buf->page_len;
1067 } else {
1068 page_len = buf->page_len - offset;
1069 if (page_len > len)
1070 page_len = len;
1071 len -= page_len;
1072 page_offset = (offset + buf->page_base) & (PAGE_CACHE_SIZE - 1);
1073 i = (offset + buf->page_base) >> PAGE_CACHE_SHIFT;
1074 thislen = PAGE_CACHE_SIZE - page_offset;
1075 do {
1076 if (thislen > page_len)
1077 thislen = page_len;
Jens Axboe642f1492007-10-24 11:20:47 +02001078 sg_set_page(sg, buf->pages[i], thislen, page_offset);
Olga Kornievskaia37a4e6c2006-12-04 20:22:33 -05001079 ret = actor(sg, data);
1080 if (ret)
1081 goto out;
1082 page_len -= thislen;
1083 i++;
1084 page_offset = 0;
1085 thislen = PAGE_CACHE_SIZE;
1086 } while (page_len != 0);
1087 offset = 0;
1088 }
1089 if (len == 0)
1090 goto out;
1091 if (offset < buf->tail[0].iov_len) {
1092 thislen = buf->tail[0].iov_len - offset;
1093 if (thislen > len)
1094 thislen = len;
1095 sg_set_buf(sg, buf->tail[0].iov_base + offset, thislen);
1096 ret = actor(sg, data);
1097 len -= thislen;
1098 }
1099 if (len != 0)
1100 ret = -EINVAL;
1101out:
1102 return ret;
1103}
1104EXPORT_SYMBOL(xdr_process_buf);
1105