blob: 75edcfad6e264f299fac566f16bb1cfd82615d2a [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
Chuck Leverb4687da2010-09-21 16:55:48 -0400114/**
115 * xdr_terminate_string - '\0'-terminate a string residing in an xdr_buf
116 * @buf: XDR buffer where string resides
117 * @len: length of string, in bytes
118 *
119 */
120void
121xdr_terminate_string(struct xdr_buf *buf, const u32 len)
122{
123 char *kaddr;
124
Cong Wangb8541782011-11-25 23:14:40 +0800125 kaddr = kmap_atomic(buf->pages[0]);
Chuck Leverb4687da2010-09-21 16:55:48 -0400126 kaddr[buf->page_base + len] = '\0';
Cong Wangb8541782011-11-25 23:14:40 +0800127 kunmap_atomic(kaddr);
Chuck Leverb4687da2010-09-21 16:55:48 -0400128}
Trond Myklebust0d961aa2011-07-13 19:24:15 -0400129EXPORT_SYMBOL_GPL(xdr_terminate_string);
Chuck Leverb4687da2010-09-21 16:55:48 -0400130
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132xdr_inline_pages(struct xdr_buf *xdr, unsigned int offset,
133 struct page **pages, unsigned int base, unsigned int len)
134{
135 struct kvec *head = xdr->head;
136 struct kvec *tail = xdr->tail;
137 char *buf = (char *)head->iov_base;
138 unsigned int buflen = head->iov_len;
139
140 head->iov_len = offset;
141
142 xdr->pages = pages;
143 xdr->page_base = base;
144 xdr->page_len = len;
145
146 tail->iov_base = buf + offset;
147 tail->iov_len = buflen - offset;
148
149 xdr->buflen += len;
150}
Trond Myklebust468039e2008-12-23 15:21:31 -0500151EXPORT_SYMBOL_GPL(xdr_inline_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153/*
154 * Helper routines for doing 'memmove' like operations on a struct xdr_buf
Ben Hutchings2c530402012-07-10 10:55:09 +0000155 */
156
157/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 * _shift_data_right_pages
159 * @pages: vector of pages containing both the source and dest memory area.
160 * @pgto_base: page vector address of destination
161 * @pgfrom_base: page vector address of source
162 * @len: number of bytes to copy
163 *
164 * Note: the addresses pgto_base and pgfrom_base are both calculated in
165 * the same way:
166 * if a memory area starts at byte 'base' in page 'pages[i]',
167 * then its address is given as (i << PAGE_CACHE_SHIFT) + base
168 * Also note: pgfrom_base must be < pgto_base, but the memory areas
169 * they point to may overlap.
170 */
171static void
172_shift_data_right_pages(struct page **pages, size_t pgto_base,
173 size_t pgfrom_base, size_t len)
174{
175 struct page **pgfrom, **pgto;
176 char *vfrom, *vto;
177 size_t copy;
178
179 BUG_ON(pgto_base <= pgfrom_base);
180
181 pgto_base += len;
182 pgfrom_base += len;
183
184 pgto = pages + (pgto_base >> PAGE_CACHE_SHIFT);
185 pgfrom = pages + (pgfrom_base >> PAGE_CACHE_SHIFT);
186
187 pgto_base &= ~PAGE_CACHE_MASK;
188 pgfrom_base &= ~PAGE_CACHE_MASK;
189
190 do {
191 /* Are any pointers crossing a page boundary? */
192 if (pgto_base == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 pgto_base = PAGE_CACHE_SIZE;
194 pgto--;
195 }
196 if (pgfrom_base == 0) {
197 pgfrom_base = PAGE_CACHE_SIZE;
198 pgfrom--;
199 }
200
201 copy = len;
202 if (copy > pgto_base)
203 copy = pgto_base;
204 if (copy > pgfrom_base)
205 copy = pgfrom_base;
206 pgto_base -= copy;
207 pgfrom_base -= copy;
208
Cong Wangb8541782011-11-25 23:14:40 +0800209 vto = kmap_atomic(*pgto);
210 vfrom = kmap_atomic(*pgfrom);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 memmove(vto + pgto_base, vfrom + pgfrom_base, copy);
Trond Myklebustbce34812006-07-05 13:17:12 -0400212 flush_dcache_page(*pgto);
Cong Wangb8541782011-11-25 23:14:40 +0800213 kunmap_atomic(vfrom);
214 kunmap_atomic(vto);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
216 } while ((len -= copy) != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217}
218
Ben Hutchings2c530402012-07-10 10:55:09 +0000219/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 * _copy_to_pages
221 * @pages: array of pages
222 * @pgbase: page vector address of destination
223 * @p: pointer to source data
224 * @len: length
225 *
226 * Copies data from an arbitrary memory location into an array of pages
227 * The copy is assumed to be non-overlapping.
228 */
229static void
230_copy_to_pages(struct page **pages, size_t pgbase, const char *p, size_t len)
231{
232 struct page **pgto;
233 char *vto;
234 size_t copy;
235
236 pgto = pages + (pgbase >> PAGE_CACHE_SHIFT);
237 pgbase &= ~PAGE_CACHE_MASK;
238
Trond Myklebustdaeba892008-03-31 17:02:02 -0400239 for (;;) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 copy = PAGE_CACHE_SIZE - pgbase;
241 if (copy > len)
242 copy = len;
243
Cong Wangb8541782011-11-25 23:14:40 +0800244 vto = kmap_atomic(*pgto);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 memcpy(vto + pgbase, p, copy);
Cong Wangb8541782011-11-25 23:14:40 +0800246 kunmap_atomic(vto);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247
Trond Myklebustdaeba892008-03-31 17:02:02 -0400248 len -= copy;
249 if (len == 0)
250 break;
251
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 pgbase += copy;
253 if (pgbase == PAGE_CACHE_SIZE) {
254 flush_dcache_page(*pgto);
255 pgbase = 0;
256 pgto++;
257 }
258 p += copy;
Trond Myklebustdaeba892008-03-31 17:02:02 -0400259 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 flush_dcache_page(*pgto);
261}
262
Ben Hutchings2c530402012-07-10 10:55:09 +0000263/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 * _copy_from_pages
265 * @p: pointer to destination
266 * @pages: array of pages
267 * @pgbase: offset of source data
268 * @len: length
269 *
270 * Copies data into an arbitrary memory location from an array of pages
271 * The copy is assumed to be non-overlapping.
272 */
Andy Adamsonbf118a32011-12-07 11:55:27 -0500273void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274_copy_from_pages(char *p, struct page **pages, size_t pgbase, size_t len)
275{
276 struct page **pgfrom;
277 char *vfrom;
278 size_t copy;
279
280 pgfrom = pages + (pgbase >> PAGE_CACHE_SHIFT);
281 pgbase &= ~PAGE_CACHE_MASK;
282
283 do {
284 copy = PAGE_CACHE_SIZE - pgbase;
285 if (copy > len)
286 copy = len;
287
Cong Wangb8541782011-11-25 23:14:40 +0800288 vfrom = kmap_atomic(*pgfrom);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 memcpy(p, vfrom + pgbase, copy);
Cong Wangb8541782011-11-25 23:14:40 +0800290 kunmap_atomic(vfrom);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
292 pgbase += copy;
293 if (pgbase == PAGE_CACHE_SIZE) {
294 pgbase = 0;
295 pgfrom++;
296 }
297 p += copy;
298
299 } while ((len -= copy) != 0);
300}
Andy Adamsonbf118a32011-12-07 11:55:27 -0500301EXPORT_SYMBOL_GPL(_copy_from_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
Ben Hutchings2c530402012-07-10 10:55:09 +0000303/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 * xdr_shrink_bufhead
305 * @buf: xdr_buf
306 * @len: bytes to remove from buf->head[0]
307 *
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800308 * Shrinks XDR buffer's header kvec buf->head[0] by
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 * 'len' bytes. The extra data is not lost, but is instead
310 * moved into the inlined pages and/or the tail.
311 */
312static void
313xdr_shrink_bufhead(struct xdr_buf *buf, size_t len)
314{
315 struct kvec *head, *tail;
316 size_t copy, offs;
317 unsigned int pglen = buf->page_len;
318
319 tail = buf->tail;
320 head = buf->head;
Weston Andros Adamson18e624a2012-10-23 10:43:42 -0400321
322 WARN_ON_ONCE(len > head->iov_len);
323 if (len > head->iov_len)
324 len = head->iov_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
326 /* Shift the tail first */
327 if (tail->iov_len != 0) {
328 if (tail->iov_len > len) {
329 copy = tail->iov_len - len;
330 memmove((char *)tail->iov_base + len,
331 tail->iov_base, copy);
332 }
333 /* Copy from the inlined pages into the tail */
334 copy = len;
335 if (copy > pglen)
336 copy = pglen;
337 offs = len - copy;
338 if (offs >= tail->iov_len)
339 copy = 0;
340 else if (copy > tail->iov_len - offs)
341 copy = tail->iov_len - offs;
342 if (copy != 0)
343 _copy_from_pages((char *)tail->iov_base + offs,
344 buf->pages,
345 buf->page_base + pglen + offs - len,
346 copy);
347 /* Do we also need to copy data from the head into the tail ? */
348 if (len > pglen) {
349 offs = copy = len - pglen;
350 if (copy > tail->iov_len)
351 copy = tail->iov_len;
352 memcpy(tail->iov_base,
353 (char *)head->iov_base +
354 head->iov_len - offs,
355 copy);
356 }
357 }
358 /* Now handle pages */
359 if (pglen != 0) {
360 if (pglen > len)
361 _shift_data_right_pages(buf->pages,
362 buf->page_base + len,
363 buf->page_base,
364 pglen - len);
365 copy = len;
366 if (len > pglen)
367 copy = pglen;
368 _copy_to_pages(buf->pages, buf->page_base,
369 (char *)head->iov_base + head->iov_len - len,
370 copy);
371 }
372 head->iov_len -= len;
373 buf->buflen -= len;
374 /* Have we truncated the message? */
375 if (buf->len > buf->buflen)
376 buf->len = buf->buflen;
377}
378
Ben Hutchings2c530402012-07-10 10:55:09 +0000379/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 * xdr_shrink_pagelen
381 * @buf: xdr_buf
382 * @len: bytes to remove from buf->pages
383 *
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -0800384 * Shrinks XDR buffer's page array buf->pages by
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 * 'len' bytes. The extra data is not lost, but is instead
386 * moved into the tail.
387 */
388static void
389xdr_shrink_pagelen(struct xdr_buf *buf, size_t len)
390{
391 struct kvec *tail;
392 size_t copy;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 unsigned int pglen = buf->page_len;
Trond Myklebustcf187c22010-08-29 12:13:16 -0400394 unsigned int tailbuf_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395
396 tail = buf->tail;
397 BUG_ON (len > pglen);
398
Trond Myklebustcf187c22010-08-29 12:13:16 -0400399 tailbuf_len = buf->buflen - buf->head->iov_len - buf->page_len;
400
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 /* Shift the tail first */
Trond Myklebustcf187c22010-08-29 12:13:16 -0400402 if (tailbuf_len != 0) {
403 unsigned int free_space = tailbuf_len - tail->iov_len;
404
405 if (len < free_space)
406 free_space = len;
407 tail->iov_len += free_space;
408
Benny Halevy42d6d8a2010-08-29 12:13:15 -0400409 copy = len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 if (tail->iov_len > len) {
Benny Halevy0fe62a352010-08-29 12:13:15 -0400411 char *p = (char *)tail->iov_base + len;
Benny Halevy2e29ebb2010-08-29 12:13:15 -0400412 memmove(p, tail->iov_base, tail->iov_len - len);
Benny Halevy42d6d8a2010-08-29 12:13:15 -0400413 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 copy = tail->iov_len;
Benny Halevy42d6d8a2010-08-29 12:13:15 -0400415 /* Copy from the inlined pages into the tail */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 _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/**
Trond Myklebust4517d522012-06-21 17:14:46 -0400435 * xdr_stream_pos - Return the current offset from the start of the xdr_stream
436 * @xdr: pointer to struct xdr_stream
437 */
438unsigned int xdr_stream_pos(const struct xdr_stream *xdr)
439{
440 return (unsigned int)(XDR_QUADLEN(xdr->buf->len) - xdr->nwords) << 2;
441}
442EXPORT_SYMBOL_GPL(xdr_stream_pos);
443
444/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 * 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 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700457void xdr_init_encode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458{
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;
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700465 xdr->p = (__be32 *)((char *)iov->iov_base + iov->iov_len);
466 xdr->end = (__be32 *)((char *)iov->iov_base + scratch_len);
Trond Myklebust334ccfd2005-06-22 17:16:19 +0000467 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}
Trond Myklebust468039e2008-12-23 15:21:31 -0500479EXPORT_SYMBOL_GPL(xdr_init_encode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480
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 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700490__be32 * xdr_reserve_space(struct xdr_stream *xdr, size_t nbytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491{
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700492 __be32 *p = xdr->p;
493 __be32 *q;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494
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}
Trond Myklebust468039e2008-12-23 15:21:31 -0500506EXPORT_SYMBOL_GPL(xdr_reserve_space);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507
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}
Trond Myklebust468039e2008-12-23 15:21:31 -0500541EXPORT_SYMBOL_GPL(xdr_write_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542
Trond Myklebust66502392011-01-08 17:45:38 -0500543static void xdr_set_iov(struct xdr_stream *xdr, struct kvec *iov,
Trond Myklebust15376932012-06-28 17:17:48 -0400544 unsigned int len)
Trond Myklebust66502392011-01-08 17:45:38 -0500545{
546 if (len > iov->iov_len)
547 len = iov->iov_len;
Trond Myklebust15376932012-06-28 17:17:48 -0400548 xdr->p = (__be32*)iov->iov_base;
Trond Myklebust66502392011-01-08 17:45:38 -0500549 xdr->end = (__be32*)(iov->iov_base + len);
550 xdr->iov = iov;
551 xdr->page_ptr = NULL;
552}
553
554static int xdr_set_page_base(struct xdr_stream *xdr,
555 unsigned int base, unsigned int len)
556{
557 unsigned int pgnr;
558 unsigned int maxlen;
559 unsigned int pgoff;
560 unsigned int pgend;
561 void *kaddr;
562
563 maxlen = xdr->buf->page_len;
564 if (base >= maxlen)
565 return -EINVAL;
566 maxlen -= base;
567 if (len > maxlen)
568 len = maxlen;
569
570 base += xdr->buf->page_base;
571
572 pgnr = base >> PAGE_SHIFT;
573 xdr->page_ptr = &xdr->buf->pages[pgnr];
574 kaddr = page_address(*xdr->page_ptr);
575
576 pgoff = base & ~PAGE_MASK;
577 xdr->p = (__be32*)(kaddr + pgoff);
578
579 pgend = pgoff + len;
580 if (pgend > PAGE_SIZE)
581 pgend = PAGE_SIZE;
582 xdr->end = (__be32*)(kaddr + pgend);
583 xdr->iov = NULL;
584 return 0;
585}
586
587static void xdr_set_next_page(struct xdr_stream *xdr)
588{
589 unsigned int newbase;
590
591 newbase = (1 + xdr->page_ptr - xdr->buf->pages) << PAGE_SHIFT;
592 newbase -= xdr->buf->page_base;
593
594 if (xdr_set_page_base(xdr, newbase, PAGE_SIZE) < 0)
Trond Myklebust15376932012-06-28 17:17:48 -0400595 xdr_set_iov(xdr, xdr->buf->tail, xdr->buf->len);
Trond Myklebust66502392011-01-08 17:45:38 -0500596}
597
598static bool xdr_set_next_buffer(struct xdr_stream *xdr)
599{
600 if (xdr->page_ptr != NULL)
601 xdr_set_next_page(xdr);
602 else if (xdr->iov == xdr->buf->head) {
603 if (xdr_set_page_base(xdr, 0, PAGE_SIZE) < 0)
Trond Myklebust15376932012-06-28 17:17:48 -0400604 xdr_set_iov(xdr, xdr->buf->tail, xdr->buf->len);
Trond Myklebust66502392011-01-08 17:45:38 -0500605 }
606 return xdr->p != xdr->end;
607}
608
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609/**
610 * xdr_init_decode - Initialize an xdr_stream for decoding data.
611 * @xdr: pointer to xdr_stream struct
612 * @buf: pointer to XDR buffer from which to decode data
613 * @p: current pointer inside XDR buffer
614 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700615void xdr_init_decode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 xdr->buf = buf;
Trond Myklebust66502392011-01-08 17:45:38 -0500618 xdr->scratch.iov_base = NULL;
619 xdr->scratch.iov_len = 0;
Trond Myklebustbfeea1d2012-06-20 09:58:35 -0400620 xdr->nwords = XDR_QUADLEN(buf->len);
Trond Myklebust66502392011-01-08 17:45:38 -0500621 if (buf->head[0].iov_len != 0)
Trond Myklebust15376932012-06-28 17:17:48 -0400622 xdr_set_iov(xdr, buf->head, buf->len);
Trond Myklebust66502392011-01-08 17:45:38 -0500623 else if (buf->page_len != 0)
624 xdr_set_page_base(xdr, 0, buf->len);
Trond Myklebustbfeea1d2012-06-20 09:58:35 -0400625 if (p != NULL && p > xdr->p && xdr->end >= p) {
626 xdr->nwords -= p - xdr->p;
Trond Myklebust15376932012-06-28 17:17:48 -0400627 xdr->p = p;
Trond Myklebustbfeea1d2012-06-20 09:58:35 -0400628 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629}
Trond Myklebust468039e2008-12-23 15:21:31 -0500630EXPORT_SYMBOL_GPL(xdr_init_decode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631
Benny Halevyf7da7a12011-05-19 14:16:47 -0400632/**
633 * xdr_init_decode - Initialize an xdr_stream for decoding data.
634 * @xdr: pointer to xdr_stream struct
635 * @buf: pointer to XDR buffer from which to decode data
636 * @pages: list of pages to decode into
637 * @len: length in bytes of buffer in pages
638 */
639void xdr_init_decode_pages(struct xdr_stream *xdr, struct xdr_buf *buf,
640 struct page **pages, unsigned int len)
641{
642 memset(buf, 0, sizeof(*buf));
643 buf->pages = pages;
644 buf->page_len = len;
645 buf->buflen = len;
646 buf->len = len;
647 xdr_init_decode(xdr, buf, NULL);
648}
649EXPORT_SYMBOL_GPL(xdr_init_decode_pages);
650
Trond Myklebust66502392011-01-08 17:45:38 -0500651static __be32 * __xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes)
Trond Myklebustba8e4522010-10-19 19:58:49 -0400652{
Trond Myklebustbfeea1d2012-06-20 09:58:35 -0400653 unsigned int nwords = XDR_QUADLEN(nbytes);
Trond Myklebustba8e4522010-10-19 19:58:49 -0400654 __be32 *p = xdr->p;
Trond Myklebustbfeea1d2012-06-20 09:58:35 -0400655 __be32 *q = p + nwords;
Trond Myklebustba8e4522010-10-19 19:58:49 -0400656
Trond Myklebustbfeea1d2012-06-20 09:58:35 -0400657 if (unlikely(nwords > xdr->nwords || q > xdr->end || q < p))
Trond Myklebustba8e4522010-10-19 19:58:49 -0400658 return NULL;
Trond Myklebust66502392011-01-08 17:45:38 -0500659 xdr->p = q;
Trond Myklebustbfeea1d2012-06-20 09:58:35 -0400660 xdr->nwords -= nwords;
Trond Myklebustba8e4522010-10-19 19:58:49 -0400661 return p;
662}
Trond Myklebustba8e4522010-10-19 19:58:49 -0400663
664/**
Trond Myklebust66502392011-01-08 17:45:38 -0500665 * xdr_set_scratch_buffer - Attach a scratch buffer for decoding data.
666 * @xdr: pointer to xdr_stream struct
667 * @buf: pointer to an empty buffer
668 * @buflen: size of 'buf'
669 *
670 * The scratch buffer is used when decoding from an array of pages.
671 * If an xdr_inline_decode() call spans across page boundaries, then
672 * we copy the data into the scratch buffer in order to allow linear
673 * access.
674 */
675void xdr_set_scratch_buffer(struct xdr_stream *xdr, void *buf, size_t buflen)
676{
677 xdr->scratch.iov_base = buf;
678 xdr->scratch.iov_len = buflen;
679}
680EXPORT_SYMBOL_GPL(xdr_set_scratch_buffer);
681
682static __be32 *xdr_copy_to_scratch(struct xdr_stream *xdr, size_t nbytes)
683{
684 __be32 *p;
685 void *cpdest = xdr->scratch.iov_base;
686 size_t cplen = (char *)xdr->end - (char *)xdr->p;
687
688 if (nbytes > xdr->scratch.iov_len)
689 return NULL;
690 memcpy(cpdest, xdr->p, cplen);
691 cpdest += cplen;
692 nbytes -= cplen;
693 if (!xdr_set_next_buffer(xdr))
694 return NULL;
695 p = __xdr_inline_decode(xdr, nbytes);
696 if (p == NULL)
697 return NULL;
698 memcpy(cpdest, p, nbytes);
699 return xdr->scratch.iov_base;
700}
701
702/**
703 * xdr_inline_decode - Retrieve XDR data to decode
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 * @xdr: pointer to xdr_stream struct
705 * @nbytes: number of bytes of data to decode
706 *
707 * Check if the input buffer is long enough to enable us to decode
708 * 'nbytes' more bytes of data starting at the current position.
709 * If so return the current pointer, then update the current
710 * pointer position.
711 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700712__be32 * xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713{
Trond Myklebust66502392011-01-08 17:45:38 -0500714 __be32 *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715
Trond Myklebust66502392011-01-08 17:45:38 -0500716 if (nbytes == 0)
717 return xdr->p;
718 if (xdr->p == xdr->end && !xdr_set_next_buffer(xdr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 return NULL;
Trond Myklebust66502392011-01-08 17:45:38 -0500720 p = __xdr_inline_decode(xdr, nbytes);
721 if (p != NULL)
722 return p;
723 return xdr_copy_to_scratch(xdr, nbytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724}
Trond Myklebust468039e2008-12-23 15:21:31 -0500725EXPORT_SYMBOL_GPL(xdr_inline_decode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726
Trond Myklebust3994ee62012-06-26 12:34:05 -0400727static unsigned int xdr_align_pages(struct xdr_stream *xdr, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728{
729 struct xdr_buf *buf = xdr->buf;
730 struct kvec *iov;
Trond Myklebustbfeea1d2012-06-20 09:58:35 -0400731 unsigned int nwords = XDR_QUADLEN(len);
Trond Myklebustb760b312012-06-26 12:19:55 -0400732 unsigned int cur = xdr_stream_pos(xdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733
Trond Myklebustbfeea1d2012-06-20 09:58:35 -0400734 if (xdr->nwords == 0)
Trond Myklebustc337d362012-06-21 17:05:37 -0400735 return 0;
Trond Myklebusta11a2bf2012-08-02 13:21:43 -0400736 /* Realign pages to current pointer position */
737 iov = buf->head;
738 if (iov->iov_len > cur) {
739 xdr_shrink_bufhead(buf, iov->iov_len - cur);
740 xdr->nwords = XDR_QUADLEN(buf->len - cur);
741 }
742
Trond Myklebustbfeea1d2012-06-20 09:58:35 -0400743 if (nwords > xdr->nwords) {
744 nwords = xdr->nwords;
745 len = nwords << 2;
746 }
Trond Myklebusta11a2bf2012-08-02 13:21:43 -0400747 if (buf->page_len <= len)
Trond Myklebust8a9a8b82012-08-01 14:32:13 -0400748 len = buf->page_len;
Trond Myklebusta11a2bf2012-08-02 13:21:43 -0400749 else if (nwords < xdr->nwords) {
750 /* Truncate page data and move it into the tail */
751 xdr_shrink_pagelen(buf, buf->page_len - len);
752 xdr->nwords = XDR_QUADLEN(buf->len - cur);
753 }
Trond Myklebust3994ee62012-06-26 12:34:05 -0400754 return len;
755}
Trond Myklebustbd00f842012-06-26 13:50:43 -0400756
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757/**
758 * xdr_read_pages - Ensure page-based XDR data to decode is aligned at current pointer position
759 * @xdr: pointer to xdr_stream struct
760 * @len: number of bytes of page data
761 *
762 * Moves data beyond the current pointer position from the XDR head[] buffer
763 * into the page list. Any data that lies beyond current position + "len"
764 * bytes is moved into the XDR tail[].
Trond Myklebust3994ee62012-06-26 12:34:05 -0400765 *
766 * Returns the number of XDR encoded bytes now contained in the pages
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 */
Trond Myklebust3994ee62012-06-26 12:34:05 -0400768unsigned int xdr_read_pages(struct xdr_stream *xdr, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769{
770 struct xdr_buf *buf = xdr->buf;
771 struct kvec *iov;
Trond Myklebust3994ee62012-06-26 12:34:05 -0400772 unsigned int nwords;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 unsigned int end;
Trond Myklebust3994ee62012-06-26 12:34:05 -0400774 unsigned int padding;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775
Trond Myklebust3994ee62012-06-26 12:34:05 -0400776 len = xdr_align_pages(xdr, len);
777 if (len == 0)
778 return 0;
779 nwords = XDR_QUADLEN(len);
Trond Myklebustbfeea1d2012-06-20 09:58:35 -0400780 padding = (nwords << 2) - len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 xdr->iov = iov = buf->tail;
782 /* Compute remaining message length. */
Trond Myklebustbd00f842012-06-26 13:50:43 -0400783 end = ((xdr->nwords - nwords) << 2) + padding;
784 if (end > iov->iov_len)
785 end = iov->iov_len;
786
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 /*
788 * Position current pointer at beginning of tail, and
789 * set remaining message length.
790 */
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700791 xdr->p = (__be32 *)((char *)iov->iov_base + padding);
792 xdr->end = (__be32 *)((char *)iov->iov_base + end);
Trond Myklebust76cacaa2012-06-26 15:32:40 -0400793 xdr->page_ptr = NULL;
Trond Myklebustbfeea1d2012-06-20 09:58:35 -0400794 xdr->nwords = XDR_QUADLEN(end - padding);
Trond Myklebustc337d362012-06-21 17:05:37 -0400795 return len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796}
Trond Myklebust468039e2008-12-23 15:21:31 -0500797EXPORT_SYMBOL_GPL(xdr_read_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798
Trond Myklebust8b23ea72006-06-09 09:34:21 -0400799/**
800 * xdr_enter_page - decode data from the XDR page
801 * @xdr: pointer to xdr_stream struct
802 * @len: number of bytes of page data
803 *
804 * Moves data beyond the current pointer position from the XDR head[] buffer
805 * into the page list. Any data that lies beyond current position + "len"
806 * bytes is moved into the XDR tail[]. The current pointer is then
807 * repositioned at the beginning of the first XDR page.
808 */
809void xdr_enter_page(struct xdr_stream *xdr, unsigned int len)
810{
Trond Myklebustf8bb7f02012-06-21 14:53:10 -0400811 len = xdr_align_pages(xdr, len);
Trond Myklebust8b23ea72006-06-09 09:34:21 -0400812 /*
813 * Position current pointer at beginning of tail, and
814 * set remaining message length.
815 */
Trond Myklebustf8bb7f02012-06-21 14:53:10 -0400816 if (len != 0)
817 xdr_set_page_base(xdr, 0, len);
Trond Myklebust8b23ea72006-06-09 09:34:21 -0400818}
Trond Myklebust468039e2008-12-23 15:21:31 -0500819EXPORT_SYMBOL_GPL(xdr_enter_page);
Trond Myklebust8b23ea72006-06-09 09:34:21 -0400820
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821static struct kvec empty_iov = {.iov_base = NULL, .iov_len = 0};
822
823void
824xdr_buf_from_iov(struct kvec *iov, struct xdr_buf *buf)
825{
826 buf->head[0] = *iov;
827 buf->tail[0] = empty_iov;
828 buf->page_len = 0;
829 buf->buflen = buf->len = iov->iov_len;
830}
Trond Myklebust468039e2008-12-23 15:21:31 -0500831EXPORT_SYMBOL_GPL(xdr_buf_from_iov);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833/* Sets subbuf to the portion of buf of length len beginning base bytes
834 * from the start of buf. Returns -1 if base of length are out of bounds. */
835int
836xdr_buf_subsegment(struct xdr_buf *buf, struct xdr_buf *subbuf,
Trond Myklebust1e789572006-08-31 15:09:19 -0400837 unsigned int base, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 subbuf->buflen = subbuf->len = len;
Trond Myklebust1e789572006-08-31 15:09:19 -0400840 if (base < buf->head[0].iov_len) {
841 subbuf->head[0].iov_base = buf->head[0].iov_base + base;
842 subbuf->head[0].iov_len = min_t(unsigned int, len,
843 buf->head[0].iov_len - base);
844 len -= subbuf->head[0].iov_len;
845 base = 0;
846 } else {
847 subbuf->head[0].iov_base = NULL;
848 subbuf->head[0].iov_len = 0;
849 base -= buf->head[0].iov_len;
850 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851
852 if (base < buf->page_len) {
Trond Myklebust1e789572006-08-31 15:09:19 -0400853 subbuf->page_len = min(buf->page_len - base, len);
854 base += buf->page_base;
855 subbuf->page_base = base & ~PAGE_CACHE_MASK;
856 subbuf->pages = &buf->pages[base >> PAGE_CACHE_SHIFT];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 len -= subbuf->page_len;
858 base = 0;
859 } else {
860 base -= buf->page_len;
861 subbuf->page_len = 0;
862 }
863
Trond Myklebust1e789572006-08-31 15:09:19 -0400864 if (base < buf->tail[0].iov_len) {
865 subbuf->tail[0].iov_base = buf->tail[0].iov_base + base;
866 subbuf->tail[0].iov_len = min_t(unsigned int, len,
867 buf->tail[0].iov_len - base);
868 len -= subbuf->tail[0].iov_len;
869 base = 0;
870 } else {
871 subbuf->tail[0].iov_base = NULL;
872 subbuf->tail[0].iov_len = 0;
873 base -= buf->tail[0].iov_len;
874 }
875
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 if (base || len)
877 return -1;
878 return 0;
879}
Trond Myklebust468039e2008-12-23 15:21:31 -0500880EXPORT_SYMBOL_GPL(xdr_buf_subsegment);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881
Jeff Layton4c190e22013-02-06 08:28:55 -0500882/**
883 * xdr_buf_trim - lop at most "len" bytes off the end of "buf"
884 * @buf: buf to be trimmed
885 * @len: number of bytes to reduce "buf" by
886 *
887 * Trim an xdr_buf by the given number of bytes by fixing up the lengths. Note
888 * that it's possible that we'll trim less than that amount if the xdr_buf is
889 * too small, or if (for instance) it's all in the head and the parser has
890 * already read too far into it.
891 */
892void xdr_buf_trim(struct xdr_buf *buf, unsigned int len)
893{
894 size_t cur;
895 unsigned int trim = len;
896
897 if (buf->tail[0].iov_len) {
898 cur = min_t(size_t, buf->tail[0].iov_len, trim);
899 buf->tail[0].iov_len -= cur;
900 trim -= cur;
901 if (!trim)
902 goto fix_len;
903 }
904
905 if (buf->page_len) {
906 cur = min_t(unsigned int, buf->page_len, trim);
907 buf->page_len -= cur;
908 trim -= cur;
909 if (!trim)
910 goto fix_len;
911 }
912
913 if (buf->head[0].iov_len) {
914 cur = min_t(size_t, buf->head[0].iov_len, trim);
915 buf->head[0].iov_len -= cur;
916 trim -= cur;
917 }
918fix_len:
919 buf->len -= (len - trim);
920}
921EXPORT_SYMBOL_GPL(xdr_buf_trim);
922
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400923static void __read_bytes_from_xdr_buf(struct xdr_buf *subbuf, void *obj, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924{
Trond Myklebust1e789572006-08-31 15:09:19 -0400925 unsigned int this_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400927 this_len = min_t(unsigned int, len, subbuf->head[0].iov_len);
928 memcpy(obj, subbuf->head[0].iov_base, this_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 len -= this_len;
930 obj += this_len;
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400931 this_len = min_t(unsigned int, len, subbuf->page_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 if (this_len)
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400933 _copy_from_pages(obj, subbuf->pages, subbuf->page_base, this_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 len -= this_len;
935 obj += this_len;
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400936 this_len = min_t(unsigned int, len, subbuf->tail[0].iov_len);
937 memcpy(obj, subbuf->tail[0].iov_base, this_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938}
939
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000940/* obj is assumed to point to allocated memory of size at least len: */
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400941int read_bytes_from_xdr_buf(struct xdr_buf *buf, unsigned int base, void *obj, unsigned int len)
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000942{
943 struct xdr_buf subbuf;
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000944 int status;
945
946 status = xdr_buf_subsegment(buf, &subbuf, base, len);
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400947 if (status != 0)
948 return status;
949 __read_bytes_from_xdr_buf(&subbuf, obj, len);
950 return 0;
951}
Trond Myklebust468039e2008-12-23 15:21:31 -0500952EXPORT_SYMBOL_GPL(read_bytes_from_xdr_buf);
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400953
954static void __write_bytes_to_xdr_buf(struct xdr_buf *subbuf, void *obj, unsigned int len)
955{
956 unsigned int this_len;
957
958 this_len = min_t(unsigned int, len, subbuf->head[0].iov_len);
959 memcpy(subbuf->head[0].iov_base, obj, this_len);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000960 len -= this_len;
961 obj += this_len;
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400962 this_len = min_t(unsigned int, len, subbuf->page_len);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000963 if (this_len)
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400964 _copy_to_pages(subbuf->pages, subbuf->page_base, obj, this_len);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000965 len -= this_len;
966 obj += this_len;
Trond Myklebust4e3e43a2006-10-17 13:47:24 -0400967 this_len = min_t(unsigned int, len, subbuf->tail[0].iov_len);
968 memcpy(subbuf->tail[0].iov_base, obj, this_len);
969}
970
971/* obj is assumed to point to allocated memory of size at least len: */
972int write_bytes_to_xdr_buf(struct xdr_buf *buf, unsigned int base, void *obj, unsigned int len)
973{
974 struct xdr_buf subbuf;
975 int status;
976
977 status = xdr_buf_subsegment(buf, &subbuf, base, len);
978 if (status != 0)
979 return status;
980 __write_bytes_to_xdr_buf(&subbuf, obj, len);
981 return 0;
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000982}
Kevin Coffmanc43abae2010-03-17 13:02:58 -0400983EXPORT_SYMBOL_GPL(write_bytes_to_xdr_buf);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000984
985int
Trond Myklebust1e789572006-08-31 15:09:19 -0400986xdr_decode_word(struct xdr_buf *buf, unsigned int base, u32 *obj)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987{
Alexey Dobriyand8ed0292006-09-26 22:29:38 -0700988 __be32 raw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 int status;
990
991 status = read_bytes_from_xdr_buf(buf, base, &raw, sizeof(*obj));
992 if (status)
993 return status;
Benny Halevy98866b52009-08-14 17:18:49 +0300994 *obj = be32_to_cpu(raw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 return 0;
996}
Trond Myklebust468039e2008-12-23 15:21:31 -0500997EXPORT_SYMBOL_GPL(xdr_decode_word);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +0000999int
Trond Myklebust1e789572006-08-31 15:09:19 -04001000xdr_encode_word(struct xdr_buf *buf, unsigned int base, u32 obj)
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +00001001{
Benny Halevy9f162d22009-08-14 17:18:44 +03001002 __be32 raw = cpu_to_be32(obj);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +00001003
1004 return write_bytes_to_xdr_buf(buf, base, &raw, sizeof(obj));
1005}
Trond Myklebust468039e2008-12-23 15:21:31 -05001006EXPORT_SYMBOL_GPL(xdr_encode_word);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +00001007
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008/* If the netobj starting offset bytes from the start of xdr_buf is contained
1009 * entirely in the head or the tail, set object to point to it; otherwise
1010 * try to find space for it at the end of the tail, copy it there, and
1011 * set obj to point to it. */
Trond Myklebustbee57c92006-10-09 22:08:22 -04001012int xdr_buf_read_netobj(struct xdr_buf *buf, struct xdr_netobj *obj, unsigned int offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013{
Trond Myklebustbee57c92006-10-09 22:08:22 -04001014 struct xdr_buf subbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +00001016 if (xdr_decode_word(buf, offset, &obj->len))
Trond Myklebustbee57c92006-10-09 22:08:22 -04001017 return -EFAULT;
1018 if (xdr_buf_subsegment(buf, &subbuf, offset + 4, obj->len))
1019 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020
Trond Myklebustbee57c92006-10-09 22:08:22 -04001021 /* Is the obj contained entirely in the head? */
1022 obj->data = subbuf.head[0].iov_base;
1023 if (subbuf.head[0].iov_len == obj->len)
1024 return 0;
1025 /* ..or is the obj contained entirely in the tail? */
1026 obj->data = subbuf.tail[0].iov_base;
1027 if (subbuf.tail[0].iov_len == obj->len)
1028 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029
Trond Myklebustbee57c92006-10-09 22:08:22 -04001030 /* use end of tail as storage for obj:
1031 * (We don't copy to the beginning because then we'd have
1032 * to worry about doing a potentially overlapping copy.
1033 * This assumes the object is at most half the length of the
1034 * tail.) */
1035 if (obj->len > buf->buflen - buf->len)
1036 return -ENOMEM;
1037 if (buf->tail[0].iov_len != 0)
1038 obj->data = buf->tail[0].iov_base + buf->tail[0].iov_len;
1039 else
1040 obj->data = buf->head[0].iov_base + buf->head[0].iov_len;
1041 __read_bytes_from_xdr_buf(&subbuf, obj->data, obj->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043}
Trond Myklebust468039e2008-12-23 15:21:31 -05001044EXPORT_SYMBOL_GPL(xdr_buf_read_netobj);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +00001045
1046/* Returns 0 on success, or else a negative error code. */
1047static int
1048xdr_xcode_array2(struct xdr_buf *buf, unsigned int base,
1049 struct xdr_array2_desc *desc, int encode)
1050{
1051 char *elem = NULL, *c;
1052 unsigned int copied = 0, todo, avail_here;
1053 struct page **ppages = NULL;
1054 int err;
1055
1056 if (encode) {
1057 if (xdr_encode_word(buf, base, desc->array_len) != 0)
1058 return -EINVAL;
1059 } else {
1060 if (xdr_decode_word(buf, base, &desc->array_len) != 0 ||
Trond Myklebust58fcb8d2005-08-10 18:15:12 -04001061 desc->array_len > desc->array_maxlen ||
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +00001062 (unsigned long) base + 4 + desc->array_len *
1063 desc->elem_size > buf->len)
1064 return -EINVAL;
1065 }
1066 base += 4;
1067
1068 if (!desc->xcode)
1069 return 0;
1070
1071 todo = desc->array_len * desc->elem_size;
1072
1073 /* process head */
1074 if (todo && base < buf->head->iov_len) {
1075 c = buf->head->iov_base + base;
1076 avail_here = min_t(unsigned int, todo,
1077 buf->head->iov_len - base);
1078 todo -= avail_here;
1079
1080 while (avail_here >= desc->elem_size) {
1081 err = desc->xcode(desc, c);
1082 if (err)
1083 goto out;
1084 c += desc->elem_size;
1085 avail_here -= desc->elem_size;
1086 }
1087 if (avail_here) {
1088 if (!elem) {
1089 elem = kmalloc(desc->elem_size, GFP_KERNEL);
1090 err = -ENOMEM;
1091 if (!elem)
1092 goto out;
1093 }
1094 if (encode) {
1095 err = desc->xcode(desc, elem);
1096 if (err)
1097 goto out;
1098 memcpy(c, elem, avail_here);
1099 } else
1100 memcpy(elem, c, avail_here);
1101 copied = avail_here;
1102 }
1103 base = buf->head->iov_len; /* align to start of pages */
1104 }
1105
1106 /* process pages array */
1107 base -= buf->head->iov_len;
1108 if (todo && base < buf->page_len) {
1109 unsigned int avail_page;
1110
1111 avail_here = min(todo, buf->page_len - base);
1112 todo -= avail_here;
1113
1114 base += buf->page_base;
1115 ppages = buf->pages + (base >> PAGE_CACHE_SHIFT);
1116 base &= ~PAGE_CACHE_MASK;
1117 avail_page = min_t(unsigned int, PAGE_CACHE_SIZE - base,
1118 avail_here);
1119 c = kmap(*ppages) + base;
1120
1121 while (avail_here) {
1122 avail_here -= avail_page;
1123 if (copied || avail_page < desc->elem_size) {
1124 unsigned int l = min(avail_page,
1125 desc->elem_size - copied);
1126 if (!elem) {
1127 elem = kmalloc(desc->elem_size,
1128 GFP_KERNEL);
1129 err = -ENOMEM;
1130 if (!elem)
1131 goto out;
1132 }
1133 if (encode) {
1134 if (!copied) {
1135 err = desc->xcode(desc, elem);
1136 if (err)
1137 goto out;
1138 }
1139 memcpy(c, elem + copied, l);
1140 copied += l;
1141 if (copied == desc->elem_size)
1142 copied = 0;
1143 } else {
1144 memcpy(elem + copied, c, l);
1145 copied += l;
1146 if (copied == desc->elem_size) {
1147 err = desc->xcode(desc, elem);
1148 if (err)
1149 goto out;
1150 copied = 0;
1151 }
1152 }
1153 avail_page -= l;
1154 c += l;
1155 }
1156 while (avail_page >= desc->elem_size) {
1157 err = desc->xcode(desc, c);
1158 if (err)
1159 goto out;
1160 c += desc->elem_size;
1161 avail_page -= desc->elem_size;
1162 }
1163 if (avail_page) {
1164 unsigned int l = min(avail_page,
1165 desc->elem_size - copied);
1166 if (!elem) {
1167 elem = kmalloc(desc->elem_size,
1168 GFP_KERNEL);
1169 err = -ENOMEM;
1170 if (!elem)
1171 goto out;
1172 }
1173 if (encode) {
1174 if (!copied) {
1175 err = desc->xcode(desc, elem);
1176 if (err)
1177 goto out;
1178 }
1179 memcpy(c, elem + copied, l);
1180 copied += l;
1181 if (copied == desc->elem_size)
1182 copied = 0;
1183 } else {
1184 memcpy(elem + copied, c, l);
1185 copied += l;
1186 if (copied == desc->elem_size) {
1187 err = desc->xcode(desc, elem);
1188 if (err)
1189 goto out;
1190 copied = 0;
1191 }
1192 }
1193 }
1194 if (avail_here) {
1195 kunmap(*ppages);
1196 ppages++;
1197 c = kmap(*ppages);
1198 }
1199
1200 avail_page = min(avail_here,
1201 (unsigned int) PAGE_CACHE_SIZE);
1202 }
1203 base = buf->page_len; /* align to start of tail */
1204 }
1205
1206 /* process tail */
1207 base -= buf->page_len;
1208 if (todo) {
1209 c = buf->tail->iov_base + base;
1210 if (copied) {
1211 unsigned int l = desc->elem_size - copied;
1212
1213 if (encode)
1214 memcpy(c, elem + copied, l);
1215 else {
1216 memcpy(elem + copied, c, l);
1217 err = desc->xcode(desc, elem);
1218 if (err)
1219 goto out;
1220 }
1221 todo -= l;
1222 c += l;
1223 }
1224 while (todo) {
1225 err = desc->xcode(desc, c);
1226 if (err)
1227 goto out;
1228 c += desc->elem_size;
1229 todo -= desc->elem_size;
1230 }
1231 }
1232 err = 0;
1233
1234out:
Jesper Juhla51482b2005-11-08 09:41:34 -08001235 kfree(elem);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +00001236 if (ppages)
1237 kunmap(*ppages);
1238 return err;
1239}
1240
1241int
1242xdr_decode_array2(struct xdr_buf *buf, unsigned int base,
1243 struct xdr_array2_desc *desc)
1244{
1245 if (base >= buf->len)
1246 return -EINVAL;
1247
1248 return xdr_xcode_array2(buf, base, desc, 0);
1249}
Trond Myklebust468039e2008-12-23 15:21:31 -05001250EXPORT_SYMBOL_GPL(xdr_decode_array2);
Andreas Gruenbacherbd8100e2005-06-22 17:16:24 +00001251
1252int
1253xdr_encode_array2(struct xdr_buf *buf, unsigned int base,
1254 struct xdr_array2_desc *desc)
1255{
1256 if ((unsigned long) base + 4 + desc->array_len * desc->elem_size >
1257 buf->head->iov_len + buf->page_len + buf->tail->iov_len)
1258 return -EINVAL;
1259
1260 return xdr_xcode_array2(buf, base, desc, 1);
1261}
Trond Myklebust468039e2008-12-23 15:21:31 -05001262EXPORT_SYMBOL_GPL(xdr_encode_array2);
Olga Kornievskaia37a4e6c2006-12-04 20:22:33 -05001263
1264int
1265xdr_process_buf(struct xdr_buf *buf, unsigned int offset, unsigned int len,
YOSHIFUJI Hideakicca51722007-02-09 15:38:13 -08001266 int (*actor)(struct scatterlist *, void *), void *data)
Olga Kornievskaia37a4e6c2006-12-04 20:22:33 -05001267{
1268 int i, ret = 0;
Eric Dumazet95c96172012-04-15 05:58:06 +00001269 unsigned int page_len, thislen, page_offset;
Olga Kornievskaia37a4e6c2006-12-04 20:22:33 -05001270 struct scatterlist sg[1];
1271
Herbert Xu68e3f5d2007-10-27 00:52:07 -07001272 sg_init_table(sg, 1);
1273
Olga Kornievskaia37a4e6c2006-12-04 20:22:33 -05001274 if (offset >= buf->head[0].iov_len) {
1275 offset -= buf->head[0].iov_len;
1276 } else {
1277 thislen = buf->head[0].iov_len - offset;
1278 if (thislen > len)
1279 thislen = len;
1280 sg_set_buf(sg, buf->head[0].iov_base + offset, thislen);
1281 ret = actor(sg, data);
1282 if (ret)
1283 goto out;
1284 offset = 0;
1285 len -= thislen;
1286 }
1287 if (len == 0)
1288 goto out;
1289
1290 if (offset >= buf->page_len) {
1291 offset -= buf->page_len;
1292 } else {
1293 page_len = buf->page_len - offset;
1294 if (page_len > len)
1295 page_len = len;
1296 len -= page_len;
1297 page_offset = (offset + buf->page_base) & (PAGE_CACHE_SIZE - 1);
1298 i = (offset + buf->page_base) >> PAGE_CACHE_SHIFT;
1299 thislen = PAGE_CACHE_SIZE - page_offset;
1300 do {
1301 if (thislen > page_len)
1302 thislen = page_len;
Jens Axboe642f1492007-10-24 11:20:47 +02001303 sg_set_page(sg, buf->pages[i], thislen, page_offset);
Olga Kornievskaia37a4e6c2006-12-04 20:22:33 -05001304 ret = actor(sg, data);
1305 if (ret)
1306 goto out;
1307 page_len -= thislen;
1308 i++;
1309 page_offset = 0;
1310 thislen = PAGE_CACHE_SIZE;
1311 } while (page_len != 0);
1312 offset = 0;
1313 }
1314 if (len == 0)
1315 goto out;
1316 if (offset < buf->tail[0].iov_len) {
1317 thislen = buf->tail[0].iov_len - offset;
1318 if (thislen > len)
1319 thislen = len;
1320 sg_set_buf(sg, buf->tail[0].iov_base + offset, thislen);
1321 ret = actor(sg, data);
1322 len -= thislen;
1323 }
1324 if (len != 0)
1325 ret = -EINVAL;
1326out:
1327 return ret;
1328}
Trond Myklebust468039e2008-12-23 15:21:31 -05001329EXPORT_SYMBOL_GPL(xdr_process_buf);
Olga Kornievskaia37a4e6c2006-12-04 20:22:33 -05001330