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  *      Verify iovec. The caller must ensure that the iovec is big enough
  32  *      to hold the message iovec.
  33  *
  34  *      Save time not doing access_ok. copy_*_user will make this work
  35  *      in any case.
  36  */
  37
  38 int verify_iovec(struct msghdr *m, struct iovec *iov, struct sockaddr_storage *address, int mode)
  39 {
  40         int size, ct, err;
  41
  42         if (m->msg_name && m->msg_namelen) {
  43                 if (mode == VERIFY_READ) {
  44                         void __user *namep;
  45                         namep = (void __user __force *) m->msg_name;
  46                         err = move_addr_to_kernel(namep, m->msg_namelen,
  47                                                   address);
  48                         if (err < 0)
  49                                 return err;
  50                 }
  51                 m->msg_name = address;
  52         } else {
  53                 m->msg_name = NULL;
  54                 m->msg_namelen = 0;
  55         }
  56
  57         size = m->msg_iovlen * sizeof(struct iovec);
  58         if (copy_from_user(iov, (void __user __force *) m->msg_iov, size))
  59                 return -EFAULT;
  60
  61         m->msg_iov = iov;
  62         err = 0;
  63
  64         for (ct = 0; ct < m->msg_iovlen; ct++) {
  65                 size_t len = iov[ct].iov_len;
  66
  67                 if (len > INT_MAX - err) {
  68                         len = INT_MAX - err;
  69                         iov[ct].iov_len = len;
  70                 }
  71                 err += len;
  72         }
  73
  74         return err;
  75 }
  76
  77 /*
  78  *      Copy kernel to iovec. Returns -EFAULT on error.
  79  */
  80
  81 int memcpy_toiovecend(const struct iovec *iov, unsigned char *kdata,
  82                       int offset, int len)
  83 {
  84         int copy;
  85         for (; len > 0; ++iov) {
  86                 /* Skip over the finished iovecs */
  87                 if (unlikely(offset >= iov->iov_len)) {
  88                         offset -= iov->iov_len;
  89                         continue;
  90                 }
  91                 copy = min_t(unsigned int, iov->iov_len - offset, len);
  92                 if (copy_to_user(iov->iov_base + offset, kdata, copy))
  93                         return -EFAULT;
  94                 offset = 0;
  95                 kdata += copy;
  96                 len -= copy;
  97         }
  98
  99         return 0;
 100 }
 101 EXPORT_SYMBOL(memcpy_toiovecend);
 102
 103 /*
 104  *      Copy iovec to kernel. Returns -EFAULT on error.
 105  */
 106
 107 int memcpy_fromiovecend(unsigned char *kdata, const struct iovec *iov,
 108                         int offset, int len)
 109 {
 110         /* No data? Done! */
 111         if (len == 0)
 112                 return 0;
 113
 114         /* Skip over the finished iovecs */
 115         while (offset >= iov->iov_len) {
 116                 offset -= iov->iov_len;
 117                 iov++;
 118         }
 119
 120         while (len > 0) {
 121                 u8 __user *base = iov->iov_base + offset;
 122                 int copy = min_t(unsigned int, len, iov->iov_len - offset);
 123
 124                 offset = 0;
 125                 if (copy_from_user(kdata, base, copy))
 126                         return -EFAULT;
 127                 len -= copy;
 128                 kdata += copy;
 129                 iov++;
 130         }
 131
 132         return 0;
 133 }
 134 EXPORT_SYMBOL(memcpy_fromiovecend);
 135
 136 /*
 137  *      And now for the all-in-one: copy and checksum from a user iovec
 138  *      directly to a datagram
 139  *      Calls to csum_partial but the last must be in 32 bit chunks
 140  *
 141  *      ip_build_xmit must ensure that when fragmenting only the last
 142  *      call to this function will be unaligned also.
 143  */
 144 int csum_partial_copy_fromiovecend(unsigned char *kdata, struct iovec *iov,
 145                                  int offset, unsigned int len, __wsum *csump)
 146 {
 147         __wsum csum = *csump;
 148         int partial_cnt = 0, err = 0;
 149
 150         /* Skip over the finished iovecs */
 151         while (offset >= iov->iov_len) {
 152                 offset -= iov->iov_len;
 153                 iov++;
 154         }
 155
 156         while (len > 0) {
 157                 u8 __user *base = iov->iov_base + offset;
 158                 int copy = min_t(unsigned int, len, iov->iov_len - offset);
 159
 160                 offset = 0;
 161
 162                 /* There is a remnant from previous iov. */
 163                 if (partial_cnt) {
 164                         int par_len = 4 - partial_cnt;
 165
 166                         /* iov component is too short ... */
 167                         if (par_len > copy) {
 168                                 if (copy_from_user(kdata, base, copy))
 169                                         goto out_fault;
 170                                 kdata += copy;
 171                                 base += copy;
 172                                 partial_cnt += copy;
 173                                 len -= copy;
 174                                 iov++;
 175                                 if (len)
 176                                         continue;
 177                                 *csump = csum_partial(kdata - partial_cnt,
 178                                                          partial_cnt, csum);
 179                                 goto out;
 180                         }
 181                         if (copy_from_user(kdata, base, par_len))
 182                                 goto out_fault;
 183                         csum = csum_partial(kdata - partial_cnt, 4, csum);
 184                         kdata += par_len;
 185                         base  += par_len;
 186                         copy  -= par_len;
 187                         len   -= par_len;
 188                         partial_cnt = 0;
 189                 }
 190
 191                 if (len > copy) {
 192                         partial_cnt = copy % 4;
 193                         if (partial_cnt) {
 194                                 copy -= partial_cnt;
 195                                 if (copy_from_user(kdata + copy, base + copy,
 196                                                 partial_cnt))
 197                                         goto out_fault;
 198                         }
 199                 }
 200
 201                 if (copy) {
 202                         csum = csum_and_copy_from_user(base, kdata, copy,
 203                                                         csum, &err);
 204                         if (err)
 205                                 goto out;
 206                 }
 207                 len   -= copy + partial_cnt;
 208                 kdata += copy + partial_cnt;
 209                 iov++;
 210         }
 211         *csump = csum;
 212 out:
 213         return err;
 214
 215 out_fault:
 216         err = -EFAULT;
 217         goto out;
 218 }
 219 EXPORT_SYMBOL(csum_partial_copy_fromiovecend);
 220
 221 unsigned long iov_pages(const struct iovec *iov, int offset,
 222                         unsigned long nr_segs)
 223 {
 224         unsigned long seg, base;
 225         int pages = 0, len, size;
 226
 227         while (nr_segs && (offset >= iov->iov_len)) {
 228                 offset -= iov->iov_len;
 229                 ++iov;
 230                 --nr_segs;
 231         }
 232
 233         for (seg = 0; seg < nr_segs; seg++) {
 234                 base = (unsigned long)iov[seg].iov_base + offset;
 235                 len = iov[seg].iov_len - offset;
 236                 size = ((base & ~PAGE_MASK) + len + ~PAGE_MASK) >> PAGE_SHIFT;
 237                 pages += size;
 238                 offset = 0;
 239         }
 240
 241         return pages;
 242 }
 243 EXPORT_SYMBOL(iov_pages);