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;
 865         size_t v = n + offset;
 866
 867         /*
 868          * The general case needs to access the page order in order
 869          * to compute the page size.
 870          * However, we mostly deal with order-0 pages and thus can
 871          * avoid a possible cache line miss for requests that fit all
 872          * page orders.
 873          */
 874         if (n <= v && v <= PAGE_SIZE)
 875                 return true;
 876
 877         head = compound_head(page);
 878         v += (page - head) << PAGE_SHIFT;
 879
 880         if (likely(n <= v && v <= (PAGE_SIZE << compound_order(head))))
 881                 return true;
 882         WARN_ON(1);
 883         return false;
 884 }
 885
 886 size_t copy_page_to_iter(struct page *page, size_t offset, size_t bytes,
 887                          struct iov_iter *i)
 888 {
 889         if (unlikely(!page_copy_sane(page, offset, bytes)))
 890                 return 0;
 891         if (i->type & (ITER_BVEC|ITER_KVEC)) {
 892                 void *kaddr = kmap_atomic(page);
 893                 size_t wanted = copy_to_iter(kaddr + offset, bytes, i);
 894                 kunmap_atomic(kaddr);
 895                 return wanted;
 896         } else if (unlikely(iov_iter_is_discard(i)))
 897                 return bytes;
 898         else if (likely(!iov_iter_is_pipe(i)))
 899                 return copy_page_to_iter_iovec(page, offset, bytes, i);
 900         else
 901                 return copy_page_to_iter_pipe(page, offset, bytes, i);
 902 }
 903 EXPORT_SYMBOL(copy_page_to_iter);
 904
 905 size_t copy_page_from_iter(struct page *page, size_t offset, size_t bytes,
 906                          struct iov_iter *i)
 907 {
 908         if (unlikely(!page_copy_sane(page, offset, bytes)))
 909                 return 0;
 910         if (unlikely(iov_iter_is_pipe(i) || iov_iter_is_discard(i))) {
 911                 WARN_ON(1);
 912                 return 0;
 913         }
 914         if (i->type & (ITER_BVEC|ITER_KVEC)) {
 915                 void *kaddr = kmap_atomic(page);
 916                 size_t wanted = _copy_from_iter(kaddr + offset, bytes, i);
 917                 kunmap_atomic(kaddr);
 918                 return wanted;
 919         } else
 920                 return copy_page_from_iter_iovec(page, offset, bytes, i);
 921 }
 922 EXPORT_SYMBOL(copy_page_from_iter);
 923
 924 static size_t pipe_zero(size_t bytes, struct iov_iter *i)
 925 {
 926         struct pipe_inode_info *pipe = i->pipe;
 927         size_t n, off;
 928         int idx;
 929
 930         if (!sanity(i))
 931                 return 0;
 932
 933         bytes = n = push_pipe(i, bytes, &idx, &off);
 934         if (unlikely(!n))
 935                 return 0;
 936
 937         for ( ; n; idx = next_idx(idx, pipe), off = 0) {
 938                 size_t chunk = min_t(size_t, n, PAGE_SIZE - off);
 939                 memzero_page(pipe->bufs[idx].page, off, chunk);
 940                 i->idx = idx;
 941                 i->iov_offset = off + chunk;
 942                 n -= chunk;
 943         }
 944         i->count -= bytes;
 945         return bytes;
 946 }
 947
 948 size_t iov_iter_zero(size_t bytes, struct iov_iter *i)
 949 {
 950         if (unlikely(iov_iter_is_pipe(i)))
 951                 return pipe_zero(bytes, i);
 952         iterate_and_advance(i, bytes, v,
 953                 clear_user(v.iov_base, v.iov_len),
 954                 memzero_page(v.bv_page, v.bv_offset, v.bv_len),
 955                 memset(v.iov_base, 0, v.iov_len)
 956         )
 957
 958         return bytes;
 959 }
 960 EXPORT_SYMBOL(iov_iter_zero);
 961
 962 size_t iov_iter_copy_from_user_atomic(struct page *page,
 963                 struct iov_iter *i, unsigned long offset, size_t bytes)
 964 {
 965         char *kaddr = kmap_atomic(page), *p = kaddr + offset;
 966         if (unlikely(!page_copy_sane(page, offset, bytes))) {
 967                 kunmap_atomic(kaddr);
 968                 return 0;
 969         }
 970         if (unlikely(iov_iter_is_pipe(i) || iov_iter_is_discard(i))) {
 971                 kunmap_atomic(kaddr);
 972                 WARN_ON(1);
 973                 return 0;
 974         }
 975         iterate_all_kinds(i, bytes, v,
 976                 copyin((p += v.iov_len) - v.iov_len, v.iov_base, v.iov_len),
 977                 memcpy_from_page((p += v.bv_len) - v.bv_len, v.bv_page,
 978                                  v.bv_offset, v.bv_len),
 979                 memcpy((p += v.iov_len) - v.iov_len, v.iov_base, v.iov_len)
 980         )
 981         kunmap_atomic(kaddr);
 982         return bytes;
 983 }
 984 EXPORT_SYMBOL(iov_iter_copy_from_user_atomic);
 985
 986 static inline void pipe_truncate(struct iov_iter *i)
 987 {
 988         struct pipe_inode_info *pipe = i->pipe;
 989         if (pipe->nrbufs) {
 990                 size_t off = i->iov_offset;
 991                 int idx = i->idx;
 992                 int nrbufs = (idx - pipe->curbuf) & (pipe->buffers - 1);
 993                 if (off) {
 994                         pipe->bufs[idx].len = off - pipe->bufs[idx].offset;
 995                         idx = next_idx(idx, pipe);
 996                         nrbufs++;
 997                 }
 998                 while (pipe->nrbufs > nrbufs) {
 999                         pipe_buf_release(pipe, &pipe->bufs[idx]);
1000                         idx = next_idx(idx, pipe);
1001                         pipe->nrbufs--;
1002                 }
1003         }
1004 }
1005
1006 static void pipe_advance(struct iov_iter *i, size_t size)
1007 {
1008         struct pipe_inode_info *pipe = i->pipe;
1009         if (unlikely(i->count < size))
1010                 size = i->count;
1011         if (size) {
1012                 struct pipe_buffer *buf;
1013                 size_t off = i->iov_offset, left = size;
1014                 int idx = i->idx;
1015                 if (off) /* make it relative to the beginning of buffer */
1016                         left += off - pipe->bufs[idx].offset;
1017                 while (1) {
1018                         buf = &pipe->bufs[idx];
1019                         if (left <= buf->len)
1020                                 break;
1021                         left -= buf->len;
1022                         idx = next_idx(idx, pipe);
1023                 }
1024                 i->idx = idx;
1025                 i->iov_offset = buf->offset + left;
1026         }
1027         i->count -= size;
1028         /* ... and discard everything past that point */
1029         pipe_truncate(i);
1030 }
1031
1032 void iov_iter_advance(struct iov_iter *i, size_t size)
1033 {
1034         if (unlikely(iov_iter_is_pipe(i))) {
1035                 pipe_advance(i, size);
1036                 return;
1037         }
1038         if (unlikely(iov_iter_is_discard(i))) {
1039                 i->count -= size;
1040                 return;
1041         }
1042         iterate_and_advance(i, size, v, 0, 0, 0)
1043 }
1044 EXPORT_SYMBOL(iov_iter_advance);
1045
1046 void iov_iter_revert(struct iov_iter *i, size_t unroll)
1047 {
1048         if (!unroll)
1049                 return;
1050         if (WARN_ON(unroll > MAX_RW_COUNT))
1051                 return;
1052         i->count += unroll;
1053         if (unlikely(iov_iter_is_pipe(i))) {
1054                 struct pipe_inode_info *pipe = i->pipe;
1055                 int idx = i->idx;
1056                 size_t off = i->iov_offset;
1057                 while (1) {
1058                         size_t n = off - pipe->bufs[idx].offset;
1059                         if (unroll < n) {
1060                                 off -= unroll;
1061                                 break;
1062                         }
1063                         unroll -= n;
1064                         if (!unroll && idx == i->start_idx) {
1065                                 off = 0;
1066                                 break;
1067                         }
1068                         if (!idx--)
1069                                 idx = pipe->buffers - 1;
1070                         off = pipe->bufs[idx].offset + pipe->bufs[idx].len;
1071                 }
1072                 i->iov_offset = off;
1073                 i->idx = idx;
1074                 pipe_truncate(i);
1075                 return;
1076         }
1077         if (unlikely(iov_iter_is_discard(i)))
1078                 return;
1079         if (unroll <= i->iov_offset) {
1080                 i->iov_offset -= unroll;
1081                 return;
1082         }
1083         unroll -= i->iov_offset;
1084         if (iov_iter_is_bvec(i)) {
1085                 const struct bio_vec *bvec = i->bvec;
1086                 while (1) {
1087                         size_t n = (--bvec)->bv_len;
1088                         i->nr_segs++;
1089                         if (unroll <= n) {
1090                                 i->bvec = bvec;
1091                                 i->iov_offset = n - unroll;
1092                                 return;
1093                         }
1094                         unroll -= n;
1095                 }
1096         } else { /* same logics for iovec and kvec */
1097                 const struct iovec *iov = i->iov;
1098                 while (1) {
1099                         size_t n = (--iov)->iov_len;
1100                         i->nr_segs++;
1101                         if (unroll <= n) {
1102                                 i->iov = iov;
1103                                 i->iov_offset = n - unroll;
1104                                 return;
1105                         }
1106                         unroll -= n;
1107                 }
1108         }
1109 }
1110 EXPORT_SYMBOL(iov_iter_revert);
1111
1112 /*
1113  * Return the count of just the current iov_iter segment.
1114  */
1115 size_t iov_iter_single_seg_count(const struct iov_iter *i)
1116 {
1117         if (unlikely(iov_iter_is_pipe(i)))
1118                 return i->count;        // it is a silly place, anyway
1119         if (i->nr_segs == 1)
1120                 return i->count;
1121         if (unlikely(iov_iter_is_discard(i)))
1122                 return i->count;
1123         else if (iov_iter_is_bvec(i))
1124                 return min(i->count, i->bvec->bv_len - i->iov_offset);
1125         else
1126                 return min(i->count, i->iov->iov_len - i->iov_offset);
1127 }
1128 EXPORT_SYMBOL(iov_iter_single_seg_count);
1129
1130 void iov_iter_kvec(struct iov_iter *i, unsigned int direction,
1131                         const struct kvec *kvec, unsigned long nr_segs,
1132                         size_t count)
1133 {
1134         WARN_ON(direction & ~(READ | WRITE));
1135         i->type = ITER_KVEC | (direction & (READ | WRITE));
1136         i->kvec = kvec;
1137         i->nr_segs = nr_segs;
1138         i->iov_offset = 0;
1139         i->count = count;
1140 }
1141 EXPORT_SYMBOL(iov_iter_kvec);
1142
1143 void iov_iter_bvec(struct iov_iter *i, unsigned int direction,
1144                         const struct bio_vec *bvec, unsigned long nr_segs,
1145                         size_t count)
1146 {
1147         WARN_ON(direction & ~(READ | WRITE));
1148         i->type = ITER_BVEC | (direction & (READ | WRITE));
1149         i->bvec = bvec;
1150         i->nr_segs = nr_segs;
1151         i->iov_offset = 0;
1152         i->count = count;
1153 }
1154 EXPORT_SYMBOL(iov_iter_bvec);
1155
1156 void iov_iter_pipe(struct iov_iter *i, unsigned int direction,
1157                         struct pipe_inode_info *pipe,
1158                         size_t count)
1159 {
1160         BUG_ON(direction != READ);
1161         WARN_ON(pipe->nrbufs == pipe->buffers);
1162         i->type = ITER_PIPE | READ;
1163         i->pipe = pipe;
1164         i->idx = (pipe->curbuf + pipe->nrbufs) & (pipe->buffers - 1);
1165         i->iov_offset = 0;
1166         i->count = count;
1167         i->start_idx = i->idx;
1168 }
1169 EXPORT_SYMBOL(iov_iter_pipe);
1170
1171 /**
1172  * iov_iter_discard - Initialise an I/O iterator that discards data
1173  * @i: The iterator to initialise.
1174  * @direction: The direction of the transfer.
1175  * @count: The size of the I/O buffer in bytes.
1176  *
1177  * Set up an I/O iterator that just discards everything that's written to it.
1178  * It's only available as a READ iterator.
1179  */
1180 void iov_iter_discard(struct iov_iter *i, unsigned int direction, size_t count)
1181 {
1182         BUG_ON(direction != READ);
1183         i->type = ITER_DISCARD | READ;
1184         i->count = count;
1185         i->iov_offset = 0;
1186 }
1187 EXPORT_SYMBOL(iov_iter_discard);
1188
1189 unsigned long iov_iter_alignment(const struct iov_iter *i)
1190 {
1191         unsigned long res = 0;
1192         size_t size = i->count;
1193
1194         if (unlikely(iov_iter_is_pipe(i))) {
1195                 if (size && i->iov_offset && allocated(&i->pipe->bufs[i->idx]))
1196                         return size | i->iov_offset;
1197                 return size;
1198         }
1199         iterate_all_kinds(i, size, v,
1200                 (res |= (unsigned long)v.iov_base | v.iov_len, 0),
1201                 res |= v.bv_offset | v.bv_len,
1202                 res |= (unsigned long)v.iov_base | v.iov_len
1203         )
1204         return res;
1205 }
1206 EXPORT_SYMBOL(iov_iter_alignment);
1207
1208 unsigned long iov_iter_gap_alignment(const struct iov_iter *i)
1209 {
1210         unsigned long res = 0;
1211         size_t size = i->count;
1212
1213         if (unlikely(iov_iter_is_pipe(i) || iov_iter_is_discard(i))) {
1214                 WARN_ON(1);
1215                 return ~0U;
1216         }
1217
1218         iterate_all_kinds(i, size, v,
1219                 (res |= (!res ? 0 : (unsigned long)v.iov_base) |
1220                         (size != v.iov_len ? size : 0), 0),
1221                 (res |= (!res ? 0 : (unsigned long)v.bv_offset) |
1222                         (size != v.bv_len ? size : 0)),
1223                 (res |= (!res ? 0 : (unsigned long)v.iov_base) |
1224                         (size != v.iov_len ? size : 0))
1225                 );
1226         return res;
1227 }
1228 EXPORT_SYMBOL(iov_iter_gap_alignment);
1229
1230 static inline ssize_t __pipe_get_pages(struct iov_iter *i,
1231                                 size_t maxsize,
1232                                 struct page **pages,
1233                                 int idx,
1234                                 size_t *start)
1235 {
1236         struct pipe_inode_info *pipe = i->pipe;
1237         ssize_t n = push_pipe(i, maxsize, &idx, start);
1238         if (!n)
1239                 return -EFAULT;
1240
1241         maxsize = n;
1242         n += *start;
1243         while (n > 0) {
1244                 get_page(*pages++ = pipe->bufs[idx].page);
1245                 idx = next_idx(idx, pipe);
1246                 n -= PAGE_SIZE;
1247         }
1248
1249         return maxsize;
1250 }
1251
1252 static ssize_t pipe_get_pages(struct iov_iter *i,
1253                    struct page **pages, size_t maxsize, unsigned maxpages,
1254                    size_t *start)
1255 {
1256         unsigned npages;
1257         size_t capacity;
1258         int idx;
1259
1260         if (!maxsize)
1261                 return 0;
1262
1263         if (!sanity(i))
1264                 return -EFAULT;
1265
1266         data_start(i, &idx, start);
1267         /* some of this one + all after this one */
1268         npages = ((i->pipe->curbuf - idx - 1) & (i->pipe->buffers - 1)) + 1;
1269         capacity = min(npages,maxpages) * PAGE_SIZE - *start;
1270
1271         return __pipe_get_pages(i, min(maxsize, capacity), pages, idx, start);
1272 }
1273
1274 ssize_t iov_iter_get_pages(struct iov_iter *i,
1275                    struct page **pages, size_t maxsize, unsigned maxpages,
1276                    size_t *start)
1277 {
1278         if (maxsize > i->count)
1279                 maxsize = i->count;
1280
1281         if (unlikely(iov_iter_is_pipe(i)))
1282                 return pipe_get_pages(i, pages, maxsize, maxpages, start);
1283         if (unlikely(iov_iter_is_discard(i)))
1284                 return -EFAULT;
1285
1286         iterate_all_kinds(i, maxsize, v, ({
1287                 unsigned long addr = (unsigned long)v.iov_base;
1288                 size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1));
1289                 int n;
1290                 int res;
1291
1292                 if (len > maxpages * PAGE_SIZE)
1293                         len = maxpages * PAGE_SIZE;
1294                 addr &= ~(PAGE_SIZE - 1);
1295                 n = DIV_ROUND_UP(len, PAGE_SIZE);
1296                 res = get_user_pages_fast(addr, n, iov_iter_rw(i) != WRITE, pages);
1297                 if (unlikely(res < 0))
1298                         return res;
1299                 return (res == n ? len : res * PAGE_SIZE) - *start;
1300         0;}),({
1301                 /* can't be more than PAGE_SIZE */
1302                 *start = v.bv_offset;
1303                 get_page(*pages = v.bv_page);
1304                 return v.bv_len;
1305         }),({
1306                 return -EFAULT;
1307         })
1308         )
1309         return 0;
1310 }
1311 EXPORT_SYMBOL(iov_iter_get_pages);
1312
1313 static struct page **get_pages_array(size_t n)
1314 {
1315         return kvmalloc_array(n, sizeof(struct page *), GFP_KERNEL);
1316 }
1317
1318 static ssize_t pipe_get_pages_alloc(struct iov_iter *i,
1319                    struct page ***pages, size_t maxsize,
1320                    size_t *start)
1321 {
1322         struct page **p;
1323         ssize_t n;
1324         int idx;
1325         int npages;
1326
1327         if (!maxsize)
1328                 return 0;
1329
1330         if (!sanity(i))
1331                 return -EFAULT;
1332
1333         data_start(i, &idx, start);
1334         /* some of this one + all after this one */
1335         npages = ((i->pipe->curbuf - idx - 1) & (i->pipe->buffers - 1)) + 1;
1336         n = npages * PAGE_SIZE - *start;
1337         if (maxsize > n)
1338                 maxsize = n;
1339         else
1340                 npages = DIV_ROUND_UP(maxsize + *start, PAGE_SIZE);
1341         p = get_pages_array(npages);
1342         if (!p)
1343                 return -ENOMEM;
1344         n = __pipe_get_pages(i, maxsize, p, idx, start);
1345         if (n > 0)
1346                 *pages = p;
1347         else
1348                 kvfree(p);
1349         return n;
1350 }
1351
1352 ssize_t iov_iter_get_pages_alloc(struct iov_iter *i,
1353                    struct page ***pages, size_t maxsize,
1354                    size_t *start)
1355 {
1356         struct page **p;
1357
1358         if (maxsize > i->count)
1359                 maxsize = i->count;
1360
1361         if (unlikely(iov_iter_is_pipe(i)))
1362                 return pipe_get_pages_alloc(i, pages, maxsize, start);
1363         if (unlikely(iov_iter_is_discard(i)))
1364                 return -EFAULT;
1365
1366         iterate_all_kinds(i, maxsize, v, ({
1367                 unsigned long addr = (unsigned long)v.iov_base;
1368                 size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1));
1369                 int n;
1370                 int res;
1371
1372                 addr &= ~(PAGE_SIZE - 1);
1373                 n = DIV_ROUND_UP(len, PAGE_SIZE);
1374                 p = get_pages_array(n);
1375                 if (!p)
1376                         return -ENOMEM;
1377                 res = get_user_pages_fast(addr, n, iov_iter_rw(i) != WRITE, p);
1378                 if (unlikely(res < 0)) {
1379                         kvfree(p);
1380                         return res;
1381                 }
1382                 *pages = p;
1383                 return (res == n ? len : res * PAGE_SIZE) - *start;
1384         0;}),({
1385                 /* can't be more than PAGE_SIZE */
1386                 *start = v.bv_offset;
1387                 *pages = p = get_pages_array(1);
1388                 if (!p)
1389                         return -ENOMEM;
1390                 get_page(*p = v.bv_page);
1391                 return v.bv_len;
1392         }),({
1393                 return -EFAULT;
1394         })
1395         )
1396         return 0;
1397 }
1398 EXPORT_SYMBOL(iov_iter_get_pages_alloc);
1399
1400 size_t csum_and_copy_from_iter(void *addr, size_t bytes, __wsum *csum,
1401                                struct iov_iter *i)
1402 {
1403         char *to = addr;
1404         __wsum sum, next;
1405         size_t off = 0;
1406         sum = *csum;
1407         if (unlikely(iov_iter_is_pipe(i) || iov_iter_is_discard(i))) {
1408                 WARN_ON(1);
1409                 return 0;
1410         }
1411         iterate_and_advance(i, bytes, v, ({
1412                 int err = 0;
1413                 next = csum_and_copy_from_user(v.iov_base,
1414                                                (to += v.iov_len) - v.iov_len,
1415                                                v.iov_len, 0, &err);
1416                 if (!err) {
1417                         sum = csum_block_add(sum, next, off);
1418                         off += v.iov_len;
1419                 }
1420                 err ? v.iov_len : 0;
1421         }), ({
1422                 char *p = kmap_atomic(v.bv_page);
1423                 sum = csum_and_memcpy((to += v.bv_len) - v.bv_len,
1424                                       p + v.bv_offset, v.bv_len,
1425                                       sum, off);
1426                 kunmap_atomic(p);
1427                 off += v.bv_len;
1428         }),({
1429                 sum = csum_and_memcpy((to += v.iov_len) - v.iov_len,
1430                                       v.iov_base, v.iov_len,
1431                                       sum, off);
1432                 off += v.iov_len;
1433         })
1434         )
1435         *csum = sum;
1436         return bytes;
1437 }
1438 EXPORT_SYMBOL(csum_and_copy_from_iter);
1439
1440 bool csum_and_copy_from_iter_full(void *addr, size_t bytes, __wsum *csum,
1441                                struct iov_iter *i)
1442 {
1443         char *to = addr;
1444         __wsum sum, next;
1445         size_t off = 0;
1446         sum = *csum;
1447         if (unlikely(iov_iter_is_pipe(i) || iov_iter_is_discard(i))) {
1448                 WARN_ON(1);
1449                 return false;
1450         }
1451         if (unlikely(i->count < bytes))
1452                 return false;
1453         iterate_all_kinds(i, bytes, v, ({
1454                 int err = 0;
1455                 next = csum_and_copy_from_user(v.iov_base,
1456                                                (to += v.iov_len) - v.iov_len,
1457                                                v.iov_len, 0, &err);
1458                 if (err)
1459                         return false;
1460                 sum = csum_block_add(sum, next, off);
1461                 off += v.iov_len;
1462                 0;
1463         }), ({
1464                 char *p = kmap_atomic(v.bv_page);
1465                 sum = csum_and_memcpy((to += v.bv_len) - v.bv_len,
1466                                       p + v.bv_offset, v.bv_len,
1467                                       sum, off);
1468                 kunmap_atomic(p);
1469                 off += v.bv_len;
1470         }),({
1471                 sum = csum_and_memcpy((to += v.iov_len) - v.iov_len,
1472                                       v.iov_base, v.iov_len,
1473                                       sum, off);
1474                 off += v.iov_len;
1475         })
1476         )
1477         *csum = sum;
1478         iov_iter_advance(i, bytes);
1479         return true;
1480 }
1481 EXPORT_SYMBOL(csum_and_copy_from_iter_full);
1482
1483 size_t csum_and_copy_to_iter(const void *addr, size_t bytes, void *csump,
1484                              struct iov_iter *i)
1485 {
1486         const char *from = addr;
1487         __wsum *csum = csump;
1488         __wsum sum, next;
1489         size_t off = 0;
1490
1491         if (unlikely(iov_iter_is_pipe(i)))
1492                 return csum_and_copy_to_pipe_iter(addr, bytes, csum, i);
1493
1494         sum = *csum;
1495         if (unlikely(iov_iter_is_discard(i))) {
1496                 WARN_ON(1);     /* for now */
1497                 return 0;
1498         }
1499         iterate_and_advance(i, bytes, v, ({
1500                 int err = 0;
1501                 next = csum_and_copy_to_user((from += v.iov_len) - v.iov_len,
1502                                              v.iov_base,
1503                                              v.iov_len, 0, &err);
1504                 if (!err) {
1505                         sum = csum_block_add(sum, next, off);
1506                         off += v.iov_len;
1507                 }
1508                 err ? v.iov_len : 0;
1509         }), ({
1510                 char *p = kmap_atomic(v.bv_page);
1511                 sum = csum_and_memcpy(p + v.bv_offset,
1512                                       (from += v.bv_len) - v.bv_len,
1513                                       v.bv_len, sum, off);
1514                 kunmap_atomic(p);
1515                 off += v.bv_len;
1516         }),({
1517                 sum = csum_and_memcpy(v.iov_base,
1518                                      (from += v.iov_len) - v.iov_len,
1519                                      v.iov_len, sum, off);
1520                 off += v.iov_len;
1521         })
1522         )
1523         *csum = sum;
1524         return bytes;
1525 }
1526 EXPORT_SYMBOL(csum_and_copy_to_iter);
1527
1528 size_t hash_and_copy_to_iter(const void *addr, size_t bytes, void *hashp,
1529                 struct iov_iter *i)
1530 {
1531 #ifdef CONFIG_CRYPTO
1532         struct ahash_request *hash = hashp;
1533         struct scatterlist sg;
1534         size_t copied;
1535
1536         copied = copy_to_iter(addr, bytes, i);
1537         sg_init_one(&sg, addr, copied);
1538         ahash_request_set_crypt(hash, &sg, NULL, copied);
1539         crypto_ahash_update(hash);
1540         return copied;
1541 #else
1542         return 0;
1543 #endif
1544 }
1545 EXPORT_SYMBOL(hash_and_copy_to_iter);
1546
1547 int iov_iter_npages(const struct iov_iter *i, int maxpages)
1548 {
1549         size_t size = i->count;
1550         int npages = 0;
1551
1552         if (!size)
1553                 return 0;
1554         if (unlikely(iov_iter_is_discard(i)))
1555                 return 0;
1556
1557         if (unlikely(iov_iter_is_pipe(i))) {
1558                 struct pipe_inode_info *pipe = i->pipe;
1559                 size_t off;
1560                 int idx;
1561
1562                 if (!sanity(i))
1563                         return 0;
1564
1565                 data_start(i, &idx, &off);
1566                 /* some of this one + all after this one */
1567                 npages = ((pipe->curbuf - idx - 1) & (pipe->buffers - 1)) + 1;
1568                 if (npages >= maxpages)
1569                         return maxpages;
1570         } else iterate_all_kinds(i, size, v, ({
1571                 unsigned long p = (unsigned long)v.iov_base;
1572                 npages += DIV_ROUND_UP(p + v.iov_len, PAGE_SIZE)
1573                         - p / PAGE_SIZE;
1574                 if (npages >= maxpages)
1575                         return maxpages;
1576         0;}),({
1577                 npages++;
1578                 if (npages >= maxpages)
1579                         return maxpages;
1580         }),({
1581                 unsigned long p = (unsigned long)v.iov_base;
1582                 npages += DIV_ROUND_UP(p + v.iov_len, PAGE_SIZE)
1583                         - p / PAGE_SIZE;
1584                 if (npages >= maxpages)
1585                         return maxpages;
1586         })
1587         )
1588         return npages;
1589 }
1590 EXPORT_SYMBOL(iov_iter_npages);
1591
1592 const void *dup_iter(struct iov_iter *new, struct iov_iter *old, gfp_t flags)
1593 {
1594         *new = *old;
1595         if (unlikely(iov_iter_is_pipe(new))) {
1596                 WARN_ON(1);
1597                 return NULL;
1598         }
1599         if (unlikely(iov_iter_is_discard(new)))
1600                 return NULL;
1601         if (iov_iter_is_bvec(new))
1602                 return new->bvec = kmemdup(new->bvec,
1603                                     new->nr_segs * sizeof(struct bio_vec),
1604                                     flags);
1605         else
1606                 /* iovec and kvec have identical layout */
1607                 return new->iov = kmemdup(new->iov,
1608                                    new->nr_segs * sizeof(struct iovec),
1609                                    flags);
1610 }
1611 EXPORT_SYMBOL(dup_iter);
1612
1613 /**
1614  * import_iovec() - Copy an array of &struct iovec from userspace
1615  *     into the kernel, check that it is valid, and initialize a new
1616  *     &struct iov_iter iterator to access it.
1617  *
1618  * @type: One of %READ or %WRITE.
1619  * @uvector: Pointer to the userspace array.
1620  * @nr_segs: Number of elements in userspace array.
1621  * @fast_segs: Number of elements in @iov.
1622  * @iov: (input and output parameter) Pointer to pointer to (usually small
1623  *     on-stack) kernel array.
1624  * @i: Pointer to iterator that will be initialized on success.
1625  *
1626  * If the array pointed to by *@iov is large enough to hold all @nr_segs,
1627  * then this function places %NULL in *@iov on return. Otherwise, a new
1628  * array will be allocated and the result placed in *@iov. This means that
1629  * the caller may call kfree() on *@iov regardless of whether the small
1630  * on-stack array was used or not (and regardless of whether this function
1631  * returns an error or not).
1632  *
1633  * Return: 0 on success or negative error code on error.
1634  */
1635 int import_iovec(int type, const struct iovec __user * uvector,
1636                  unsigned nr_segs, unsigned fast_segs,
1637                  struct iovec **iov, struct iov_iter *i)
1638 {
1639         ssize_t n;
1640         struct iovec *p;
1641         n = rw_copy_check_uvector(type, uvector, nr_segs, fast_segs,
1642                                   *iov, &p);
1643         if (n < 0) {
1644                 if (p != *iov)
1645                         kfree(p);
1646                 *iov = NULL;
1647                 return n;
1648         }
1649         iov_iter_init(i, type, p, nr_segs, n);
1650         *iov = p == *iov ? NULL : p;
1651         return 0;
1652 }
1653 EXPORT_SYMBOL(import_iovec);
1654
1655 #ifdef CONFIG_COMPAT
1656 #include <linux/compat.h>
1657
1658 int compat_import_iovec(int type, const struct compat_iovec __user * uvector,
1659                  unsigned nr_segs, unsigned fast_segs,
1660                  struct iovec **iov, struct iov_iter *i)
1661 {
1662         ssize_t n;
1663         struct iovec *p;
1664         n = compat_rw_copy_check_uvector(type, uvector, nr_segs, fast_segs,
1665                                   *iov, &p);
1666         if (n < 0) {
1667                 if (p != *iov)
1668                         kfree(p);
1669                 *iov = NULL;
1670                 return n;
1671         }
1672         iov_iter_init(i, type, p, nr_segs, n);
1673         *iov = p == *iov ? NULL : p;
1674         return 0;
1675 }
1676 #endif
1677
1678 int import_single_range(int rw, void __user *buf, size_t len,
1679                  struct iovec *iov, struct iov_iter *i)
1680 {
1681         if (len > MAX_RW_COUNT)
1682                 len = MAX_RW_COUNT;
1683         if (unlikely(!access_ok(buf, len)))
1684                 return -EFAULT;
1685
1686         iov->iov_base = buf;
1687         iov->iov_len = len;
1688         iov_iter_init(i, rw, iov, 1, len);
1689         return 0;
1690 }
1691 EXPORT_SYMBOL(import_single_range);
1692
1693 int iov_iter_for_each_range(struct iov_iter *i, size_t bytes,
1694                             int (*f)(struct kvec *vec, void *context),
1695                             void *context)
1696 {
1697         struct kvec w;
1698         int err = -EINVAL;
1699         if (!bytes)
1700                 return 0;
1701
1702         iterate_all_kinds(i, bytes, v, -EINVAL, ({
1703                 w.iov_base = kmap(v.bv_page) + v.bv_offset;
1704                 w.iov_len = v.bv_len;
1705                 err = f(&w, context);
1706                 kunmap(v.bv_page);
1707                 err;}), ({
1708                 w = v;
1709                 err = f(&w, context);})
1710         )
1711         return err;
1712 }
1713 EXPORT_SYMBOL(iov_iter_for_each_range);