net/core/iovec.c

   1 /*
   2  *      iovec manipulation routines.
   3  *
   4  *
   5  *              This program is free software; you can redistribute it and/or
   6  *              modify it under the terms of the GNU General Public License
   7  *              as published by the Free Software Foundation; either version
   8  *              2 of the License, or (at your option) any later version.
   9  *
  10  *      Fixes:
  11  *              Andrew Lunn     :       Errors in iovec copying.
  12  *              Pedro Roque     :       Added memcpy_fromiovecend and
  13  *                                      csum_..._fromiovecend.
  14  *              Andi Kleen      :       fixed error handling for 2.1
  15  *              Alexey Kuznetsov:       2.1 optimisations
  16  *              Andi Kleen      :       Fix csum*fromiovecend for IPv6.
  17  */
  18
  19 #include <linux/errno.h>
  20 #include <linux/module.h>
  21 #include <linux/kernel.h>
  22 #include <linux/mm.h>
  23 #include <linux/net.h>
  24 #include <linux/in6.h>
  25 #include <asm/uaccess.h>
  26 #include <asm/byteorder.h>
  27 #include <net/checksum.h>
  28 #include <net/sock.h>
  29
  30 /*
  31  *      And now for the all-in-one: copy and checksum from a user iovec
  32  *      directly to a datagram
  33  *      Calls to csum_partial but the last must be in 32 bit chunks
  34  *
  35  *      ip_build_xmit must ensure that when fragmenting only the last
  36  *      call to this function will be unaligned also.
  37  */
  38 int csum_partial_copy_fromiovecend(unsigned char *kdata, struct iovec *iov,
  39                                  int offset, unsigned int len, __wsum *csump)
  40 {
  41         __wsum csum = *csump;
  42         int partial_cnt = 0, err = 0;
  43
  44         /* Skip over the finished iovecs */
  45         while (offset >= iov->iov_len) {
  46                 offset -= iov->iov_len;
  47                 iov++;
  48         }
  49
  50         while (len > 0) {
  51                 u8 __user *base = iov->iov_base + offset;
  52                 int copy = min_t(unsigned int, len, iov->iov_len - offset);
  53
  54                 offset = 0;
  55
  56                 /* There is a remnant from previous iov. */
  57                 if (partial_cnt) {
  58                         int par_len = 4 - partial_cnt;
  59
  60                         /* iov component is too short ... */
  61                         if (par_len > copy) {
  62                                 if (copy_from_user(kdata, base, copy))
  63                                         goto out_fault;
  64                                 kdata += copy;
  65                                 base += copy;
  66                                 partial_cnt += copy;
  67                                 len -= copy;
  68                                 iov++;
  69                                 if (len)
  70                                         continue;
  71                                 *csump = csum_partial(kdata - partial_cnt,
  72                                                          partial_cnt, csum);
  73                                 goto out;
  74                         }
  75                         if (copy_from_user(kdata, base, par_len))
  76                                 goto out_fault;
  77                         csum = csum_partial(kdata - partial_cnt, 4, csum);
  78                         kdata += par_len;
  79                         base  += par_len;
  80                         copy  -= par_len;
  81                         len   -= par_len;
  82                         partial_cnt = 0;
  83                 }
  84
  85                 if (len > copy) {
  86                         partial_cnt = copy % 4;
  87                         if (partial_cnt) {
  88                                 copy -= partial_cnt;
  89                                 if (copy_from_user(kdata + copy, base + copy,
  90                                                 partial_cnt))
  91                                         goto out_fault;
  92                         }
  93                 }
  94
  95                 if (copy) {
  96                         csum = csum_and_copy_from_user(base, kdata, copy,
  97                                                         csum, &err);
  98                         if (err)
  99                                 goto out;
 100                 }
 101                 len   -= copy + partial_cnt;
 102                 kdata += copy + partial_cnt;
 103                 iov++;
 104         }
 105         *csump = csum;
 106 out:
 107         return err;
 108
 109 out_fault:
 110         err = -EFAULT;
 111         goto out;
 112 }
 113 EXPORT_SYMBOL(csum_partial_copy_fromiovecend);
 114
 115 unsigned long iov_pages(const struct iovec *iov, int offset,
 116                         unsigned long nr_segs)
 117 {
 118         unsigned long seg, base;
 119         int pages = 0, len, size;
 120
 121         while (nr_segs && (offset >= iov->iov_len)) {
 122                 offset -= iov->iov_len;
 123                 ++iov;
 124                 --nr_segs;
 125         }
 126
 127         for (seg = 0; seg < nr_segs; seg++) {
 128                 base = (unsigned long)iov[seg].iov_base + offset;
 129                 len = iov[seg].iov_len - offset;
 130                 size = ((base & ~PAGE_MASK) + len + ~PAGE_MASK) >> PAGE_SHIFT;
 131                 pages += size;
 132                 offset = 0;
 133         }
 134
 135         return pages;
 136 }
 137 EXPORT_SYMBOL(iov_pages);