]> git.ipfire.org Git - thirdparty/linux.git/blob - lib/iov_iter.c
projects / thirdparty / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[thirdparty/linux.git] / lib / iov_iter.c
1 #include <linux/export.h>
2 #include <linux/bvec.h>
3 #include <linux/uio.h>
4 #include <linux/pagemap.h>
5 #include <linux/slab.h>
6 #include <linux/vmalloc.h>
7 #include <linux/splice.h>
8 #include <net/checksum.h>
9 #include <linux/scatterlist.h>
10
11 #define PIPE_PARANOIA /* for now */
12
13 #define iterate_iovec(i, n, __v, __p, skip, STEP) { \
14 size_t left; \
15 size_t wanted = n; \
16 __p = i->iov; \
17 __v.iov_len = min(n, __p->iov_len - skip); \
18 if (likely(__v.iov_len)) { \
19 __v.iov_base = __p->iov_base + skip; \
20 left = (STEP); \
21 __v.iov_len -= left; \
22 skip += __v.iov_len; \
23 n -= __v.iov_len; \
24 } else { \
25 left = 0; \
26 } \
27 while (unlikely(!left && n)) { \
28 __p++; \
29 __v.iov_len = min(n, __p->iov_len); \
30 if (unlikely(!__v.iov_len)) \
31 continue; \
32 __v.iov_base = __p->iov_base; \
33 left = (STEP); \
34 __v.iov_len -= left; \
35 skip = __v.iov_len; \
36 n -= __v.iov_len; \
37 } \
38 n = wanted - n; \
39 }
40
41 #define iterate_kvec(i, n, __v, __p, skip, STEP) { \
42 size_t wanted = n; \
43 __p = i->kvec; \
44 __v.iov_len = min(n, __p->iov_len - skip); \
45 if (likely(__v.iov_len)) { \
46 __v.iov_base = __p->iov_base + skip; \
47 (void)(STEP); \
48 skip += __v.iov_len; \
49 n -= __v.iov_len; \
50 } \
51 while (unlikely(n)) { \
52 __p++; \
53 __v.iov_len = min(n, __p->iov_len); \
54 if (unlikely(!__v.iov_len)) \
55 continue; \
56 __v.iov_base = __p->iov_base; \
57 (void)(STEP); \
58 skip = __v.iov_len; \
59 n -= __v.iov_len; \
60 } \
61 n = wanted; \
62 }
63
64 #define iterate_bvec(i, n, __v, __bi, skip, STEP) { \
65 struct bvec_iter __start; \
66 __start.bi_size = n; \
67 __start.bi_bvec_done = skip; \
68 __start.bi_idx = 0; \
69 for_each_bvec(__v, i->bvec, __bi, __start) { \
70 if (!__v.bv_len) \
71 continue; \
72 (void)(STEP); \
73 } \
74 }
75
76 #define iterate_all_kinds(i, n, v, I, B, K) { \
77 if (likely(n)) { \
78 size_t skip = i->iov_offset; \
79 if (unlikely(i->type & ITER_BVEC)) { \
80 struct bio_vec v; \
81 struct bvec_iter __bi; \
82 iterate_bvec(i, n, v, __bi, skip, (B)) \
83 } else if (unlikely(i->type & ITER_KVEC)) { \
84 const struct kvec *kvec; \
85 struct kvec v; \
86 iterate_kvec(i, n, v, kvec, skip, (K)) \
87 } else if (unlikely(i->type & ITER_DISCARD)) { \
88 } else { \
89 const struct iovec *iov; \
90 struct iovec v; \
91 iterate_iovec(i, n, v, iov, skip, (I)) \
92 } \
93 } \
94 }
95
96 #define iterate_and_advance(i, n, v, I, B, K) { \
97 if (unlikely(i->count < n)) \
98 n = i->count; \
99 if (i->count) { \
100 size_t skip = i->iov_offset; \
101 if (unlikely(i->type & ITER_BVEC)) { \
102 const struct bio_vec *bvec = i->bvec; \
103 struct bio_vec v; \
104 struct bvec_iter __bi; \
105 iterate_bvec(i, n, v, __bi, skip, (B)) \
106 i->bvec = __bvec_iter_bvec(i->bvec, __bi); \
107 i->nr_segs -= i->bvec - bvec; \
108 skip = __bi.bi_bvec_done; \
109 } else if (unlikely(i->type & ITER_KVEC)) { \
110 const struct kvec *kvec; \
111 struct kvec v; \
112 iterate_kvec(i, n, v, kvec, skip, (K)) \
113 if (skip == kvec->iov_len) { \
114 kvec++; \
115 skip = 0; \
116 } \
117 i->nr_segs -= kvec - i->kvec; \
118 i->kvec = kvec; \
119 } else if (unlikely(i->type & ITER_DISCARD)) { \
120 skip += n; \
121 } else { \
122 const struct iovec *iov; \
123 struct iovec v; \
124 iterate_iovec(i, n, v, iov, skip, (I)) \
125 if (skip == iov->iov_len) { \
126 iov++; \
127 skip = 0; \
128 } \
129 i->nr_segs -= iov - i->iov; \
130 i->iov = iov; \
131 } \
132 i->count -= n; \
133 i->iov_offset = skip; \
134 } \
135 }
136
137 static int copyout(void __user *to, const void *from, size_t n)
138 {
139 if (access_ok(to, n)) {
140 kasan_check_read(from, n);
141 n = raw_copy_to_user(to, from, n);
142 }
143 return n;
144 }
145
146 static int copyin(void *to, const void __user *from, size_t n)
147 {
148 if (access_ok(from, n)) {
149 kasan_check_write(to, n);
150 n = raw_copy_from_user(to, from, n);
151 }
152 return n;
153 }
154
155 static size_t copy_page_to_iter_iovec(struct page *page, size_t offset, size_t bytes,
156 struct iov_iter *i)
157 {
158 size_t skip, copy, left, wanted;
159 const struct iovec *iov;
160 char __user *buf;
161 void *kaddr, *from;
162
163 if (unlikely(bytes > i->count))
164 bytes = i->count;
165
166 if (unlikely(!bytes))
167 return 0;
168
169 might_fault();
170 wanted = bytes;
171 iov = i->iov;
172 skip = i->iov_offset;
173 buf = iov->iov_base + skip;
174 copy = min(bytes, iov->iov_len - skip);
175
176 if (IS_ENABLED(CONFIG_HIGHMEM) && !fault_in_pages_writeable(buf, copy)) {
177 kaddr = kmap_atomic(page);
178 from = kaddr + offset;
179
180 /* first chunk, usually the only one */
181 left = copyout(buf, from, copy);
182 copy -= left;
183 skip += copy;
184 from += copy;
185 bytes -= copy;
186
187 while (unlikely(!left && bytes)) {
188 iov++;
189 buf = iov->iov_base;
190 copy = min(bytes, iov->iov_len);
191 left = copyout(buf, from, copy);
192 copy -= left;
193 skip = copy;
194 from += copy;
195 bytes -= copy;
196 }
197 if (likely(!bytes)) {
198 kunmap_atomic(kaddr);
199 goto done;
200 }
201 offset = from - kaddr;
202 buf += copy;
203 kunmap_atomic(kaddr);
204 copy = min(bytes, iov->iov_len - skip);
205 }
206 /* Too bad - revert to non-atomic kmap */
207
208 kaddr = kmap(page);
209 from = kaddr + offset;
210 left = copyout(buf, from, copy);
211 copy -= left;
212 skip += copy;
213 from += copy;
214 bytes -= copy;
215 while (unlikely(!left && bytes)) {
216 iov++;
217 buf = iov->iov_base;
218 copy = min(bytes, iov->iov_len);
219 left = copyout(buf, from, copy);
220 copy -= left;
221 skip = copy;
222 from += copy;
223 bytes -= copy;
224 }
225 kunmap(page);
226
227 done:
228 if (skip == iov->iov_len) {
229 iov++;
230 skip = 0;
231 }
232 i->count -= wanted - bytes;
233 i->nr_segs -= iov - i->iov;
234 i->iov = iov;
235 i->iov_offset = skip;
236 return wanted - bytes;
237 }
238
239 static size_t copy_page_from_iter_iovec(struct page *page, size_t offset, size_t bytes,
240 struct iov_iter *i)
241 {
242 size_t skip, copy, left, wanted;
243 const struct iovec *iov;
244 char __user *buf;
245 void *kaddr, *to;
246
247 if (unlikely(bytes > i->count))
248 bytes = i->count;
249
250 if (unlikely(!bytes))
251 return 0;
252
253 might_fault();
254 wanted = bytes;
255 iov = i->iov;
256 skip = i->iov_offset;
257 buf = iov->iov_base + skip;
258 copy = min(bytes, iov->iov_len - skip);
259
260 if (IS_ENABLED(CONFIG_HIGHMEM) && !fault_in_pages_readable(buf, copy)) {
261 kaddr = kmap_atomic(page);
262 to = kaddr + offset;
263
264 /* first chunk, usually the only one */
265 left = copyin(to, buf, copy);
266 copy -= left;
267 skip += copy;
268 to += copy;
269 bytes -= copy;
270
271 while (unlikely(!left && bytes)) {
272 iov++;
273 buf = iov->iov_base;
274 copy = min(bytes, iov->iov_len);
275 left = copyin(to, buf, copy);
276 copy -= left;
277 skip = copy;
278 to += copy;
279 bytes -= copy;
280 }
281 if (likely(!bytes)) {
282 kunmap_atomic(kaddr);
283 goto done;
284 }
285 offset = to - kaddr;
286 buf += copy;
287 kunmap_atomic(kaddr);
288 copy = min(bytes, iov->iov_len - skip);
289 }
290 /* Too bad - revert to non-atomic kmap */
291
292 kaddr = kmap(page);
293 to = kaddr + offset;
294 left = copyin(to, buf, copy);
295 copy -= left;
296 skip += copy;
297 to += copy;
298 bytes -= copy;
299 while (unlikely(!left && bytes)) {
300 iov++;
301 buf = iov->iov_base;
302 copy = min(bytes, iov->iov_len);
303 left = copyin(to, buf, copy);
304 copy -= left;
305 skip = copy;
306 to += copy;
307 bytes -= copy;
308 }
309 kunmap(page);
310
311 done:
312 if (skip == iov->iov_len) {
313 iov++;
314 skip = 0;
315 }
316 i->count -= wanted - bytes;
317 i->nr_segs -= iov - i->iov;
318 i->iov = iov;
319 i->iov_offset = skip;
320 return wanted - bytes;
321 }
322
323 #ifdef PIPE_PARANOIA
324 static bool sanity(const struct iov_iter *i)
325 {
326 struct pipe_inode_info *pipe = i->pipe;
327 int idx = i->idx;
328 int next = pipe->curbuf + pipe->nrbufs;
329 if (i->iov_offset) {
330 struct pipe_buffer *p;
331 if (unlikely(!pipe->nrbufs))
332 goto Bad; // pipe must be non-empty
333 if (unlikely(idx != ((next - 1) & (pipe->buffers - 1))))
334 goto Bad; // must be at the last buffer...
335
336 p = &pipe->bufs[idx];
337 if (unlikely(p->offset + p->len != i->iov_offset))
338 goto Bad; // ... at the end of segment
339 } else {
340 if (idx != (next & (pipe->buffers - 1)))
341 goto Bad; // must be right after the last buffer
342 }
343 return true;
344 Bad:
345 printk(KERN_ERR "idx = %d, offset = %zd\n", i->idx, i->iov_offset);
346 printk(KERN_ERR "curbuf = %d, nrbufs = %d, buffers = %d\n",
347 pipe->curbuf, pipe->nrbufs, pipe->buffers);
348 for (idx = 0; idx < pipe->buffers; idx++)
349 printk(KERN_ERR "[%p %p %d %d]\n",
350 pipe->bufs[idx].ops,
351 pipe->bufs[idx].page,
352 pipe->bufs[idx].offset,
353 pipe->bufs[idx].len);
354 WARN_ON(1);
355 return false;
356 }
357 #else
358 #define sanity(i) true
359 #endif
360
361 static inline int next_idx(int idx, struct pipe_inode_info *pipe)
362 {
363 return (idx + 1) & (pipe->buffers - 1);
364 }
365
366 static size_t copy_page_to_iter_pipe(struct page *page, size_t offset, size_t bytes,
367 struct iov_iter *i)
368 {
369 struct pipe_inode_info *pipe = i->pipe;
370 struct pipe_buffer *buf;
371 size_t off;
372 int idx;
373
374 if (unlikely(bytes > i->count))
375 bytes = i->count;
376
377 if (unlikely(!bytes))
378 return 0;
379
380 if (!sanity(i))
381 return 0;
382
383 off = i->iov_offset;
384 idx = i->idx;
385 buf = &pipe->bufs[idx];
386 if (off) {
387 if (offset == off && buf->page == page) {
388 /* merge with the last one */
389 buf->len += bytes;
390 i->iov_offset += bytes;
391 goto out;
392 }
393 idx = next_idx(idx, pipe);
394 buf = &pipe->bufs[idx];
395 }
396 if (idx == pipe->curbuf && pipe->nrbufs)
397 return 0;
398 pipe->nrbufs++;
399 buf->ops = &page_cache_pipe_buf_ops;
400 get_page(buf->page = page);
401 buf->offset = offset;
402 buf->len = bytes;
403 i->iov_offset = offset + bytes;
404 i->idx = idx;
405 out:
406 i->count -= bytes;
407 return bytes;
408 }
409
410 /*
411 * Fault in one or more iovecs of the given iov_iter, to a maximum length of
412 * bytes. For each iovec, fault in each page that constitutes the iovec.
413 *
414 * Return 0 on success, or non-zero if the memory could not be accessed (i.e.
415 * because it is an invalid address).
416 */
417 int iov_iter_fault_in_readable(struct iov_iter *i, size_t bytes)
418 {
419 size_t skip = i->iov_offset;
420 const struct iovec *iov;
421 int err;
422 struct iovec v;
423
424 if (!(i->type & (ITER_BVEC|ITER_KVEC))) {
425 iterate_iovec(i, bytes, v, iov, skip, ({
426 err = fault_in_pages_readable(v.iov_base, v.iov_len);
427 if (unlikely(err))
428 return err;
429 0;}))
430 }
431 return 0;
432 }
433 EXPORT_SYMBOL(iov_iter_fault_in_readable);
434
435 void iov_iter_init(struct iov_iter *i, unsigned int direction,
436 const struct iovec *iov, unsigned long nr_segs,
437 size_t count)
438 {
439 WARN_ON(direction & ~(READ | WRITE));
440 direction &= READ | WRITE;
441
442 /* It will get better. Eventually... */
443 if (uaccess_kernel()) {
444 i->type = ITER_KVEC | direction;
445 i->kvec = (struct kvec *)iov;
446 } else {
447 i->type = ITER_IOVEC | direction;
448 i->iov = iov;
449 }
450 i->nr_segs = nr_segs;
451 i->iov_offset = 0;
452 i->count = count;
453 }
454 EXPORT_SYMBOL(iov_iter_init);
455
456 static void memcpy_from_page(char *to, struct page *page, size_t offset, size_t len)
457 {
458 char *from = kmap_atomic(page);
459 memcpy(to, from + offset, len);
460 kunmap_atomic(from);
461 }
462
463 static void memcpy_to_page(struct page *page, size_t offset, const char *from, size_t len)
464 {
465 char *to = kmap_atomic(page);
466 memcpy(to + offset, from, len);
467 kunmap_atomic(to);
468 }
469
470 static void memzero_page(struct page *page, size_t offset, size_t len)
471 {
472 char *addr = kmap_atomic(page);
473 memset(addr + offset, 0, len);
474 kunmap_atomic(addr);
475 }
476
477 static inline bool allocated(struct pipe_buffer *buf)
478 {
479 return buf->ops == &default_pipe_buf_ops;
480 }
481
482 static inline void data_start(const struct iov_iter *i, int *idxp, size_t *offp)
483 {
484 size_t off = i->iov_offset;
485 int idx = i->idx;
486 if (off && (!allocated(&i->pipe->bufs[idx]) || off == PAGE_SIZE)) {
487 idx = next_idx(idx, i->pipe);
488 off = 0;
489 }
490 *idxp = idx;
491 *offp = off;
492 }
493
494 static size_t push_pipe(struct iov_iter *i, size_t size,
495 int *idxp, size_t *offp)
496 {
497 struct pipe_inode_info *pipe = i->pipe;
498 size_t off;
499 int idx;
500 ssize_t left;
501
502 if (unlikely(size > i->count))
503 size = i->count;
504 if (unlikely(!size))
505 return 0;
506
507 left = size;
508 data_start(i, &idx, &off);
509 *idxp = idx;
510 *offp = off;
511 if (off) {
512 left -= PAGE_SIZE - off;
513 if (left <= 0) {
514 pipe->bufs[idx].len += size;
515 return size;
516 }
517 pipe->bufs[idx].len = PAGE_SIZE;
518 idx = next_idx(idx, pipe);
519 }
520 while (idx != pipe->curbuf || !pipe->nrbufs) {
521 struct page *page = alloc_page(GFP_USER);
522 if (!page)
523 break;
524 pipe->nrbufs++;
525 pipe->bufs[idx].ops = &default_pipe_buf_ops;
526 pipe->bufs[idx].page = page;
527 pipe->bufs[idx].offset = 0;
528 if (left <= PAGE_SIZE) {
529 pipe->bufs[idx].len = left;
530 return size;
531 }
532 pipe->bufs[idx].len = PAGE_SIZE;
533 left -= PAGE_SIZE;
534 idx = next_idx(idx, pipe);
535 }
536 return size - left;
537 }
538
539 static size_t copy_pipe_to_iter(const void *addr, size_t bytes,
540 struct iov_iter *i)
541 {
542 struct pipe_inode_info *pipe = i->pipe;
543 size_t n, off;
544 int idx;
545
546 if (!sanity(i))
547 return 0;
548
549 bytes = n = push_pipe(i, bytes, &idx, &off);
550 if (unlikely(!n))
551 return 0;
552 for ( ; n; idx = next_idx(idx, pipe), off = 0) {
553 size_t chunk = min_t(size_t, n, PAGE_SIZE - off);
554 memcpy_to_page(pipe->bufs[idx].page, off, addr, chunk);
555 i->idx = idx;
556 i->iov_offset = off + chunk;
557 n -= chunk;
558 addr += chunk;
559 }
560 i->count -= bytes;
561 return bytes;
562 }
563
564 static __wsum csum_and_memcpy(void *to, const void *from, size_t len,
565 __wsum sum, size_t off)
566 {
567 __wsum next = csum_partial_copy_nocheck(from, to, len, 0);
568 return csum_block_add(sum, next, off);
569 }
570
571 static size_t csum_and_copy_to_pipe_iter(const void *addr, size_t bytes,
572 __wsum *csum, struct iov_iter *i)
573 {
574 struct pipe_inode_info *pipe = i->pipe;
575 size_t n, r;
576 size_t off = 0;
577 __wsum sum = *csum;
578 int idx;
579
580 if (!sanity(i))
581 return 0;
582
583 bytes = n = push_pipe(i, bytes, &idx, &r);
584 if (unlikely(!n))
585 return 0;
586 for ( ; n; idx = next_idx(idx, pipe), r = 0) {
587 size_t chunk = min_t(size_t, n, PAGE_SIZE - r);
588 char *p = kmap_atomic(pipe->bufs[idx].page);
589 sum = csum_and_memcpy(p + r, addr, chunk, sum, off);
590 kunmap_atomic(p);
591 i->idx = idx;
592 i->iov_offset = r + chunk;
593 n -= chunk;
594 off += chunk;
595 addr += chunk;
596 }
597 i->count -= bytes;
598 *csum = sum;
599 return bytes;
600 }
601
602 size_t _copy_to_iter(const void *addr, size_t bytes, struct iov_iter *i)
603 {
604 const char *from = addr;
605 if (unlikely(iov_iter_is_pipe(i)))
606 return copy_pipe_to_iter(addr, bytes, i);
607 if (iter_is_iovec(i))
608 might_fault();
609 iterate_and_advance(i, bytes, v,
610 copyout(v.iov_base, (from += v.iov_len) - v.iov_len, v.iov_len),
611 memcpy_to_page(v.bv_page, v.bv_offset,
612 (from += v.bv_len) - v.bv_len, v.bv_len),
613 memcpy(v.iov_base, (from += v.iov_len) - v.iov_len, v.iov_len)
614 )
615
616 return bytes;
617 }
618 EXPORT_SYMBOL(_copy_to_iter);
619
620 #ifdef CONFIG_ARCH_HAS_UACCESS_MCSAFE
621 static int copyout_mcsafe(void __user *to, const void *from, size_t n)
622 {
623 if (access_ok(to, n)) {
624 kasan_check_read(from, n);
625 n = copy_to_user_mcsafe((__force void *) to, from, n);
626 }
627 return n;
628 }
629
630 static unsigned long memcpy_mcsafe_to_page(struct page *page, size_t offset,
631 const char *from, size_t len)
632 {
633 unsigned long ret;
634 char *to;
635
636 to = kmap_atomic(page);
637 ret = memcpy_mcsafe(to + offset, from, len);
638 kunmap_atomic(to);
639
640 return ret;
641 }
642
643 static size_t copy_pipe_to_iter_mcsafe(const void *addr, size_t bytes,
644 struct iov_iter *i)
645 {
646 struct pipe_inode_info *pipe = i->pipe;
647 size_t n, off, xfer = 0;
648 int idx;
649
650 if (!sanity(i))
651 return 0;
652
653 bytes = n = push_pipe(i, bytes, &idx, &off);
654 if (unlikely(!n))
655 return 0;
656 for ( ; n; idx = next_idx(idx, pipe), off = 0) {
657 size_t chunk = min_t(size_t, n, PAGE_SIZE - off);
658 unsigned long rem;
659
660 rem = memcpy_mcsafe_to_page(pipe->bufs[idx].page, off, addr,
661 chunk);
662 i->idx = idx;
663 i->iov_offset = off + chunk - rem;
664 xfer += chunk - rem;
665 if (rem)
666 break;
667 n -= chunk;
668 addr += chunk;
669 }
670 i->count -= xfer;
671 return xfer;
672 }
673
674 /**
675 * _copy_to_iter_mcsafe - copy to user with source-read error exception handling
676 * @addr: source kernel address
677 * @bytes: total transfer length
678 * @iter: destination iterator
679 *
680 * The pmem driver arranges for filesystem-dax to use this facility via
681 * dax_copy_to_iter() for protecting read/write to persistent memory.
682 * Unless / until an architecture can guarantee identical performance
683 * between _copy_to_iter_mcsafe() and _copy_to_iter() it would be a
684 * performance regression to switch more users to the mcsafe version.
685 *
686 * Otherwise, the main differences between this and typical _copy_to_iter().
687 *
688 * * Typical tail/residue handling after a fault retries the copy
689 * byte-by-byte until the fault happens again. Re-triggering machine
690 * checks is potentially fatal so the implementation uses source
691 * alignment and poison alignment assumptions to avoid re-triggering
692 * hardware exceptions.
693 *
694 * * ITER_KVEC, ITER_PIPE, and ITER_BVEC can return short copies.
695 * Compare to copy_to_iter() where only ITER_IOVEC attempts might return
696 * a short copy.
697 *
698 * See MCSAFE_TEST for self-test.
699 */
700 size_t _copy_to_iter_mcsafe(const void *addr, size_t bytes, struct iov_iter *i)
701 {
702 const char *from = addr;
703 unsigned long rem, curr_addr, s_addr = (unsigned long) addr;
704
705 if (unlikely(iov_iter_is_pipe(i)))
706 return copy_pipe_to_iter_mcsafe(addr, bytes, i);
707 if (iter_is_iovec(i))
708 might_fault();
709 iterate_and_advance(i, bytes, v,
710 copyout_mcsafe(v.iov_base, (from += v.iov_len) - v.iov_len, v.iov_len),
711 ({
712 rem = memcpy_mcsafe_to_page(v.bv_page, v.bv_offset,
713 (from += v.bv_len) - v.bv_len, v.bv_len);
714 if (rem) {
715 curr_addr = (unsigned long) from;
716 bytes = curr_addr - s_addr - rem;
717 return bytes;
718 }
719 }),
720 ({
721 rem = memcpy_mcsafe(v.iov_base, (from += v.iov_len) - v.iov_len,
722 v.iov_len);
723 if (rem) {
724 curr_addr = (unsigned long) from;
725 bytes = curr_addr - s_addr - rem;
726 return bytes;
727 }
728 })
729 )
730
731 return bytes;
732 }
733 EXPORT_SYMBOL_GPL(_copy_to_iter_mcsafe);
734 #endif /* CONFIG_ARCH_HAS_UACCESS_MCSAFE */
735
736 size_t _copy_from_iter(void *addr, size_t bytes, struct iov_iter *i)
737 {
738 char *to = addr;
739 if (unlikely(iov_iter_is_pipe(i))) {
740 WARN_ON(1);
741 return 0;
742 }
743 if (iter_is_iovec(i))
744 might_fault();
745 iterate_and_advance(i, bytes, v,
746 copyin((to += v.iov_len) - v.iov_len, v.iov_base, v.iov_len),
747 memcpy_from_page((to += v.bv_len) - v.bv_len, v.bv_page,
748 v.bv_offset, v.bv_len),
749 memcpy((to += v.iov_len) - v.iov_len, v.iov_base, v.iov_len)
750 )
751
752 return bytes;
753 }
754 EXPORT_SYMBOL(_copy_from_iter);
755
756 bool _copy_from_iter_full(void *addr, size_t bytes, struct iov_iter *i)
757 {
758 char *to = addr;
759 if (unlikely(iov_iter_is_pipe(i))) {
760 WARN_ON(1);
761 return false;
762 }
763 if (unlikely(i->count < bytes))
764 return false;
765
766 if (iter_is_iovec(i))
767 might_fault();
768 iterate_all_kinds(i, bytes, v, ({
769 if (copyin((to += v.iov_len) - v.iov_len,
770 v.iov_base, v.iov_len))
771 return false;
772 0;}),
773 memcpy_from_page((to += v.bv_len) - v.bv_len, v.bv_page,
774 v.bv_offset, v.bv_len),
775 memcpy((to += v.iov_len) - v.iov_len, v.iov_base, v.iov_len)
776 )
777
778 iov_iter_advance(i, bytes);
779 return true;
780 }
781 EXPORT_SYMBOL(_copy_from_iter_full);
782
783 size_t _copy_from_iter_nocache(void *addr, size_t bytes, struct iov_iter *i)
784 {
785 char *to = addr;
786 if (unlikely(iov_iter_is_pipe(i))) {
787 WARN_ON(1);
788 return 0;
789 }
790 iterate_and_advance(i, bytes, v,
791 __copy_from_user_inatomic_nocache((to += v.iov_len) - v.iov_len,
792 v.iov_base, v.iov_len),
793 memcpy_from_page((to += v.bv_len) - v.bv_len, v.bv_page,
794 v.bv_offset, v.bv_len),
795 memcpy((to += v.iov_len) - v.iov_len, v.iov_base, v.iov_len)
796 )
797
798 return bytes;
799 }
800 EXPORT_SYMBOL(_copy_from_iter_nocache);
801
802 #ifdef CONFIG_ARCH_HAS_UACCESS_FLUSHCACHE
803 /**
804 * _copy_from_iter_flushcache - write destination through cpu cache
805 * @addr: destination kernel address
806 * @bytes: total transfer length
807 * @iter: source iterator
808 *
809 * The pmem driver arranges for filesystem-dax to use this facility via
810 * dax_copy_from_iter() for ensuring that writes to persistent memory
811 * are flushed through the CPU cache. It is differentiated from
812 * _copy_from_iter_nocache() in that guarantees all data is flushed for
813 * all iterator types. The _copy_from_iter_nocache() only attempts to
814 * bypass the cache for the ITER_IOVEC case, and on some archs may use
815 * instructions that strand dirty-data in the cache.
816 */
817 size_t _copy_from_iter_flushcache(void *addr, size_t bytes, struct iov_iter *i)
818 {
819 char *to = addr;
820 if (unlikely(iov_iter_is_pipe(i))) {
821 WARN_ON(1);
822 return 0;
823 }
824 iterate_and_advance(i, bytes, v,
825 __copy_from_user_flushcache((to += v.iov_len) - v.iov_len,
826 v.iov_base, v.iov_len),
827 memcpy_page_flushcache((to += v.bv_len) - v.bv_len, v.bv_page,
828 v.bv_offset, v.bv_len),
829 memcpy_flushcache((to += v.iov_len) - v.iov_len, v.iov_base,
830 v.iov_len)
831 )
832
833 return bytes;
834 }
835 EXPORT_SYMBOL_GPL(_copy_from_iter_flushcache);
836 #endif
837
838 bool _copy_from_iter_full_nocache(void *addr, size_t bytes, struct iov_iter *i)
839 {
840 char *to = addr;
841 if (unlikely(iov_iter_is_pipe(i))) {
842 WARN_ON(1);
843 return false;
844 }
845 if (unlikely(i->count < bytes))
846 return false;
847 iterate_all_kinds(i, bytes, v, ({
848 if (__copy_from_user_inatomic_nocache((to += v.iov_len) - v.iov_len,
849 v.iov_base, v.iov_len))
850 return false;
851 0;}),
852 memcpy_from_page((to += v.bv_len) - v.bv_len, v.bv_page,
853 v.bv_offset, v.bv_len),
854 memcpy((to += v.iov_len) - v.iov_len, v.iov_base, v.iov_len)
855 )
856
857 iov_iter_advance(i, bytes);
858 return true;
859 }
860 EXPORT_SYMBOL(_copy_from_iter_full_nocache);
861
862 static inline bool page_copy_sane(struct page *page, size_t offset, size_t n)
863 {
864 struct page *head = compound_head(page);
865 size_t v = n + offset + page_address(page) - page_address(head);
866
867 if (likely(n <= v && v <= (PAGE_SIZE << compound_order(head))))
868 return true;
869 WARN_ON(1);
870 return false;
871 }
872
873 size_t copy_page_to_iter(struct page *page, size_t offset, size_t bytes,
874 struct iov_iter *i)
875 {
876 if (unlikely(!page_copy_sane(page, offset, bytes)))
877 return 0;
878 if (i->type & (ITER_BVEC|ITER_KVEC)) {
879 void *kaddr = kmap_atomic(page);
880 size_t wanted = copy_to_iter(kaddr + offset, bytes, i);
881 kunmap_atomic(kaddr);
882 return wanted;
883 } else if (unlikely(iov_iter_is_discard(i)))
884 return bytes;
885 else if (likely(!iov_iter_is_pipe(i)))
886 return copy_page_to_iter_iovec(page, offset, bytes, i);
887 else
888 return copy_page_to_iter_pipe(page, offset, bytes, i);
889 }
890 EXPORT_SYMBOL(copy_page_to_iter);
891
892 size_t copy_page_from_iter(struct page *page, size_t offset, size_t bytes,
893 struct iov_iter *i)
894 {
895 if (unlikely(!page_copy_sane(page, offset, bytes)))
896 return 0;
897 if (unlikely(iov_iter_is_pipe(i) || iov_iter_is_discard(i))) {
898 WARN_ON(1);
899 return 0;
900 }
901 if (i->type & (ITER_BVEC|ITER_KVEC)) {
902 void *kaddr = kmap_atomic(page);
903 size_t wanted = _copy_from_iter(kaddr + offset, bytes, i);
904 kunmap_atomic(kaddr);
905 return wanted;
906 } else
907 return copy_page_from_iter_iovec(page, offset, bytes, i);
908 }
909 EXPORT_SYMBOL(copy_page_from_iter);
910
911 static size_t pipe_zero(size_t bytes, struct iov_iter *i)
912 {
913 struct pipe_inode_info *pipe = i->pipe;
914 size_t n, off;
915 int idx;
916
917 if (!sanity(i))
918 return 0;
919
920 bytes = n = push_pipe(i, bytes, &idx, &off);
921 if (unlikely(!n))
922 return 0;
923
924 for ( ; n; idx = next_idx(idx, pipe), off = 0) {
925 size_t chunk = min_t(size_t, n, PAGE_SIZE - off);
926 memzero_page(pipe->bufs[idx].page, off, chunk);
927 i->idx = idx;
928 i->iov_offset = off + chunk;
929 n -= chunk;
930 }
931 i->count -= bytes;
932 return bytes;
933 }
934
935 size_t iov_iter_zero(size_t bytes, struct iov_iter *i)
936 {
937 if (unlikely(iov_iter_is_pipe(i)))
938 return pipe_zero(bytes, i);
939 iterate_and_advance(i, bytes, v,
940 clear_user(v.iov_base, v.iov_len),
941 memzero_page(v.bv_page, v.bv_offset, v.bv_len),
942 memset(v.iov_base, 0, v.iov_len)
943 )
944
945 return bytes;
946 }
947 EXPORT_SYMBOL(iov_iter_zero);
948
949 size_t iov_iter_copy_from_user_atomic(struct page *page,
950 struct iov_iter *i, unsigned long offset, size_t bytes)
951 {
952 char *kaddr = kmap_atomic(page), *p = kaddr + offset;
953 if (unlikely(!page_copy_sane(page, offset, bytes))) {
954 kunmap_atomic(kaddr);
955 return 0;
956 }
957 if (unlikely(iov_iter_is_pipe(i) || iov_iter_is_discard(i))) {
958 kunmap_atomic(kaddr);
959 WARN_ON(1);
960 return 0;
961 }
962 iterate_all_kinds(i, bytes, v,
963 copyin((p += v.iov_len) - v.iov_len, v.iov_base, v.iov_len),
964 memcpy_from_page((p += v.bv_len) - v.bv_len, v.bv_page,
965 v.bv_offset, v.bv_len),
966 memcpy((p += v.iov_len) - v.iov_len, v.iov_base, v.iov_len)
967 )
968 kunmap_atomic(kaddr);
969 return bytes;
970 }
971 EXPORT_SYMBOL(iov_iter_copy_from_user_atomic);
972
973 static inline void pipe_truncate(struct iov_iter *i)
974 {
975 struct pipe_inode_info *pipe = i->pipe;
976 if (pipe->nrbufs) {
977 size_t off = i->iov_offset;
978 int idx = i->idx;
979 int nrbufs = (idx - pipe->curbuf) & (pipe->buffers - 1);
980 if (off) {
981 pipe->bufs[idx].len = off - pipe->bufs[idx].offset;
982 idx = next_idx(idx, pipe);
983 nrbufs++;
984 }
985 while (pipe->nrbufs > nrbufs) {
986 pipe_buf_release(pipe, &pipe->bufs[idx]);
987 idx = next_idx(idx, pipe);
988 pipe->nrbufs--;
989 }
990 }
991 }
992
993 static void pipe_advance(struct iov_iter *i, size_t size)
994 {
995 struct pipe_inode_info *pipe = i->pipe;
996 if (unlikely(i->count < size))
997 size = i->count;
998 if (size) {
999 struct pipe_buffer *buf;
1000 size_t off = i->iov_offset, left = size;
1001 int idx = i->idx;
1002 if (off) /* make it relative to the beginning of buffer */
1003 left += off - pipe->bufs[idx].offset;
1004 while (1) {
1005 buf = &pipe->bufs[idx];
1006 if (left <= buf->len)
1007 break;
1008 left -= buf->len;
1009 idx = next_idx(idx, pipe);
1010 }
1011 i->idx = idx;
1012 i->iov_offset = buf->offset + left;
1013 }
1014 i->count -= size;
1015 /* ... and discard everything past that point */
1016 pipe_truncate(i);
1017 }
1018
1019 void iov_iter_advance(struct iov_iter *i, size_t size)
1020 {
1021 if (unlikely(iov_iter_is_pipe(i))) {
1022 pipe_advance(i, size);
1023 return;
1024 }
1025 if (unlikely(iov_iter_is_discard(i))) {
1026 i->count -= size;
1027 return;
1028 }
1029 iterate_and_advance(i, size, v, 0, 0, 0)
1030 }
1031 EXPORT_SYMBOL(iov_iter_advance);
1032
1033 void iov_iter_revert(struct iov_iter *i, size_t unroll)
1034 {
1035 if (!unroll)
1036 return;
1037 if (WARN_ON(unroll > MAX_RW_COUNT))
1038 return;
1039 i->count += unroll;
1040 if (unlikely(iov_iter_is_pipe(i))) {
1041 struct pipe_inode_info *pipe = i->pipe;
1042 int idx = i->idx;
1043 size_t off = i->iov_offset;
1044 while (1) {
1045 size_t n = off - pipe->bufs[idx].offset;
1046 if (unroll < n) {
1047 off -= unroll;
1048 break;
1049 }
1050 unroll -= n;
1051 if (!unroll && idx == i->start_idx) {
1052 off = 0;
1053 break;
1054 }
1055 if (!idx--)
1056 idx = pipe->buffers - 1;
1057 off = pipe->bufs[idx].offset + pipe->bufs[idx].len;
1058 }
1059 i->iov_offset = off;
1060 i->idx = idx;
1061 pipe_truncate(i);
1062 return;
1063 }
1064 if (unlikely(iov_iter_is_discard(i)))
1065 return;
1066 if (unroll <= i->iov_offset) {
1067 i->iov_offset -= unroll;
1068 return;
1069 }
1070 unroll -= i->iov_offset;
1071 if (iov_iter_is_bvec(i)) {
1072 const struct bio_vec *bvec = i->bvec;
1073 while (1) {
1074 size_t n = (--bvec)->bv_len;
1075 i->nr_segs++;
1076 if (unroll <= n) {
1077 i->bvec = bvec;
1078 i->iov_offset = n - unroll;
1079 return;
1080 }
1081 unroll -= n;
1082 }
1083 } else { /* same logics for iovec and kvec */
1084 const struct iovec *iov = i->iov;
1085 while (1) {
1086 size_t n = (--iov)->iov_len;
1087 i->nr_segs++;
1088 if (unroll <= n) {
1089 i->iov = iov;
1090 i->iov_offset = n - unroll;
1091 return;
1092 }
1093 unroll -= n;
1094 }
1095 }
1096 }
1097 EXPORT_SYMBOL(iov_iter_revert);
1098
1099 /*
1100 * Return the count of just the current iov_iter segment.
1101 */
1102 size_t iov_iter_single_seg_count(const struct iov_iter *i)
1103 {
1104 if (unlikely(iov_iter_is_pipe(i)))
1105 return i->count; // it is a silly place, anyway
1106 if (i->nr_segs == 1)
1107 return i->count;
1108 if (unlikely(iov_iter_is_discard(i)))
1109 return i->count;
1110 else if (iov_iter_is_bvec(i))
1111 return min(i->count, i->bvec->bv_len - i->iov_offset);
1112 else
1113 return min(i->count, i->iov->iov_len - i->iov_offset);
1114 }
1115 EXPORT_SYMBOL(iov_iter_single_seg_count);
1116
1117 void iov_iter_kvec(struct iov_iter *i, unsigned int direction,
1118 const struct kvec *kvec, unsigned long nr_segs,
1119 size_t count)
1120 {
1121 WARN_ON(direction & ~(READ | WRITE));
1122 i->type = ITER_KVEC | (direction & (READ | WRITE));
1123 i->kvec = kvec;
1124 i->nr_segs = nr_segs;
1125 i->iov_offset = 0;
1126 i->count = count;
1127 }
1128 EXPORT_SYMBOL(iov_iter_kvec);
1129
1130 void iov_iter_bvec(struct iov_iter *i, unsigned int direction,
1131 const struct bio_vec *bvec, unsigned long nr_segs,
1132 size_t count)
1133 {
1134 WARN_ON(direction & ~(READ | WRITE));
1135 i->type = ITER_BVEC | (direction & (READ | WRITE));
1136 i->bvec = bvec;
1137 i->nr_segs = nr_segs;
1138 i->iov_offset = 0;
1139 i->count = count;
1140 }
1141 EXPORT_SYMBOL(iov_iter_bvec);
1142
1143 void iov_iter_pipe(struct iov_iter *i, unsigned int direction,
1144 struct pipe_inode_info *pipe,
1145 size_t count)
1146 {
1147 BUG_ON(direction != READ);
1148 WARN_ON(pipe->nrbufs == pipe->buffers);
1149 i->type = ITER_PIPE | READ;
1150 i->pipe = pipe;
1151 i->idx = (pipe->curbuf + pipe->nrbufs) & (pipe->buffers - 1);
1152 i->iov_offset = 0;
1153 i->count = count;
1154 i->start_idx = i->idx;
1155 }
1156 EXPORT_SYMBOL(iov_iter_pipe);
1157
1158 /**
1159 * iov_iter_discard - Initialise an I/O iterator that discards data
1160 * @i: The iterator to initialise.
1161 * @direction: The direction of the transfer.
1162 * @count: The size of the I/O buffer in bytes.
1163 *
1164 * Set up an I/O iterator that just discards everything that's written to it.
1165 * It's only available as a READ iterator.
1166 */
1167 void iov_iter_discard(struct iov_iter *i, unsigned int direction, size_t count)
1168 {
1169 BUG_ON(direction != READ);
1170 i->type = ITER_DISCARD | READ;
1171 i->count = count;
1172 i->iov_offset = 0;
1173 }
1174 EXPORT_SYMBOL(iov_iter_discard);
1175
1176 unsigned long iov_iter_alignment(const struct iov_iter *i)
1177 {
1178 unsigned long res = 0;
1179 size_t size = i->count;
1180
1181 if (unlikely(iov_iter_is_pipe(i))) {
1182 if (size && i->iov_offset && allocated(&i->pipe->bufs[i->idx]))
1183 return size | i->iov_offset;
1184 return size;
1185 }
1186 iterate_all_kinds(i, size, v,
1187 (res |= (unsigned long)v.iov_base | v.iov_len, 0),
1188 res |= v.bv_offset | v.bv_len,
1189 res |= (unsigned long)v.iov_base | v.iov_len
1190 )
1191 return res;
1192 }
1193 EXPORT_SYMBOL(iov_iter_alignment);
1194
1195 unsigned long iov_iter_gap_alignment(const struct iov_iter *i)
1196 {
1197 unsigned long res = 0;
1198 size_t size = i->count;
1199
1200 if (unlikely(iov_iter_is_pipe(i) || iov_iter_is_discard(i))) {
1201 WARN_ON(1);
1202 return ~0U;
1203 }
1204
1205 iterate_all_kinds(i, size, v,
1206 (res |= (!res ? 0 : (unsigned long)v.iov_base) |
1207 (size != v.iov_len ? size : 0), 0),
1208 (res |= (!res ? 0 : (unsigned long)v.bv_offset) |
1209 (size != v.bv_len ? size : 0)),
1210 (res |= (!res ? 0 : (unsigned long)v.iov_base) |
1211 (size != v.iov_len ? size : 0))
1212 );
1213 return res;
1214 }
1215 EXPORT_SYMBOL(iov_iter_gap_alignment);
1216
1217 static inline ssize_t __pipe_get_pages(struct iov_iter *i,
1218 size_t maxsize,
1219 struct page **pages,
1220 int idx,
1221 size_t *start)
1222 {
1223 struct pipe_inode_info *pipe = i->pipe;
1224 ssize_t n = push_pipe(i, maxsize, &idx, start);
1225 if (!n)
1226 return -EFAULT;
1227
1228 maxsize = n;
1229 n += *start;
1230 while (n > 0) {
1231 get_page(*pages++ = pipe->bufs[idx].page);
1232 idx = next_idx(idx, pipe);
1233 n -= PAGE_SIZE;
1234 }
1235
1236 return maxsize;
1237 }
1238
1239 static ssize_t pipe_get_pages(struct iov_iter *i,
1240 struct page **pages, size_t maxsize, unsigned maxpages,
1241 size_t *start)
1242 {
1243 unsigned npages;
1244 size_t capacity;
1245 int idx;
1246
1247 if (!maxsize)
1248 return 0;
1249
1250 if (!sanity(i))
1251 return -EFAULT;
1252
1253 data_start(i, &idx, start);
1254 /* some of this one + all after this one */
1255 npages = ((i->pipe->curbuf - idx - 1) & (i->pipe->buffers - 1)) + 1;
1256 capacity = min(npages,maxpages) * PAGE_SIZE - *start;
1257
1258 return __pipe_get_pages(i, min(maxsize, capacity), pages, idx, start);
1259 }
1260
1261 ssize_t iov_iter_get_pages(struct iov_iter *i,
1262 struct page **pages, size_t maxsize, unsigned maxpages,
1263 size_t *start)
1264 {
1265 if (maxsize > i->count)
1266 maxsize = i->count;
1267
1268 if (unlikely(iov_iter_is_pipe(i)))
1269 return pipe_get_pages(i, pages, maxsize, maxpages, start);
1270 if (unlikely(iov_iter_is_discard(i)))
1271 return -EFAULT;
1272
1273 iterate_all_kinds(i, maxsize, v, ({
1274 unsigned long addr = (unsigned long)v.iov_base;
1275 size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1));
1276 int n;
1277 int res;
1278
1279 if (len > maxpages * PAGE_SIZE)
1280 len = maxpages * PAGE_SIZE;
1281 addr &= ~(PAGE_SIZE - 1);
1282 n = DIV_ROUND_UP(len, PAGE_SIZE);
1283 res = get_user_pages_fast(addr, n, iov_iter_rw(i) != WRITE, pages);
1284 if (unlikely(res < 0))
1285 return res;
1286 return (res == n ? len : res * PAGE_SIZE) - *start;
1287 0;}),({
1288 /* can't be more than PAGE_SIZE */
1289 *start = v.bv_offset;
1290 get_page(*pages = v.bv_page);
1291 return v.bv_len;
1292 }),({
1293 return -EFAULT;
1294 })
1295 )
1296 return 0;
1297 }
1298 EXPORT_SYMBOL(iov_iter_get_pages);
1299
1300 static struct page **get_pages_array(size_t n)
1301 {
1302 return kvmalloc_array(n, sizeof(struct page *), GFP_KERNEL);
1303 }
1304
1305 static ssize_t pipe_get_pages_alloc(struct iov_iter *i,
1306 struct page ***pages, size_t maxsize,
1307 size_t *start)
1308 {
1309 struct page **p;
1310 ssize_t n;
1311 int idx;
1312 int npages;
1313
1314 if (!maxsize)
1315 return 0;
1316
1317 if (!sanity(i))
1318 return -EFAULT;
1319
1320 data_start(i, &idx, start);
1321 /* some of this one + all after this one */
1322 npages = ((i->pipe->curbuf - idx - 1) & (i->pipe->buffers - 1)) + 1;
1323 n = npages * PAGE_SIZE - *start;
1324 if (maxsize > n)
1325 maxsize = n;
1326 else
1327 npages = DIV_ROUND_UP(maxsize + *start, PAGE_SIZE);
1328 p = get_pages_array(npages);
1329 if (!p)
1330 return -ENOMEM;
1331 n = __pipe_get_pages(i, maxsize, p, idx, start);
1332 if (n > 0)
1333 *pages = p;
1334 else
1335 kvfree(p);
1336 return n;
1337 }
1338
1339 ssize_t iov_iter_get_pages_alloc(struct iov_iter *i,
1340 struct page ***pages, size_t maxsize,
1341 size_t *start)
1342 {
1343 struct page **p;
1344
1345 if (maxsize > i->count)
1346 maxsize = i->count;
1347
1348 if (unlikely(iov_iter_is_pipe(i)))
1349 return pipe_get_pages_alloc(i, pages, maxsize, start);
1350 if (unlikely(iov_iter_is_discard(i)))
1351 return -EFAULT;
1352
1353 iterate_all_kinds(i, maxsize, v, ({
1354 unsigned long addr = (unsigned long)v.iov_base;
1355 size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1));
1356 int n;
1357 int res;
1358
1359 addr &= ~(PAGE_SIZE - 1);
1360 n = DIV_ROUND_UP(len, PAGE_SIZE);
1361 p = get_pages_array(n);
1362 if (!p)
1363 return -ENOMEM;
1364 res = get_user_pages_fast(addr, n, iov_iter_rw(i) != WRITE, p);
1365 if (unlikely(res < 0)) {
1366 kvfree(p);
1367 return res;
1368 }
1369 *pages = p;
1370 return (res == n ? len : res * PAGE_SIZE) - *start;
1371 0;}),({
1372 /* can't be more than PAGE_SIZE */
1373 *start = v.bv_offset;
1374 *pages = p = get_pages_array(1);
1375 if (!p)
1376 return -ENOMEM;
1377 get_page(*p = v.bv_page);
1378 return v.bv_len;
1379 }),({
1380 return -EFAULT;
1381 })
1382 )
1383 return 0;
1384 }
1385 EXPORT_SYMBOL(iov_iter_get_pages_alloc);
1386
1387 size_t csum_and_copy_from_iter(void *addr, size_t bytes, __wsum *csum,
1388 struct iov_iter *i)
1389 {
1390 char *to = addr;
1391 __wsum sum, next;
1392 size_t off = 0;
1393 sum = *csum;
1394 if (unlikely(iov_iter_is_pipe(i) || iov_iter_is_discard(i))) {
1395 WARN_ON(1);
1396 return 0;
1397 }
1398 iterate_and_advance(i, bytes, v, ({
1399 int err = 0;
1400 next = csum_and_copy_from_user(v.iov_base,
1401 (to += v.iov_len) - v.iov_len,
1402 v.iov_len, 0, &err);
1403 if (!err) {
1404 sum = csum_block_add(sum, next, off);
1405 off += v.iov_len;
1406 }
1407 err ? v.iov_len : 0;
1408 }), ({
1409 char *p = kmap_atomic(v.bv_page);
1410 sum = csum_and_memcpy((to += v.bv_len) - v.bv_len,
1411 p + v.bv_offset, v.bv_len,
1412 sum, off);
1413 kunmap_atomic(p);
1414 off += v.bv_len;
1415 }),({
1416 sum = csum_and_memcpy((to += v.iov_len) - v.iov_len,
1417 v.iov_base, v.iov_len,
1418 sum, off);
1419 off += v.iov_len;
1420 })
1421 )
1422 *csum = sum;
1423 return bytes;
1424 }
1425 EXPORT_SYMBOL(csum_and_copy_from_iter);
1426
1427 bool csum_and_copy_from_iter_full(void *addr, size_t bytes, __wsum *csum,
1428 struct iov_iter *i)
1429 {
1430 char *to = addr;
1431 __wsum sum, next;
1432 size_t off = 0;
1433 sum = *csum;
1434 if (unlikely(iov_iter_is_pipe(i) || iov_iter_is_discard(i))) {
1435 WARN_ON(1);
1436 return false;
1437 }
1438 if (unlikely(i->count < bytes))
1439 return false;
1440 iterate_all_kinds(i, bytes, v, ({
1441 int err = 0;
1442 next = csum_and_copy_from_user(v.iov_base,
1443 (to += v.iov_len) - v.iov_len,
1444 v.iov_len, 0, &err);
1445 if (err)
1446 return false;
1447 sum = csum_block_add(sum, next, off);
1448 off += v.iov_len;
1449 0;
1450 }), ({
1451 char *p = kmap_atomic(v.bv_page);
1452 sum = csum_and_memcpy((to += v.bv_len) - v.bv_len,
1453 p + v.bv_offset, v.bv_len,
1454 sum, off);
1455 kunmap_atomic(p);
1456 off += v.bv_len;
1457 }),({
1458 sum = csum_and_memcpy((to += v.iov_len) - v.iov_len,
1459 v.iov_base, v.iov_len,
1460 sum, off);
1461 off += v.iov_len;
1462 })
1463 )
1464 *csum = sum;
1465 iov_iter_advance(i, bytes);
1466 return true;
1467 }
1468 EXPORT_SYMBOL(csum_and_copy_from_iter_full);
1469
1470 size_t csum_and_copy_to_iter(const void *addr, size_t bytes, void *csump,
1471 struct iov_iter *i)
1472 {
1473 const char *from = addr;
1474 __wsum *csum = csump;
1475 __wsum sum, next;
1476 size_t off = 0;
1477
1478 if (unlikely(iov_iter_is_pipe(i)))
1479 return csum_and_copy_to_pipe_iter(addr, bytes, csum, i);
1480
1481 sum = *csum;
1482 if (unlikely(iov_iter_is_discard(i))) {
1483 WARN_ON(1); /* for now */
1484 return 0;
1485 }
1486 iterate_and_advance(i, bytes, v, ({
1487 int err = 0;
1488 next = csum_and_copy_to_user((from += v.iov_len) - v.iov_len,
1489 v.iov_base,
1490 v.iov_len, 0, &err);
1491 if (!err) {
1492 sum = csum_block_add(sum, next, off);
1493 off += v.iov_len;
1494 }
1495 err ? v.iov_len : 0;
1496 }), ({
1497 char *p = kmap_atomic(v.bv_page);
1498 sum = csum_and_memcpy(p + v.bv_offset,
1499 (from += v.bv_len) - v.bv_len,
1500 v.bv_len, sum, off);
1501 kunmap_atomic(p);
1502 off += v.bv_len;
1503 }),({
1504 sum = csum_and_memcpy(v.iov_base,
1505 (from += v.iov_len) - v.iov_len,
1506 v.iov_len, sum, off);
1507 off += v.iov_len;
1508 })
1509 )
1510 *csum = sum;
1511 return bytes;
1512 }
1513 EXPORT_SYMBOL(csum_and_copy_to_iter);
1514
1515 size_t hash_and_copy_to_iter(const void *addr, size_t bytes, void *hashp,
1516 struct iov_iter *i)
1517 {
1518 struct ahash_request *hash = hashp;
1519 struct scatterlist sg;
1520 size_t copied;
1521
1522 copied = copy_to_iter(addr, bytes, i);
1523 sg_init_one(&sg, addr, copied);
1524 ahash_request_set_crypt(hash, &sg, NULL, copied);
1525 crypto_ahash_update(hash);
1526 return copied;
1527 }
1528 EXPORT_SYMBOL(hash_and_copy_to_iter);
1529
1530 int iov_iter_npages(const struct iov_iter *i, int maxpages)
1531 {
1532 size_t size = i->count;
1533 int npages = 0;
1534
1535 if (!size)
1536 return 0;
1537 if (unlikely(iov_iter_is_discard(i)))
1538 return 0;
1539
1540 if (unlikely(iov_iter_is_pipe(i))) {
1541 struct pipe_inode_info *pipe = i->pipe;
1542 size_t off;
1543 int idx;
1544
1545 if (!sanity(i))
1546 return 0;
1547
1548 data_start(i, &idx, &off);
1549 /* some of this one + all after this one */
1550 npages = ((pipe->curbuf - idx - 1) & (pipe->buffers - 1)) + 1;
1551 if (npages >= maxpages)
1552 return maxpages;
1553 } else iterate_all_kinds(i, size, v, ({
1554 unsigned long p = (unsigned long)v.iov_base;
1555 npages += DIV_ROUND_UP(p + v.iov_len, PAGE_SIZE)
1556 - p / PAGE_SIZE;
1557 if (npages >= maxpages)
1558 return maxpages;
1559 0;}),({
1560 npages++;
1561 if (npages >= maxpages)
1562 return maxpages;
1563 }),({
1564 unsigned long p = (unsigned long)v.iov_base;
1565 npages += DIV_ROUND_UP(p + v.iov_len, PAGE_SIZE)
1566 - p / PAGE_SIZE;
1567 if (npages >= maxpages)
1568 return maxpages;
1569 })
1570 )
1571 return npages;
1572 }
1573 EXPORT_SYMBOL(iov_iter_npages);
1574
1575 const void *dup_iter(struct iov_iter *new, struct iov_iter *old, gfp_t flags)
1576 {
1577 *new = *old;
1578 if (unlikely(iov_iter_is_pipe(new))) {
1579 WARN_ON(1);
1580 return NULL;
1581 }
1582 if (unlikely(iov_iter_is_discard(new)))
1583 return NULL;
1584 if (iov_iter_is_bvec(new))
1585 return new->bvec = kmemdup(new->bvec,
1586 new->nr_segs * sizeof(struct bio_vec),
1587 flags);
1588 else
1589 /* iovec and kvec have identical layout */
1590 return new->iov = kmemdup(new->iov,
1591 new->nr_segs * sizeof(struct iovec),
1592 flags);
1593 }
1594 EXPORT_SYMBOL(dup_iter);
1595
1596 /**
1597 * import_iovec() - Copy an array of &struct iovec from userspace
1598 * into the kernel, check that it is valid, and initialize a new
1599 * &struct iov_iter iterator to access it.
1600 *
1601 * @type: One of %READ or %WRITE.
1602 * @uvector: Pointer to the userspace array.
1603 * @nr_segs: Number of elements in userspace array.
1604 * @fast_segs: Number of elements in @iov.
1605 * @iov: (input and output parameter) Pointer to pointer to (usually small
1606 * on-stack) kernel array.
1607 * @i: Pointer to iterator that will be initialized on success.
1608 *
1609 * If the array pointed to by *@iov is large enough to hold all @nr_segs,
1610 * then this function places %NULL in *@iov on return. Otherwise, a new
1611 * array will be allocated and the result placed in *@iov. This means that
1612 * the caller may call kfree() on *@iov regardless of whether the small
1613 * on-stack array was used or not (and regardless of whether this function
1614 * returns an error or not).
1615 *
1616 * Return: 0 on success or negative error code on error.
1617 */
1618 int import_iovec(int type, const struct iovec __user * uvector,
1619 unsigned nr_segs, unsigned fast_segs,
1620 struct iovec **iov, struct iov_iter *i)
1621 {
1622 ssize_t n;
1623 struct iovec *p;
1624 n = rw_copy_check_uvector(type, uvector, nr_segs, fast_segs,
1625 *iov, &p);
1626 if (n < 0) {
1627 if (p != *iov)
1628 kfree(p);
1629 *iov = NULL;
1630 return n;
1631 }
1632 iov_iter_init(i, type, p, nr_segs, n);
1633 *iov = p == *iov ? NULL : p;
1634 return 0;
1635 }
1636 EXPORT_SYMBOL(import_iovec);
1637
1638 #ifdef CONFIG_COMPAT
1639 #include <linux/compat.h>
1640
1641 int compat_import_iovec(int type, const struct compat_iovec __user * uvector,
1642 unsigned nr_segs, unsigned fast_segs,
1643 struct iovec **iov, struct iov_iter *i)
1644 {
1645 ssize_t n;
1646 struct iovec *p;
1647 n = compat_rw_copy_check_uvector(type, uvector, nr_segs, fast_segs,
1648 *iov, &p);
1649 if (n < 0) {
1650 if (p != *iov)
1651 kfree(p);
1652 *iov = NULL;
1653 return n;
1654 }
1655 iov_iter_init(i, type, p, nr_segs, n);
1656 *iov = p == *iov ? NULL : p;
1657 return 0;
1658 }
1659 #endif
1660
1661 int import_single_range(int rw, void __user *buf, size_t len,
1662 struct iovec *iov, struct iov_iter *i)
1663 {
1664 if (len > MAX_RW_COUNT)
1665 len = MAX_RW_COUNT;
1666 if (unlikely(!access_ok(buf, len)))
1667 return -EFAULT;
1668
1669 iov->iov_base = buf;
1670 iov->iov_len = len;
1671 iov_iter_init(i, rw, iov, 1, len);
1672 return 0;
1673 }
1674 EXPORT_SYMBOL(import_single_range);
1675
1676 int iov_iter_for_each_range(struct iov_iter *i, size_t bytes,
1677 int (*f)(struct kvec *vec, void *context),
1678 void *context)
1679 {
1680 struct kvec w;
1681 int err = -EINVAL;
1682 if (!bytes)
1683 return 0;
1684
1685 iterate_all_kinds(i, bytes, v, -EINVAL, ({
1686 w.iov_base = kmap(v.bv_page) + v.bv_offset;
1687 w.iov_len = v.bv_len;
1688 err = f(&w, context);
1689 kunmap(v.bv_page);
1690 err;}), ({
1691 w = v;
1692 err = f(&w, context);})
1693 )
1694 return err;
1695 }
1696 EXPORT_SYMBOL(iov_iter_for_each_range);
A mirror of Linus' kernel repository