blob: 2763fde88499866084bf4782e597ce78d1086be4 [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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090010#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/string.h>
13#include <linux/kernel.h>
14#include <linux/pagemap.h>
15#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/sunrpc/xdr.h>
17#include <linux/sunrpc/msg_prot.h>
18
19/*
20 * XDR functions for basic NFS types
21 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -070022__be32 *
23xdr_encode_netobj(__be32 *p, const struct xdr_netobj *obj)
Linus Torvalds1da177e2005-04-16 15:20:36 -070024{
25 unsigned int quadlen = XDR_QUADLEN(obj->len);
26
27 p[quadlen] = 0; /* zero trailing bytes */
Benny Halevy9f162d22009-08-14 17:18:44 +030028 *p++ = cpu_to_be32(obj->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -070029 memcpy(p, obj->data, obj->len);
30 return p + XDR_QUADLEN(obj->len);
31}
Trond Myklebust468039e2008-12-23 15:21:31 -050032EXPORT_SYMBOL_GPL(xdr_encode_netobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
Alexey Dobriyand8ed0292006-09-26 22:29:38 -070034__be32 *
35xdr_decode_netobj(__be32 *p, struct xdr_netobj *obj)
Linus Torvalds1da177e2005-04-16 15:20:36 -070036{
37 unsigned int len;
38
Benny Halevy98866b52009-08-14 17:18:49 +030039 if ((len = be32_to_cpu(*p++)) > XDR_MAX_NETOBJ)
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 return NULL;
41 obj->len = len;
42 obj->data = (u8 *) p;
43 return p + XDR_QUADLEN(len);
44}
Trond Myklebust468039e2008-12-23 15:21:31 -050045EXPORT_SYMBOL_GPL(xdr_decode_netobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
47/**
48 * xdr_encode_opaque_fixed - Encode fixed length opaque data
Pavel Pisa4dc3b162005-05-01 08:59:25 -070049 * @p: pointer to current position in XDR buffer.
50 * @ptr: pointer to data to encode (or NULL)
51 * @nbytes: size of data.
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 *
53 * Copy the array of data of length nbytes at ptr to the XDR buffer
54 * at position p, then align to the next 32-bit boundary by padding
55 * with zero bytes (see RFC1832).
56 * Note: if ptr is NULL, only the padding is performed.
57 *
58 * Returns the updated current XDR buffer position
59 *
60 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -070061__be32 *xdr_encode_opaque_fixed(__be32 *p, const void *ptr, unsigned int nbytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -070062{
63 if (likely(nbytes != 0)) {
64 unsigned int quadlen = XDR_QUADLEN(nbytes);
65 unsigned int padding = (quadlen << 2) - nbytes;
66
67 if (ptr != NULL)
68 memcpy(p, ptr, nbytes);
69 if (padding != 0)
70 memset((char *)p + nbytes, 0, padding);
71 p += quadlen;
72 }
73 return p;
74}
Trond Myklebust468039e2008-12-23 15:21:31 -050075EXPORT_SYMBOL_GPL(xdr_encode_opaque_fixed);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
77/**
78 * xdr_encode_opaque - Encode variable length opaque data
Pavel Pisa4dc3b162005-05-01 08:59:25 -070079 * @p: pointer to current position in XDR buffer.
80 * @ptr: pointer to data to encode (or NULL)
81 * @nbytes: size of data.
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 *
83 * Returns the updated current XDR buffer position
84 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -070085__be32 *xdr_encode_opaque(__be32 *p, const void *ptr, unsigned int nbytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -070086{
Benny Halevy9f162d22009-08-14 17:18:44 +030087 *p++ = cpu_to_be32(nbytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 return xdr_encode_opaque_fixed(p, ptr, nbytes);
89}
Trond Myklebust468039e2008-12-23 15:21:31 -050090EXPORT_SYMBOL_GPL(xdr_encode_opaque);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
Alexey Dobriyand8ed0292006-09-26 22:29:38 -070092__be32 *
93xdr_encode_string(__be32 *p, const char *string)
Linus Torvalds1da177e2005-04-16 15:20:36 -070094{
95 return xdr_encode_array(p, string, strlen(string));
96}
Trond Myklebust468039e2008-12-23 15:21:31 -050097EXPORT_SYMBOL_GPL(xdr_encode_string);
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
Alexey Dobriyand8ed0292006-09-26 22:29:38 -070099__be32 *
Chuck Levere5cff482007-11-01 16:56:47 -0400100xdr_decode_string_inplace(__be32 *p, char **sp,
101 unsigned int *lenp, unsigned int maxlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102{
Chuck Levere5cff482007-11-01 16:56:47 -0400103 u32 len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104
Benny Halevy98866b52009-08-14 17:18:49 +0300105 len = be32_to_cpu(*p++);
Chuck Levere5cff482007-11-01 16:56:47 -0400106 if (len > maxlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 return NULL;
108 *lenp = len;
109 *sp = (char *) p;
110 return p + XDR_QUADLEN(len);
111}
Trond Myklebust468039e2008-12-23 15:21:31 -0500112EXPORT_SYMBOL_GPL(xdr_decode_string_inplace);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113
114void
115xdr_encode_pages(struct xdr_buf *xdr, struct page **pages, unsigned int base,
116 unsigned int len)
117{
118 struct kvec *tail = xdr->tail;
119 u32 *p;
120
121 xdr->pages = pages;
122 xdr->page_base = base;
123 xdr->page_len = len;
124
125 p = (u32 *)xdr->head[0].iov_base + XDR_QUADLEN(xdr->head[0].iov_len);
126 tail->iov_base = p;
127 tail->iov_len = 0;
128
129 if (len & 3) {
130 unsigned int pad = 4 - (len & 3);
131
132 *p = 0;
133 tail->iov_base = (char *)p + (len & 3);
134 tail->iov_len = pad;
135 len += pad;
136 }
137 xdr->buflen += len;
138 xdr->len += len;
139}
Trond Myklebust468039e2008-12-23 15:21:31 -0500140EXPORT_SYMBOL_GPL(xdr_encode_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141
142void
143xdr_inline_pages(struct xdr_buf *xdr, unsigned int offset,
144 struct page **pages, unsigned int base, unsigned int len)
145{
146 struct kvec *head = xdr->head;
147 struct kvec *tail = xdr->tail;
148 char *buf = (char *)head->iov_base;
149 unsigned int buflen = head->iov_len;
150
151 head->iov_len = offset;
152
153 xdr->pages = pages;
154 xdr->page_base = base;
155 xdr->page_len = len;
156
157 tail->iov_base = buf + offset;
158 tail->iov_len = buflen - offset;
159
160 xdr->buflen += len;
161}
Trond Myklebust468039e2008-12-23 15:21:31 -0500162EXPORT_SYMBOL_GPL(xdr_inline_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164/*
165 * Helper routines for doing 'memmove' like operations on a struct xdr_buf
166 *
167 * _shift_data_right_pages
168 * @pages: vector of pages containing both the source and dest memory area.
169 * @pgto_base: page vector address of destination
170 * @pgfrom_base: page vector address of source
171 * @len: number of bytes to copy
172 *
173 * Note: the addresses pgto_base and pgfrom_base are both calculated in
174 * the same way:
175 * if a memory area starts at byte 'base' in page 'pages[i]',
176 * then its address is given as (i << PAGE_CACHE_SHIFT) + base
177 * Also note: pgfrom_base must be < pgto_base, but the memory areas
178 * they point to may overlap.
179 */
180static void
181_shift_data_right_pages(struct page **pages, size_t pgto_base,
182 size_t pgfrom_base, size_t len)
183{
184 struct page **pgfrom, **pgto;
185 char *vfrom, *vto;
186 size_t copy;
187
188 BUG_ON(pgto_base <= pgfrom_base);
189
190 pgto_base += len;
191 pgfrom_base += len;
192
193 pgto = pages + (pgto_base >> PAGE_CACHE_SHIFT);
194 pgfrom = pages + (pgfrom_base >> PAGE_CACHE_SHIFT);
195
196 pgto_base &= ~PAGE_CACHE_MASK;
197 pgfrom_base &= ~PAGE_CACHE_MASK;
198
199 do {
200 /* Are any pointers crossing a page boundary? */
201 if (pgto_base == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 pgto_base = PAGE_CACHE_SIZE;
203 pgto--;
204 }
205 if (pgfrom_base == 0) {
206 pgfrom_base = PAGE_CACHE_SIZE;
207 pgfrom--;
208 }
209
210 copy = len;
211 if (copy > pgto_base)
212 copy = pgto_base;
213 if (copy > pgfrom_base)
214 copy = pgfrom_base;
215 pgto_base -= copy;
216 pgfrom_base -= copy;
217
218 vto = kmap_atomic(*pgto, KM_USER0);
219 vfrom = kmap_atomic(*pgfrom, KM_USER1);
220 memmove(vto + pgto_base, vfrom + pgfrom_base, copy);
Trond Myklebustbce34812006-07-05 13:17:12 -0400221 flush_dcache_page(*pgto);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 kunmap_atomic(vfrom, KM_USER1);
223 kunmap_atomic(vto, KM_USER0);
224
225 } while ((len -= copy) != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226}
227
228/*
229 * _copy_to_pages
230 * @pages: array of pages
231 * @pgbase: page vector address of destination
232 * @p: pointer to source data
233 * @len: length
234 *
235 * Copies data from an arbitrary memory location into an array of pages
236 * The copy is assumed to be non-overlapping.
237 */
238static void
239_copy_to_pages(struct page **pages, size_t pgbase, const char *p, size_t len)
240{
241 struct page **pgto;
242 char *vto;
243 size_t copy;
244
245 pgto = pages + (pgbase >> PAGE_CACHE_SHIFT);
246 pgbase &= ~PAGE_CACHE_MASK;
247
Trond Myklebustdaeba892008-03-31 17:02:02 -0400248 for (;;) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 copy = PAGE_CACHE_SIZE - pgbase;
250 if (copy > len)
251 copy = len;
252
253 vto = kmap_atomic(*pgto, KM_USER0);
254 memcpy(vto + pgbase, p, copy);
255 kunmap_atomic(vto, KM_USER0);
256
Trond Myklebustdaeba892008-03-31 17:02:02 -0400257 len -= copy;
258 if (len == 0)
259 break;
260
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 pgbase += copy;
262 if (pgbase == PAGE_CACHE_SIZE) {
263 flush_dcache_page(*pgto);
264 pgbase = 0;
265 pgto++;
266 }
267 p += copy;
Trond Myklebustdaeba892008-03-31 17:02:02 -0400268 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 flush_dcache_page(*pgto);
270}
271
272/*
273 * _copy_from_pages
274 * @p: pointer to destination
275 * @pages: array of pages
276 * @pgbase: offset of source data
277 * @len: length
278 *
279 * Copies data into an arbitrary memory location from an array of pages
280 * The copy is assumed to be non-overlapping.
281 */
282static void
283_copy_from_pages(char *p, struct page **pages, size_t pgbase, size_t len)
284{
285 struct page **pgfrom;
286 char *vfrom;
287 size_t copy;
288
289 pgfrom = pages + (pgbase >> PAGE_CACHE_SHIFT);
290 pgbase &= ~PAGE_CACHE_MASK;
291
292 do {
293 copy = PAGE_CACHE_SIZE - pgbase;
294 if (copy > len)
295 copy = len;
296
297 vfrom = kmap_atomic(*pgfrom, KM_USER0);
298 memcpy(p, vfrom + pgbase, copy);
299 kunmap_atomic(vfrom, KM_USER0);
300
301 pgbase += copy;
302 if (pgbase == PAGE_CACHE_SIZE) {
303 pgbase = 0;
304 pgfrom++;
305 }
306 p += copy;
307
308 } while ((len -= copy) != 0);
309}
310
311/*
312 * xdr_shrink_bufhead
313 * @buf: xdr_buf
314 * @len: bytes to remove from buf->head[0]
315 *
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800316 * Shrinks XDR buffer's header kvec buf->head[0] by
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 * 'len' bytes. The extra data is not lost, but is instead
318 * moved into the inlined pages and/or the tail.
319 */
320static void
321xdr_shrink_bufhead(struct xdr_buf *buf, size_t len)
322{
323 struct kvec *head, *tail;
324 size_t copy, offs;
325 unsigned int pglen = buf->page_len;
326
327 tail = buf->tail;
328 head = buf->head;
329 BUG_ON (len > head->iov_len);
330
331 /* Shift the tail first */
332 if (tail->iov_len != 0) {
333 if (tail->iov_len > len) {
334 copy = tail->iov_len - len;
335 memmove((char *)tail->iov_base + len,
336 tail->iov_base, copy);
337 }
338 /* Copy from the inlined pages into the tail */
339 copy = len;
340 if (copy > pglen)
341 copy = pglen;
342 offs = len - copy;
343 if (offs >= tail->iov_len)
344 copy = 0;
345 else if (copy > tail->iov_len - offs)
346 copy = tail->iov_len - offs;
347 if (copy != 0)
348 _copy_from_pages((char *)tail->iov_base + offs,
349 buf->pages,
350 buf->page_base + pglen + offs - len,
351 copy);
352 /* Do we also need to copy data from the head into the tail ? */
353 if (len > pglen) {
354 offs = copy = len - pglen;
355 if (copy > tail->iov_len)
356 copy = tail->iov_len;
357 memcpy(tail->iov_base,
358 (char *)head->iov_base +
359 head->iov_len - offs,
360 copy);
361 }
362 }
363 /* Now handle pages */
364 if (pglen != 0) {
365 if (pglen > len)
366 _shift_data_right_pages(buf->pages,
367 buf->page_base + len,
368 buf->page_base,
369 pglen - len);
370 copy = len;
371 if (len > pglen)
372 copy = pglen;
373 _copy_to_pages(buf->pages, buf->page_base,
374 (char *)head->iov_base + head->iov_len - len,
375 copy);
376 }
377 head->iov_len -= len;
378 buf->buflen -= len;
379 /* Have we truncated the message? */
380 if (buf->len > buf->buflen)
381 buf->len = buf->buflen;
382}
383
384/*
385 * xdr_shrink_pagelen
386 * @buf: xdr_buf
387 * @len: bytes to remove from buf->pages
388 *
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800389 * Shrinks XDR buffer's page array buf->pages by
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 * 'len' bytes. The extra data is not lost, but is instead
391 * moved into the tail.
392 */
393static void
394xdr_shrink_pagelen(struct xdr_buf *buf, size_t len)
395{
396 struct kvec *tail;
397 size_t copy;
398 char *p;
399 unsigned int pglen = buf->page_len;
400
401 tail = buf->tail;
402 BUG_ON (len > pglen);
403
404 /* Shift the tail first */
405 if (tail->iov_len != 0) {
406 p = (char *)tail->iov_base + len;
407 if (tail->iov_len > len) {
408 copy = tail->iov_len - len;
409 memmove(p, tail->iov_base, copy);
410 } else
411 buf->buflen -= len;
412 /* Copy from the inlined pages into the tail */
413 copy = len;
414 if (copy > tail->iov_len)
415 copy = tail->iov_len;
416 _copy_from_pages((char *)tail->iov_base,
417 buf->pages, buf->page_base + pglen - len,
418 copy);
419 }
420 buf->page_len -= len;
421 buf->buflen -= len;
422 /* Have we truncated the message? */
423 if (buf->len > buf->buflen)
424 buf->len = buf->buflen;
425}
426
427void
428xdr_shift_buf(struct xdr_buf *buf, size_t len)
429{
430 xdr_shrink_bufhead(buf, len);
431}
Trond Myklebust468039e2008-12-23 15:21:31 -0500432EXPORT_SYMBOL_GPL(xdr_shift_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
434/**
435 * xdr_init_encode - Initialize a struct xdr_stream for sending data.
436 * @xdr: pointer to xdr_stream struct
437 * @buf: pointer to XDR buffer in which to encode data
438 * @p: current pointer inside XDR buffer
439 *
440 * Note: at the moment the RPC client only passes the length of our
441 * scratch buffer in the xdr_buf's header kvec. Previously this
442 * meant we needed to call xdr_adjust_iovec() after encoding the
443 * data. With the new scheme, the xdr_stream manages the details
444 * of the buffer length, and takes care of adjusting the kvec
445 * length for us.
446 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700447void xdr_init_encode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448{
449 struct kvec *iov = buf->head;
Trond Myklebust334ccfd2005-06-22 17:16:19 +0000450 int scratch_len = buf->buflen - buf->page_len - buf->tail[0].iov_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451
Trond Myklebust334ccfd2005-06-22 17:16:19 +0000452 BUG_ON(scratch_len < 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 xdr->buf = buf;
454 xdr->iov = iov;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700455 xdr->p = (__be32 *)((char *)iov->iov_base + iov->iov_len);
456 xdr->end = (__be32 *)((char *)iov->iov_base + scratch_len);
Trond Myklebust334ccfd2005-06-22 17:16:19 +0000457 BUG_ON(iov->iov_len > scratch_len);
458
459 if (p != xdr->p && p != NULL) {
460 size_t len;
461
462 BUG_ON(p < xdr->p || p > xdr->end);
463 len = (char *)p - (char *)xdr->p;
464 xdr->p = p;
465 buf->len += len;
466 iov->iov_len += len;
467 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468}
Trond Myklebust468039e2008-12-23 15:21:31 -0500469EXPORT_SYMBOL_GPL(xdr_init_encode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470
471/**
472 * xdr_reserve_space - Reserve buffer space for sending
473 * @xdr: pointer to xdr_stream
474 * @nbytes: number of bytes to reserve
475 *
476 * Checks that we have enough buffer space to encode 'nbytes' more
477 * bytes of data. If so, update the total xdr_buf length, and
478 * adjust the length of the current kvec.
479 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700480__be32 * xdr_reserve_space(struct xdr_stream *xdr, size_t nbytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481{
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700482 __be32 *p = xdr->p;
483 __be32 *q;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
485 /* align nbytes on the next 32-bit boundary */
486 nbytes += 3;
487 nbytes &= ~3;
488 q = p + (nbytes >> 2);
489 if (unlikely(q > xdr->end || q < p))
490 return NULL;
491 xdr->p = q;
492 xdr->iov->iov_len += nbytes;
493 xdr->buf->len += nbytes;
494 return p;
495}
Trond Myklebust468039e2008-12-23 15:21:31 -0500496EXPORT_SYMBOL_GPL(xdr_reserve_space);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497
498/**
499 * xdr_write_pages - Insert a list of pages into an XDR buffer for sending
500 * @xdr: pointer to xdr_stream
501 * @pages: list of pages
502 * @base: offset of first byte
503 * @len: length of data in bytes
504 *
505 */
506void xdr_write_pages(struct xdr_stream *xdr, struct page **pages, unsigned int base,
507 unsigned int len)
508{
509 struct xdr_buf *buf = xdr->buf;
510 struct kvec *iov = buf->tail;
511 buf->pages = pages;
512 buf->page_base = base;
513 buf->page_len = len;
514
515 iov->iov_base = (char *)xdr->p;
516 iov->iov_len = 0;
517 xdr->iov = iov;
518
519 if (len & 3) {
520 unsigned int pad = 4 - (len & 3);
521
522 BUG_ON(xdr->p >= xdr->end);
523 iov->iov_base = (char *)xdr->p + (len & 3);
524 iov->iov_len += pad;
525 len += pad;
526 *xdr->p++ = 0;
527 }
528 buf->buflen += len;
529 buf->len += len;
530}
Trond Myklebust468039e2008-12-23 15:21:31 -0500531EXPORT_SYMBOL_GPL(xdr_write_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532
533/**
534 * xdr_init_decode - Initialize an xdr_stream for decoding data.
535 * @xdr: pointer to xdr_stream struct
536 * @buf: pointer to XDR buffer from which to decode data
537 * @p: current pointer inside XDR buffer
538 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700539void xdr_init_decode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540{
541 struct kvec *iov = buf->head;
542 unsigned int len = iov->iov_len;
543
544 if (len > buf->len)
545 len = buf->len;
546 xdr->buf = buf;
547 xdr->iov = iov;
548 xdr->p = p;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700549 xdr->end = (__be32 *)((char *)iov->iov_base + len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550}
Trond Myklebust468039e2008-12-23 15:21:31 -0500551EXPORT_SYMBOL_GPL(xdr_init_decode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552
553/**
554 * xdr_inline_decode - Retrieve non-page XDR data to decode
555 * @xdr: pointer to xdr_stream struct
556 * @nbytes: number of bytes of data to decode
557 *
558 * Check if the input buffer is long enough to enable us to decode
559 * 'nbytes' more bytes of data starting at the current position.
560 * If so return the current pointer, then update the current
561 * pointer position.
562 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700563__be32 * xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564{
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700565 __be32 *p = xdr->p;
566 __be32 *q = p + XDR_QUADLEN(nbytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
568 if (unlikely(q > xdr->end || q < p))
569 return NULL;
570 xdr->p = q;
571 return p;
572}
Trond Myklebust468039e2008-12-23 15:21:31 -0500573EXPORT_SYMBOL_GPL(xdr_inline_decode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574
575/**
576 * xdr_read_pages - Ensure page-based XDR data to decode is aligned at current pointer position
577 * @xdr: pointer to xdr_stream struct
578 * @len: number of bytes of page data
579 *
580 * Moves data beyond the current pointer position from the XDR head[] buffer
581 * into the page list. Any data that lies beyond current position + "len"
Trond Myklebust8b23ea72006-06-09 09:34:21 -0400582 * bytes is moved into the XDR tail[].
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 */
584void xdr_read_pages(struct xdr_stream *xdr, unsigned int len)
585{
586 struct xdr_buf *buf = xdr->buf;
587 struct kvec *iov;
588 ssize_t shift;
589 unsigned int end;
590 int padding;
591
592 /* Realign pages to current pointer position */
593 iov = buf->head;
594 shift = iov->iov_len + (char *)iov->iov_base - (char *)xdr->p;
595 if (shift > 0)
596 xdr_shrink_bufhead(buf, shift);
597
598 /* Truncate page data and move it into the tail */
599 if (buf->page_len > len)
600 xdr_shrink_pagelen(buf, buf->page_len - len);
601 padding = (XDR_QUADLEN(len) << 2) - len;
602 xdr->iov = iov = buf->tail;
603 /* Compute remaining message length. */
604 end = iov->iov_len;
605 shift = buf->buflen - buf->len;
606 if (shift < end)
607 end -= shift;
608 else if (shift > 0)
609 end = 0;
610 /*
611 * Position current pointer at beginning of tail, and
612 * set remaining message length.
613 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700614 xdr->p = (__be32 *)((char *)iov->iov_base + padding);
615 xdr->end = (__be32 *)((char *)iov->iov_base + end);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616}
Trond Myklebust468039e2008-12-23 15:21:31 -0500617EXPORT_SYMBOL_GPL(xdr_read_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618
Trond Myklebust8b23ea72006-06-09 09:34:21 -0400619/**
620 * xdr_enter_page - decode data from the XDR page
621 * @xdr: pointer to xdr_stream struct
622 * @len: number of bytes of page data
623 *
624 * Moves data beyond the current pointer position from the XDR head[] buffer
625 * into the page list. Any data that lies beyond current position + "len"
626 * bytes is moved into the XDR tail[]. The current pointer is then
627 * repositioned at the beginning of the first XDR page.
628 */
629void xdr_enter_page(struct xdr_stream *xdr, unsigned int len)
630{
631 char * kaddr = page_address(xdr->buf->pages[0]);
632 xdr_read_pages(xdr, len);
633 /*
634 * Position current pointer at beginning of tail, and
635 * set remaining message length.
636 */
637 if (len > PAGE_CACHE_SIZE - xdr->buf->page_base)
638 len = PAGE_CACHE_SIZE - xdr->buf->page_base;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700639 xdr->p = (__be32 *)(kaddr + xdr->buf->page_base);
640 xdr->end = (__be32 *)((char *)xdr->p + len);
Trond Myklebust8b23ea72006-06-09 09:34:21 -0400641}
Trond Myklebust468039e2008-12-23 15:21:31 -0500642EXPORT_SYMBOL_GPL(xdr_enter_page);
Trond Myklebust8b23ea72006-06-09 09:34:21 -0400643
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644static struct kvec empty_iov = {.iov_base = NULL, .iov_len = 0};
645
646void
647xdr_buf_from_iov(struct kvec *iov, struct xdr_buf *buf)
648{
649 buf->head[0] = *iov;
650 buf->tail[0] = empty_iov;
651 buf->page_len = 0;
652 buf->buflen = buf->len = iov->iov_len;
653}
Trond Myklebust468039e2008-12-23 15:21:31 -0500654EXPORT_SYMBOL_GPL(xdr_buf_from_iov);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656/* Sets subbuf to the portion of buf of length len beginning base bytes
657 * from the start of buf. Returns -1 if base of length are out of bounds. */
658int
659xdr_buf_subsegment(struct xdr_buf *buf, struct xdr_buf *subbuf,
Trond Myklebust1e789572006-08-31 15:09:19 -0400660 unsigned int base, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 subbuf->buflen = subbuf->len = len;
Trond Myklebust1e789572006-08-31 15:09:19 -0400663 if (base < buf->head[0].iov_len) {
664 subbuf->head[0].iov_base = buf->head[0].iov_base + base;
665 subbuf->head[0].iov_len = min_t(unsigned int, len,
666 buf->head[0].iov_len - base);
667 len -= subbuf->head[0].iov_len;
668 base = 0;
669 } else {
670 subbuf->head[0].iov_base = NULL;
671 subbuf->head[0].iov_len = 0;
672 base -= buf->head[0].iov_len;
673 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674
675 if (base < buf->page_len) {
Trond Myklebust1e789572006-08-31 15:09:19 -0400676 subbuf->page_len = min(buf->page_len - base, len);
677 base += buf->page_base;
678 subbuf->page_base = base & ~PAGE_CACHE_MASK;
679 subbuf->pages = &buf->pages[base >> PAGE_CACHE_SHIFT];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 len -= subbuf->page_len;
681 base = 0;
682 } else {
683 base -= buf->page_len;
684 subbuf->page_len = 0;
685 }
686
Trond Myklebust1e789572006-08-31 15:09:19 -0400687 if (base < buf->tail[0].iov_len) {
688 subbuf->tail[0].iov_base = buf->tail[0].iov_base + base;
689 subbuf->tail[0].iov_len = min_t(unsigned int, len,
690 buf->tail[0].iov_len - base);
691 len -= subbuf->tail[0].iov_len;
692 base = 0;
693 } else {
694 subbuf->tail[0].iov_base = NULL;
695 subbuf->tail[0].iov_len = 0;
696 base -= buf->tail[0].iov_len;
697 }
698
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 if (base || len)
700 return -1;
701 return 0;
702}
Trond Myklebust468039e2008-12-23 15:21:31 -0500703EXPORT_SYMBOL_GPL(xdr_buf_subsegment);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400705static void __read_bytes_from_xdr_buf(struct xdr_buf *subbuf, void *obj, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706{
Trond Myklebust1e789572006-08-31 15:09:19 -0400707 unsigned int this_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400709 this_len = min_t(unsigned int, len, subbuf->head[0].iov_len);
710 memcpy(obj, subbuf->head[0].iov_base, this_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 len -= this_len;
712 obj += this_len;
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400713 this_len = min_t(unsigned int, len, subbuf->page_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 if (this_len)
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400715 _copy_from_pages(obj, subbuf->pages, subbuf->page_base, this_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 len -= this_len;
717 obj += this_len;
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400718 this_len = min_t(unsigned int, len, subbuf->tail[0].iov_len);
719 memcpy(obj, subbuf->tail[0].iov_base, this_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720}
721
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000722/* obj is assumed to point to allocated memory of size at least len: */
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400723int read_bytes_from_xdr_buf(struct xdr_buf *buf, unsigned int base, void *obj, unsigned int len)
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000724{
725 struct xdr_buf subbuf;
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000726 int status;
727
728 status = xdr_buf_subsegment(buf, &subbuf, base, len);
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400729 if (status != 0)
730 return status;
731 __read_bytes_from_xdr_buf(&subbuf, obj, len);
732 return 0;
733}
Trond Myklebust468039e2008-12-23 15:21:31 -0500734EXPORT_SYMBOL_GPL(read_bytes_from_xdr_buf);
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400735
736static void __write_bytes_to_xdr_buf(struct xdr_buf *subbuf, void *obj, unsigned int len)
737{
738 unsigned int this_len;
739
740 this_len = min_t(unsigned int, len, subbuf->head[0].iov_len);
741 memcpy(subbuf->head[0].iov_base, obj, this_len);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000742 len -= this_len;
743 obj += this_len;
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400744 this_len = min_t(unsigned int, len, subbuf->page_len);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000745 if (this_len)
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400746 _copy_to_pages(subbuf->pages, subbuf->page_base, obj, this_len);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000747 len -= this_len;
748 obj += this_len;
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400749 this_len = min_t(unsigned int, len, subbuf->tail[0].iov_len);
750 memcpy(subbuf->tail[0].iov_base, obj, this_len);
751}
752
753/* obj is assumed to point to allocated memory of size at least len: */
754int write_bytes_to_xdr_buf(struct xdr_buf *buf, unsigned int base, void *obj, unsigned int len)
755{
756 struct xdr_buf subbuf;
757 int status;
758
759 status = xdr_buf_subsegment(buf, &subbuf, base, len);
760 if (status != 0)
761 return status;
762 __write_bytes_to_xdr_buf(&subbuf, obj, len);
763 return 0;
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000764}
765
766int
Trond Myklebust1e789572006-08-31 15:09:19 -0400767xdr_decode_word(struct xdr_buf *buf, unsigned int base, u32 *obj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768{
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700769 __be32 raw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 int status;
771
772 status = read_bytes_from_xdr_buf(buf, base, &raw, sizeof(*obj));
773 if (status)
774 return status;
Benny Halevy98866b52009-08-14 17:18:49 +0300775 *obj = be32_to_cpu(raw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 return 0;
777}
Trond Myklebust468039e2008-12-23 15:21:31 -0500778EXPORT_SYMBOL_GPL(xdr_decode_word);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000780int
Trond Myklebust1e789572006-08-31 15:09:19 -0400781xdr_encode_word(struct xdr_buf *buf, unsigned int base, u32 obj)
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000782{
Benny Halevy9f162d22009-08-14 17:18:44 +0300783 __be32 raw = cpu_to_be32(obj);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000784
785 return write_bytes_to_xdr_buf(buf, base, &raw, sizeof(obj));
786}
Trond Myklebust468039e2008-12-23 15:21:31 -0500787EXPORT_SYMBOL_GPL(xdr_encode_word);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000788
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789/* If the netobj starting offset bytes from the start of xdr_buf is contained
790 * entirely in the head or the tail, set object to point to it; otherwise
791 * try to find space for it at the end of the tail, copy it there, and
792 * set obj to point to it. */
Trond Myklebustbee57c92006-10-09 22:08:22 -0400793int xdr_buf_read_netobj(struct xdr_buf *buf, struct xdr_netobj *obj, unsigned int offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794{
Trond Myklebustbee57c92006-10-09 22:08:22 -0400795 struct xdr_buf subbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000797 if (xdr_decode_word(buf, offset, &obj->len))
Trond Myklebustbee57c92006-10-09 22:08:22 -0400798 return -EFAULT;
799 if (xdr_buf_subsegment(buf, &subbuf, offset + 4, obj->len))
800 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801
Trond Myklebustbee57c92006-10-09 22:08:22 -0400802 /* Is the obj contained entirely in the head? */
803 obj->data = subbuf.head[0].iov_base;
804 if (subbuf.head[0].iov_len == obj->len)
805 return 0;
806 /* ..or is the obj contained entirely in the tail? */
807 obj->data = subbuf.tail[0].iov_base;
808 if (subbuf.tail[0].iov_len == obj->len)
809 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810
Trond Myklebustbee57c92006-10-09 22:08:22 -0400811 /* use end of tail as storage for obj:
812 * (We don't copy to the beginning because then we'd have
813 * to worry about doing a potentially overlapping copy.
814 * This assumes the object is at most half the length of the
815 * tail.) */
816 if (obj->len > buf->buflen - buf->len)
817 return -ENOMEM;
818 if (buf->tail[0].iov_len != 0)
819 obj->data = buf->tail[0].iov_base + buf->tail[0].iov_len;
820 else
821 obj->data = buf->head[0].iov_base + buf->head[0].iov_len;
822 __read_bytes_from_xdr_buf(&subbuf, obj->data, obj->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824}
Trond Myklebust468039e2008-12-23 15:21:31 -0500825EXPORT_SYMBOL_GPL(xdr_buf_read_netobj);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000826
827/* Returns 0 on success, or else a negative error code. */
828static int
829xdr_xcode_array2(struct xdr_buf *buf, unsigned int base,
830 struct xdr_array2_desc *desc, int encode)
831{
832 char *elem = NULL, *c;
833 unsigned int copied = 0, todo, avail_here;
834 struct page **ppages = NULL;
835 int err;
836
837 if (encode) {
838 if (xdr_encode_word(buf, base, desc->array_len) != 0)
839 return -EINVAL;
840 } else {
841 if (xdr_decode_word(buf, base, &desc->array_len) != 0 ||
Trond Myklebust58fcb8d2005-08-10 18:15:12 -0400842 desc->array_len > desc->array_maxlen ||
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000843 (unsigned long) base + 4 + desc->array_len *
844 desc->elem_size > buf->len)
845 return -EINVAL;
846 }
847 base += 4;
848
849 if (!desc->xcode)
850 return 0;
851
852 todo = desc->array_len * desc->elem_size;
853
854 /* process head */
855 if (todo && base < buf->head->iov_len) {
856 c = buf->head->iov_base + base;
857 avail_here = min_t(unsigned int, todo,
858 buf->head->iov_len - base);
859 todo -= avail_here;
860
861 while (avail_here >= desc->elem_size) {
862 err = desc->xcode(desc, c);
863 if (err)
864 goto out;
865 c += desc->elem_size;
866 avail_here -= desc->elem_size;
867 }
868 if (avail_here) {
869 if (!elem) {
870 elem = kmalloc(desc->elem_size, GFP_KERNEL);
871 err = -ENOMEM;
872 if (!elem)
873 goto out;
874 }
875 if (encode) {
876 err = desc->xcode(desc, elem);
877 if (err)
878 goto out;
879 memcpy(c, elem, avail_here);
880 } else
881 memcpy(elem, c, avail_here);
882 copied = avail_here;
883 }
884 base = buf->head->iov_len; /* align to start of pages */
885 }
886
887 /* process pages array */
888 base -= buf->head->iov_len;
889 if (todo && base < buf->page_len) {
890 unsigned int avail_page;
891
892 avail_here = min(todo, buf->page_len - base);
893 todo -= avail_here;
894
895 base += buf->page_base;
896 ppages = buf->pages + (base >> PAGE_CACHE_SHIFT);
897 base &= ~PAGE_CACHE_MASK;
898 avail_page = min_t(unsigned int, PAGE_CACHE_SIZE - base,
899 avail_here);
900 c = kmap(*ppages) + base;
901
902 while (avail_here) {
903 avail_here -= avail_page;
904 if (copied || avail_page < desc->elem_size) {
905 unsigned int l = min(avail_page,
906 desc->elem_size - copied);
907 if (!elem) {
908 elem = kmalloc(desc->elem_size,
909 GFP_KERNEL);
910 err = -ENOMEM;
911 if (!elem)
912 goto out;
913 }
914 if (encode) {
915 if (!copied) {
916 err = desc->xcode(desc, elem);
917 if (err)
918 goto out;
919 }
920 memcpy(c, elem + copied, l);
921 copied += l;
922 if (copied == desc->elem_size)
923 copied = 0;
924 } else {
925 memcpy(elem + copied, c, l);
926 copied += l;
927 if (copied == desc->elem_size) {
928 err = desc->xcode(desc, elem);
929 if (err)
930 goto out;
931 copied = 0;
932 }
933 }
934 avail_page -= l;
935 c += l;
936 }
937 while (avail_page >= desc->elem_size) {
938 err = desc->xcode(desc, c);
939 if (err)
940 goto out;
941 c += desc->elem_size;
942 avail_page -= desc->elem_size;
943 }
944 if (avail_page) {
945 unsigned int l = min(avail_page,
946 desc->elem_size - copied);
947 if (!elem) {
948 elem = kmalloc(desc->elem_size,
949 GFP_KERNEL);
950 err = -ENOMEM;
951 if (!elem)
952 goto out;
953 }
954 if (encode) {
955 if (!copied) {
956 err = desc->xcode(desc, elem);
957 if (err)
958 goto out;
959 }
960 memcpy(c, elem + copied, l);
961 copied += l;
962 if (copied == desc->elem_size)
963 copied = 0;
964 } else {
965 memcpy(elem + copied, c, l);
966 copied += l;
967 if (copied == desc->elem_size) {
968 err = desc->xcode(desc, elem);
969 if (err)
970 goto out;
971 copied = 0;
972 }
973 }
974 }
975 if (avail_here) {
976 kunmap(*ppages);
977 ppages++;
978 c = kmap(*ppages);
979 }
980
981 avail_page = min(avail_here,
982 (unsigned int) PAGE_CACHE_SIZE);
983 }
984 base = buf->page_len; /* align to start of tail */
985 }
986
987 /* process tail */
988 base -= buf->page_len;
989 if (todo) {
990 c = buf->tail->iov_base + base;
991 if (copied) {
992 unsigned int l = desc->elem_size - copied;
993
994 if (encode)
995 memcpy(c, elem + copied, l);
996 else {
997 memcpy(elem + copied, c, l);
998 err = desc->xcode(desc, elem);
999 if (err)
1000 goto out;
1001 }
1002 todo -= l;
1003 c += l;
1004 }
1005 while (todo) {
1006 err = desc->xcode(desc, c);
1007 if (err)
1008 goto out;
1009 c += desc->elem_size;
1010 todo -= desc->elem_size;
1011 }
1012 }
1013 err = 0;
1014
1015out:
Jesper Juhla51482b2005-11-08 09:41:34 -08001016 kfree(elem);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +00001017 if (ppages)
1018 kunmap(*ppages);
1019 return err;
1020}
1021
1022int
1023xdr_decode_array2(struct xdr_buf *buf, unsigned int base,
1024 struct xdr_array2_desc *desc)
1025{
1026 if (base >= buf->len)
1027 return -EINVAL;
1028
1029 return xdr_xcode_array2(buf, base, desc, 0);
1030}
Trond Myklebust468039e2008-12-23 15:21:31 -05001031EXPORT_SYMBOL_GPL(xdr_decode_array2);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +00001032
1033int
1034xdr_encode_array2(struct xdr_buf *buf, unsigned int base,
1035 struct xdr_array2_desc *desc)
1036{
1037 if ((unsigned long) base + 4 + desc->array_len * desc->elem_size >
1038 buf->head->iov_len + buf->page_len + buf->tail->iov_len)
1039 return -EINVAL;
1040
1041 return xdr_xcode_array2(buf, base, desc, 1);
1042}
Trond Myklebust468039e2008-12-23 15:21:31 -05001043EXPORT_SYMBOL_GPL(xdr_encode_array2);
Olga Kornievskaia37a4e6c2006-12-04 20:22:33 -05001044
1045int
1046xdr_process_buf(struct xdr_buf *buf, unsigned int offset, unsigned int len,
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -08001047 int (*actor)(struct scatterlist *, void *), void *data)
Olga Kornievskaia37a4e6c2006-12-04 20:22:33 -05001048{
1049 int i, ret = 0;
1050 unsigned page_len, thislen, page_offset;
1051 struct scatterlist sg[1];
1052
Herbert Xu68e3f5d2007-10-27 00:52:07 -07001053 sg_init_table(sg, 1);
1054
Olga Kornievskaia37a4e6c2006-12-04 20:22:33 -05001055 if (offset >= buf->head[0].iov_len) {
1056 offset -= buf->head[0].iov_len;
1057 } else {
1058 thislen = buf->head[0].iov_len - offset;
1059 if (thislen > len)
1060 thislen = len;
1061 sg_set_buf(sg, buf->head[0].iov_base + offset, thislen);
1062 ret = actor(sg, data);
1063 if (ret)
1064 goto out;
1065 offset = 0;
1066 len -= thislen;
1067 }
1068 if (len == 0)
1069 goto out;
1070
1071 if (offset >= buf->page_len) {
1072 offset -= buf->page_len;
1073 } else {
1074 page_len = buf->page_len - offset;
1075 if (page_len > len)
1076 page_len = len;
1077 len -= page_len;
1078 page_offset = (offset + buf->page_base) & (PAGE_CACHE_SIZE - 1);
1079 i = (offset + buf->page_base) >> PAGE_CACHE_SHIFT;
1080 thislen = PAGE_CACHE_SIZE - page_offset;
1081 do {
1082 if (thislen > page_len)
1083 thislen = page_len;
Jens Axboe642f1492007-10-24 11:20:47 +02001084 sg_set_page(sg, buf->pages[i], thislen, page_offset);
Olga Kornievskaia37a4e6c2006-12-04 20:22:33 -05001085 ret = actor(sg, data);
1086 if (ret)
1087 goto out;
1088 page_len -= thislen;
1089 i++;
1090 page_offset = 0;
1091 thislen = PAGE_CACHE_SIZE;
1092 } while (page_len != 0);
1093 offset = 0;
1094 }
1095 if (len == 0)
1096 goto out;
1097 if (offset < buf->tail[0].iov_len) {
1098 thislen = buf->tail[0].iov_len - offset;
1099 if (thislen > len)
1100 thislen = len;
1101 sg_set_buf(sg, buf->tail[0].iov_base + offset, thislen);
1102 ret = actor(sg, data);
1103 len -= thislen;
1104 }
1105 if (len != 0)
1106 ret = -EINVAL;
1107out:
1108 return ret;
1109}
Trond Myklebust468039e2008-12-23 15:21:31 -05001110EXPORT_SYMBOL_GPL(xdr_process_buf);
Olga Kornievskaia37a4e6c2006-12-04 20:22:33 -05001111