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