Merge tag 'iio-for-3.18a' of git://git.kernel.org/pub/scm/linux/kernel/git/jic23...
[sfrench/cifs-2.6.git] / mm / iov_iter.c
1 #include <linux/export.h>
2 #include <linux/uio.h>
3 #include <linux/pagemap.h>
4 #include <linux/slab.h>
5 #include <linux/vmalloc.h>
6
7 static size_t copy_page_to_iter_iovec(struct page *page, size_t offset, size_t bytes,
8                          struct iov_iter *i)
9 {
10         size_t skip, copy, left, wanted;
11         const struct iovec *iov;
12         char __user *buf;
13         void *kaddr, *from;
14
15         if (unlikely(bytes > i->count))
16                 bytes = i->count;
17
18         if (unlikely(!bytes))
19                 return 0;
20
21         wanted = bytes;
22         iov = i->iov;
23         skip = i->iov_offset;
24         buf = iov->iov_base + skip;
25         copy = min(bytes, iov->iov_len - skip);
26
27         if (!fault_in_pages_writeable(buf, copy)) {
28                 kaddr = kmap_atomic(page);
29                 from = kaddr + offset;
30
31                 /* first chunk, usually the only one */
32                 left = __copy_to_user_inatomic(buf, from, copy);
33                 copy -= left;
34                 skip += copy;
35                 from += copy;
36                 bytes -= copy;
37
38                 while (unlikely(!left && bytes)) {
39                         iov++;
40                         buf = iov->iov_base;
41                         copy = min(bytes, iov->iov_len);
42                         left = __copy_to_user_inatomic(buf, from, copy);
43                         copy -= left;
44                         skip = copy;
45                         from += copy;
46                         bytes -= copy;
47                 }
48                 if (likely(!bytes)) {
49                         kunmap_atomic(kaddr);
50                         goto done;
51                 }
52                 offset = from - kaddr;
53                 buf += copy;
54                 kunmap_atomic(kaddr);
55                 copy = min(bytes, iov->iov_len - skip);
56         }
57         /* Too bad - revert to non-atomic kmap */
58         kaddr = kmap(page);
59         from = kaddr + offset;
60         left = __copy_to_user(buf, from, copy);
61         copy -= left;
62         skip += copy;
63         from += copy;
64         bytes -= copy;
65         while (unlikely(!left && bytes)) {
66                 iov++;
67                 buf = iov->iov_base;
68                 copy = min(bytes, iov->iov_len);
69                 left = __copy_to_user(buf, from, copy);
70                 copy -= left;
71                 skip = copy;
72                 from += copy;
73                 bytes -= copy;
74         }
75         kunmap(page);
76 done:
77         if (skip == iov->iov_len) {
78                 iov++;
79                 skip = 0;
80         }
81         i->count -= wanted - bytes;
82         i->nr_segs -= iov - i->iov;
83         i->iov = iov;
84         i->iov_offset = skip;
85         return wanted - bytes;
86 }
87
88 static size_t copy_page_from_iter_iovec(struct page *page, size_t offset, size_t bytes,
89                          struct iov_iter *i)
90 {
91         size_t skip, copy, left, wanted;
92         const struct iovec *iov;
93         char __user *buf;
94         void *kaddr, *to;
95
96         if (unlikely(bytes > i->count))
97                 bytes = i->count;
98
99         if (unlikely(!bytes))
100                 return 0;
101
102         wanted = bytes;
103         iov = i->iov;
104         skip = i->iov_offset;
105         buf = iov->iov_base + skip;
106         copy = min(bytes, iov->iov_len - skip);
107
108         if (!fault_in_pages_readable(buf, copy)) {
109                 kaddr = kmap_atomic(page);
110                 to = kaddr + offset;
111
112                 /* first chunk, usually the only one */
113                 left = __copy_from_user_inatomic(to, buf, copy);
114                 copy -= left;
115                 skip += copy;
116                 to += copy;
117                 bytes -= copy;
118
119                 while (unlikely(!left && bytes)) {
120                         iov++;
121                         buf = iov->iov_base;
122                         copy = min(bytes, iov->iov_len);
123                         left = __copy_from_user_inatomic(to, buf, copy);
124                         copy -= left;
125                         skip = copy;
126                         to += copy;
127                         bytes -= copy;
128                 }
129                 if (likely(!bytes)) {
130                         kunmap_atomic(kaddr);
131                         goto done;
132                 }
133                 offset = to - kaddr;
134                 buf += copy;
135                 kunmap_atomic(kaddr);
136                 copy = min(bytes, iov->iov_len - skip);
137         }
138         /* Too bad - revert to non-atomic kmap */
139         kaddr = kmap(page);
140         to = kaddr + offset;
141         left = __copy_from_user(to, buf, copy);
142         copy -= left;
143         skip += copy;
144         to += copy;
145         bytes -= copy;
146         while (unlikely(!left && bytes)) {
147                 iov++;
148                 buf = iov->iov_base;
149                 copy = min(bytes, iov->iov_len);
150                 left = __copy_from_user(to, buf, copy);
151                 copy -= left;
152                 skip = copy;
153                 to += copy;
154                 bytes -= copy;
155         }
156         kunmap(page);
157 done:
158         if (skip == iov->iov_len) {
159                 iov++;
160                 skip = 0;
161         }
162         i->count -= wanted - bytes;
163         i->nr_segs -= iov - i->iov;
164         i->iov = iov;
165         i->iov_offset = skip;
166         return wanted - bytes;
167 }
168
169 static size_t __iovec_copy_from_user_inatomic(char *vaddr,
170                         const struct iovec *iov, size_t base, size_t bytes)
171 {
172         size_t copied = 0, left = 0;
173
174         while (bytes) {
175                 char __user *buf = iov->iov_base + base;
176                 int copy = min(bytes, iov->iov_len - base);
177
178                 base = 0;
179                 left = __copy_from_user_inatomic(vaddr, buf, copy);
180                 copied += copy;
181                 bytes -= copy;
182                 vaddr += copy;
183                 iov++;
184
185                 if (unlikely(left))
186                         break;
187         }
188         return copied - left;
189 }
190
191 /*
192  * Copy as much as we can into the page and return the number of bytes which
193  * were successfully copied.  If a fault is encountered then return the number of
194  * bytes which were copied.
195  */
196 static size_t copy_from_user_atomic_iovec(struct page *page,
197                 struct iov_iter *i, unsigned long offset, size_t bytes)
198 {
199         char *kaddr;
200         size_t copied;
201
202         kaddr = kmap_atomic(page);
203         if (likely(i->nr_segs == 1)) {
204                 int left;
205                 char __user *buf = i->iov->iov_base + i->iov_offset;
206                 left = __copy_from_user_inatomic(kaddr + offset, buf, bytes);
207                 copied = bytes - left;
208         } else {
209                 copied = __iovec_copy_from_user_inatomic(kaddr + offset,
210                                                 i->iov, i->iov_offset, bytes);
211         }
212         kunmap_atomic(kaddr);
213
214         return copied;
215 }
216
217 static void advance_iovec(struct iov_iter *i, size_t bytes)
218 {
219         BUG_ON(i->count < bytes);
220
221         if (likely(i->nr_segs == 1)) {
222                 i->iov_offset += bytes;
223                 i->count -= bytes;
224         } else {
225                 const struct iovec *iov = i->iov;
226                 size_t base = i->iov_offset;
227                 unsigned long nr_segs = i->nr_segs;
228
229                 /*
230                  * The !iov->iov_len check ensures we skip over unlikely
231                  * zero-length segments (without overruning the iovec).
232                  */
233                 while (bytes || unlikely(i->count && !iov->iov_len)) {
234                         int copy;
235
236                         copy = min(bytes, iov->iov_len - base);
237                         BUG_ON(!i->count || i->count < copy);
238                         i->count -= copy;
239                         bytes -= copy;
240                         base += copy;
241                         if (iov->iov_len == base) {
242                                 iov++;
243                                 nr_segs--;
244                                 base = 0;
245                         }
246                 }
247                 i->iov = iov;
248                 i->iov_offset = base;
249                 i->nr_segs = nr_segs;
250         }
251 }
252
253 /*
254  * Fault in the first iovec of the given iov_iter, to a maximum length
255  * of bytes. Returns 0 on success, or non-zero if the memory could not be
256  * accessed (ie. because it is an invalid address).
257  *
258  * writev-intensive code may want this to prefault several iovecs -- that
259  * would be possible (callers must not rely on the fact that _only_ the
260  * first iovec will be faulted with the current implementation).
261  */
262 int iov_iter_fault_in_readable(struct iov_iter *i, size_t bytes)
263 {
264         if (!(i->type & ITER_BVEC)) {
265                 char __user *buf = i->iov->iov_base + i->iov_offset;
266                 bytes = min(bytes, i->iov->iov_len - i->iov_offset);
267                 return fault_in_pages_readable(buf, bytes);
268         }
269         return 0;
270 }
271 EXPORT_SYMBOL(iov_iter_fault_in_readable);
272
273 static unsigned long alignment_iovec(const struct iov_iter *i)
274 {
275         const struct iovec *iov = i->iov;
276         unsigned long res;
277         size_t size = i->count;
278         size_t n;
279
280         if (!size)
281                 return 0;
282
283         res = (unsigned long)iov->iov_base + i->iov_offset;
284         n = iov->iov_len - i->iov_offset;
285         if (n >= size)
286                 return res | size;
287         size -= n;
288         res |= n;
289         while (size > (++iov)->iov_len) {
290                 res |= (unsigned long)iov->iov_base | iov->iov_len;
291                 size -= iov->iov_len;
292         }
293         res |= (unsigned long)iov->iov_base | size;
294         return res;
295 }
296
297 void iov_iter_init(struct iov_iter *i, int direction,
298                         const struct iovec *iov, unsigned long nr_segs,
299                         size_t count)
300 {
301         /* It will get better.  Eventually... */
302         if (segment_eq(get_fs(), KERNEL_DS))
303                 direction |= ITER_KVEC;
304         i->type = direction;
305         i->iov = iov;
306         i->nr_segs = nr_segs;
307         i->iov_offset = 0;
308         i->count = count;
309 }
310 EXPORT_SYMBOL(iov_iter_init);
311
312 static ssize_t get_pages_iovec(struct iov_iter *i,
313                    struct page **pages, unsigned maxpages,
314                    size_t *start)
315 {
316         size_t offset = i->iov_offset;
317         const struct iovec *iov = i->iov;
318         size_t len;
319         unsigned long addr;
320         int n;
321         int res;
322
323         len = iov->iov_len - offset;
324         if (len > i->count)
325                 len = i->count;
326         addr = (unsigned long)iov->iov_base + offset;
327         len += *start = addr & (PAGE_SIZE - 1);
328         if (len > maxpages * PAGE_SIZE)
329                 len = maxpages * PAGE_SIZE;
330         addr &= ~(PAGE_SIZE - 1);
331         n = (len + PAGE_SIZE - 1) / PAGE_SIZE;
332         res = get_user_pages_fast(addr, n, (i->type & WRITE) != WRITE, pages);
333         if (unlikely(res < 0))
334                 return res;
335         return (res == n ? len : res * PAGE_SIZE) - *start;
336 }
337
338 static ssize_t get_pages_alloc_iovec(struct iov_iter *i,
339                    struct page ***pages, size_t maxsize,
340                    size_t *start)
341 {
342         size_t offset = i->iov_offset;
343         const struct iovec *iov = i->iov;
344         size_t len;
345         unsigned long addr;
346         void *p;
347         int n;
348         int res;
349
350         len = iov->iov_len - offset;
351         if (len > i->count)
352                 len = i->count;
353         if (len > maxsize)
354                 len = maxsize;
355         addr = (unsigned long)iov->iov_base + offset;
356         len += *start = addr & (PAGE_SIZE - 1);
357         addr &= ~(PAGE_SIZE - 1);
358         n = (len + PAGE_SIZE - 1) / PAGE_SIZE;
359         
360         p = kmalloc(n * sizeof(struct page *), GFP_KERNEL);
361         if (!p)
362                 p = vmalloc(n * sizeof(struct page *));
363         if (!p)
364                 return -ENOMEM;
365
366         res = get_user_pages_fast(addr, n, (i->type & WRITE) != WRITE, p);
367         if (unlikely(res < 0)) {
368                 kvfree(p);
369                 return res;
370         }
371         *pages = p;
372         return (res == n ? len : res * PAGE_SIZE) - *start;
373 }
374
375 static int iov_iter_npages_iovec(const struct iov_iter *i, int maxpages)
376 {
377         size_t offset = i->iov_offset;
378         size_t size = i->count;
379         const struct iovec *iov = i->iov;
380         int npages = 0;
381         int n;
382
383         for (n = 0; size && n < i->nr_segs; n++, iov++) {
384                 unsigned long addr = (unsigned long)iov->iov_base + offset;
385                 size_t len = iov->iov_len - offset;
386                 offset = 0;
387                 if (unlikely(!len))     /* empty segment */
388                         continue;
389                 if (len > size)
390                         len = size;
391                 npages += (addr + len + PAGE_SIZE - 1) / PAGE_SIZE
392                           - addr / PAGE_SIZE;
393                 if (npages >= maxpages) /* don't bother going further */
394                         return maxpages;
395                 size -= len;
396                 offset = 0;
397         }
398         return min(npages, maxpages);
399 }
400
401 static void memcpy_from_page(char *to, struct page *page, size_t offset, size_t len)
402 {
403         char *from = kmap_atomic(page);
404         memcpy(to, from + offset, len);
405         kunmap_atomic(from);
406 }
407
408 static void memcpy_to_page(struct page *page, size_t offset, char *from, size_t len)
409 {
410         char *to = kmap_atomic(page);
411         memcpy(to + offset, from, len);
412         kunmap_atomic(to);
413 }
414
415 static size_t copy_page_to_iter_bvec(struct page *page, size_t offset, size_t bytes,
416                          struct iov_iter *i)
417 {
418         size_t skip, copy, wanted;
419         const struct bio_vec *bvec;
420         void *kaddr, *from;
421
422         if (unlikely(bytes > i->count))
423                 bytes = i->count;
424
425         if (unlikely(!bytes))
426                 return 0;
427
428         wanted = bytes;
429         bvec = i->bvec;
430         skip = i->iov_offset;
431         copy = min_t(size_t, bytes, bvec->bv_len - skip);
432
433         kaddr = kmap_atomic(page);
434         from = kaddr + offset;
435         memcpy_to_page(bvec->bv_page, skip + bvec->bv_offset, from, copy);
436         skip += copy;
437         from += copy;
438         bytes -= copy;
439         while (bytes) {
440                 bvec++;
441                 copy = min(bytes, (size_t)bvec->bv_len);
442                 memcpy_to_page(bvec->bv_page, bvec->bv_offset, from, copy);
443                 skip = copy;
444                 from += copy;
445                 bytes -= copy;
446         }
447         kunmap_atomic(kaddr);
448         if (skip == bvec->bv_len) {
449                 bvec++;
450                 skip = 0;
451         }
452         i->count -= wanted - bytes;
453         i->nr_segs -= bvec - i->bvec;
454         i->bvec = bvec;
455         i->iov_offset = skip;
456         return wanted - bytes;
457 }
458
459 static size_t copy_page_from_iter_bvec(struct page *page, size_t offset, size_t bytes,
460                          struct iov_iter *i)
461 {
462         size_t skip, copy, wanted;
463         const struct bio_vec *bvec;
464         void *kaddr, *to;
465
466         if (unlikely(bytes > i->count))
467                 bytes = i->count;
468
469         if (unlikely(!bytes))
470                 return 0;
471
472         wanted = bytes;
473         bvec = i->bvec;
474         skip = i->iov_offset;
475
476         kaddr = kmap_atomic(page);
477
478         to = kaddr + offset;
479
480         copy = min(bytes, bvec->bv_len - skip);
481
482         memcpy_from_page(to, bvec->bv_page, bvec->bv_offset + skip, copy);
483
484         to += copy;
485         skip += copy;
486         bytes -= copy;
487
488         while (bytes) {
489                 bvec++;
490                 copy = min(bytes, (size_t)bvec->bv_len);
491                 memcpy_from_page(to, bvec->bv_page, bvec->bv_offset, copy);
492                 skip = copy;
493                 to += copy;
494                 bytes -= copy;
495         }
496         kunmap_atomic(kaddr);
497         if (skip == bvec->bv_len) {
498                 bvec++;
499                 skip = 0;
500         }
501         i->count -= wanted;
502         i->nr_segs -= bvec - i->bvec;
503         i->bvec = bvec;
504         i->iov_offset = skip;
505         return wanted;
506 }
507
508 static size_t copy_from_user_bvec(struct page *page,
509                 struct iov_iter *i, unsigned long offset, size_t bytes)
510 {
511         char *kaddr;
512         size_t left;
513         const struct bio_vec *bvec;
514         size_t base = i->iov_offset;
515
516         kaddr = kmap_atomic(page);
517         for (left = bytes, bvec = i->bvec; left; bvec++, base = 0) {
518                 size_t copy = min(left, bvec->bv_len - base);
519                 if (!bvec->bv_len)
520                         continue;
521                 memcpy_from_page(kaddr + offset, bvec->bv_page,
522                                  bvec->bv_offset + base, copy);
523                 offset += copy;
524                 left -= copy;
525         }
526         kunmap_atomic(kaddr);
527         return bytes;
528 }
529
530 static void advance_bvec(struct iov_iter *i, size_t bytes)
531 {
532         BUG_ON(i->count < bytes);
533
534         if (likely(i->nr_segs == 1)) {
535                 i->iov_offset += bytes;
536                 i->count -= bytes;
537         } else {
538                 const struct bio_vec *bvec = i->bvec;
539                 size_t base = i->iov_offset;
540                 unsigned long nr_segs = i->nr_segs;
541
542                 /*
543                  * The !iov->iov_len check ensures we skip over unlikely
544                  * zero-length segments (without overruning the iovec).
545                  */
546                 while (bytes || unlikely(i->count && !bvec->bv_len)) {
547                         int copy;
548
549                         copy = min(bytes, bvec->bv_len - base);
550                         BUG_ON(!i->count || i->count < copy);
551                         i->count -= copy;
552                         bytes -= copy;
553                         base += copy;
554                         if (bvec->bv_len == base) {
555                                 bvec++;
556                                 nr_segs--;
557                                 base = 0;
558                         }
559                 }
560                 i->bvec = bvec;
561                 i->iov_offset = base;
562                 i->nr_segs = nr_segs;
563         }
564 }
565
566 static unsigned long alignment_bvec(const struct iov_iter *i)
567 {
568         const struct bio_vec *bvec = i->bvec;
569         unsigned long res;
570         size_t size = i->count;
571         size_t n;
572
573         if (!size)
574                 return 0;
575
576         res = bvec->bv_offset + i->iov_offset;
577         n = bvec->bv_len - i->iov_offset;
578         if (n >= size)
579                 return res | size;
580         size -= n;
581         res |= n;
582         while (size > (++bvec)->bv_len) {
583                 res |= bvec->bv_offset | bvec->bv_len;
584                 size -= bvec->bv_len;
585         }
586         res |= bvec->bv_offset | size;
587         return res;
588 }
589
590 static ssize_t get_pages_bvec(struct iov_iter *i,
591                    struct page **pages, unsigned maxpages,
592                    size_t *start)
593 {
594         const struct bio_vec *bvec = i->bvec;
595         size_t len = bvec->bv_len - i->iov_offset;
596         if (len > i->count)
597                 len = i->count;
598         /* can't be more than PAGE_SIZE */
599         *start = bvec->bv_offset + i->iov_offset;
600
601         get_page(*pages = bvec->bv_page);
602
603         return len;
604 }
605
606 static ssize_t get_pages_alloc_bvec(struct iov_iter *i,
607                    struct page ***pages, size_t maxsize,
608                    size_t *start)
609 {
610         const struct bio_vec *bvec = i->bvec;
611         size_t len = bvec->bv_len - i->iov_offset;
612         if (len > i->count)
613                 len = i->count;
614         if (len > maxsize)
615                 len = maxsize;
616         *start = bvec->bv_offset + i->iov_offset;
617
618         *pages = kmalloc(sizeof(struct page *), GFP_KERNEL);
619         if (!*pages)
620                 return -ENOMEM;
621
622         get_page(**pages = bvec->bv_page);
623
624         return len;
625 }
626
627 static int iov_iter_npages_bvec(const struct iov_iter *i, int maxpages)
628 {
629         size_t offset = i->iov_offset;
630         size_t size = i->count;
631         const struct bio_vec *bvec = i->bvec;
632         int npages = 0;
633         int n;
634
635         for (n = 0; size && n < i->nr_segs; n++, bvec++) {
636                 size_t len = bvec->bv_len - offset;
637                 offset = 0;
638                 if (unlikely(!len))     /* empty segment */
639                         continue;
640                 if (len > size)
641                         len = size;
642                 npages++;
643                 if (npages >= maxpages) /* don't bother going further */
644                         return maxpages;
645                 size -= len;
646                 offset = 0;
647         }
648         return min(npages, maxpages);
649 }
650
651 size_t copy_page_to_iter(struct page *page, size_t offset, size_t bytes,
652                          struct iov_iter *i)
653 {
654         if (i->type & ITER_BVEC)
655                 return copy_page_to_iter_bvec(page, offset, bytes, i);
656         else
657                 return copy_page_to_iter_iovec(page, offset, bytes, i);
658 }
659 EXPORT_SYMBOL(copy_page_to_iter);
660
661 size_t copy_page_from_iter(struct page *page, size_t offset, size_t bytes,
662                          struct iov_iter *i)
663 {
664         if (i->type & ITER_BVEC)
665                 return copy_page_from_iter_bvec(page, offset, bytes, i);
666         else
667                 return copy_page_from_iter_iovec(page, offset, bytes, i);
668 }
669 EXPORT_SYMBOL(copy_page_from_iter);
670
671 size_t iov_iter_copy_from_user_atomic(struct page *page,
672                 struct iov_iter *i, unsigned long offset, size_t bytes)
673 {
674         if (i->type & ITER_BVEC)
675                 return copy_from_user_bvec(page, i, offset, bytes);
676         else
677                 return copy_from_user_atomic_iovec(page, i, offset, bytes);
678 }
679 EXPORT_SYMBOL(iov_iter_copy_from_user_atomic);
680
681 void iov_iter_advance(struct iov_iter *i, size_t size)
682 {
683         if (i->type & ITER_BVEC)
684                 advance_bvec(i, size);
685         else
686                 advance_iovec(i, size);
687 }
688 EXPORT_SYMBOL(iov_iter_advance);
689
690 /*
691  * Return the count of just the current iov_iter segment.
692  */
693 size_t iov_iter_single_seg_count(const struct iov_iter *i)
694 {
695         if (i->nr_segs == 1)
696                 return i->count;
697         else if (i->type & ITER_BVEC)
698                 return min(i->count, i->iov->iov_len - i->iov_offset);
699         else
700                 return min(i->count, i->bvec->bv_len - i->iov_offset);
701 }
702 EXPORT_SYMBOL(iov_iter_single_seg_count);
703
704 unsigned long iov_iter_alignment(const struct iov_iter *i)
705 {
706         if (i->type & ITER_BVEC)
707                 return alignment_bvec(i);
708         else
709                 return alignment_iovec(i);
710 }
711 EXPORT_SYMBOL(iov_iter_alignment);
712
713 ssize_t iov_iter_get_pages(struct iov_iter *i,
714                    struct page **pages, unsigned maxpages,
715                    size_t *start)
716 {
717         if (i->type & ITER_BVEC)
718                 return get_pages_bvec(i, pages, maxpages, start);
719         else
720                 return get_pages_iovec(i, pages, maxpages, start);
721 }
722 EXPORT_SYMBOL(iov_iter_get_pages);
723
724 ssize_t iov_iter_get_pages_alloc(struct iov_iter *i,
725                    struct page ***pages, size_t maxsize,
726                    size_t *start)
727 {
728         if (i->type & ITER_BVEC)
729                 return get_pages_alloc_bvec(i, pages, maxsize, start);
730         else
731                 return get_pages_alloc_iovec(i, pages, maxsize, start);
732 }
733 EXPORT_SYMBOL(iov_iter_get_pages_alloc);
734
735 int iov_iter_npages(const struct iov_iter *i, int maxpages)
736 {
737         if (i->type & ITER_BVEC)
738                 return iov_iter_npages_bvec(i, maxpages);
739         else
740                 return iov_iter_npages_iovec(i, maxpages);
741 }
742 EXPORT_SYMBOL(iov_iter_npages);