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         struct iovec *res;
  41         int err;
  42
  43         if (m->msg_name && m->msg_namelen) {
  44                 if (mode == WRITE) {
  45                         void __user *namep = (void __user __force *)m->msg_name;
  46                         int 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         if (m->msg_iovlen > UIO_MAXIOV)
  57                 return -EMSGSIZE;
  58
  59         err = rw_copy_check_uvector(mode, (void __user __force *)m->msg_iov,
  60                                     m->msg_iovlen, UIO_FASTIOV, iov, &res);
  61         if (err >= 0)
  62                 m->msg_iov = res;
  63         else if (res != iov)
  64                 kfree(res);
  65         return err;
  66 }
  67
  68 /*
  69  *      And now for the all-in-one: copy and checksum from a user iovec
  70  *      directly to a datagram
  71  *      Calls to csum_partial but the last must be in 32 bit chunks
  72  *
  73  *      ip_build_xmit must ensure that when fragmenting only the last
  74  *      call to this function will be unaligned also.
  75  */
  76 int csum_partial_copy_fromiovecend(unsigned char *kdata, struct iovec *iov,
  77                                  int offset, unsigned int len, __wsum *csump)
  78 {
  79         __wsum csum = *csump;
  80         int partial_cnt = 0, err = 0;
  81
  82         /* Skip over the finished iovecs */
  83         while (offset >= iov->iov_len) {
  84                 offset -= iov->iov_len;
  85                 iov++;
  86         }
  87
  88         while (len > 0) {
  89                 u8 __user *base = iov->iov_base + offset;
  90                 int copy = min_t(unsigned int, len, iov->iov_len - offset);
  91
  92                 offset = 0;
  93
  94                 /* There is a remnant from previous iov. */
  95                 if (partial_cnt) {
  96                         int par_len = 4 - partial_cnt;
  97
  98                         /* iov component is too short ... */
  99                         if (par_len > copy) {
 100                                 if (copy_from_user(kdata, base, copy))
 101                                         goto out_fault;
 102                                 kdata += copy;
 103                                 base += copy;
 104                                 partial_cnt += copy;
 105                                 len -= copy;
 106                                 iov++;
 107                                 if (len)
 108                                         continue;
 109                                 *csump = csum_partial(kdata - partial_cnt,
 110                                                          partial_cnt, csum);
 111                                 goto out;
 112                         }
 113                         if (copy_from_user(kdata, base, par_len))
 114                                 goto out_fault;
 115                         csum = csum_partial(kdata - partial_cnt, 4, csum);
 116                         kdata += par_len;
 117                         base  += par_len;
 118                         copy  -= par_len;
 119                         len   -= par_len;
 120                         partial_cnt = 0;
 121                 }
 122
 123                 if (len > copy) {
 124                         partial_cnt = copy % 4;
 125                         if (partial_cnt) {
 126                                 copy -= partial_cnt;
 127                                 if (copy_from_user(kdata + copy, base + copy,
 128                                                 partial_cnt))
 129                                         goto out_fault;
 130                         }
 131                 }
 132
 133                 if (copy) {
 134                         csum = csum_and_copy_from_user(base, kdata, copy,
 135                                                         csum, &err);
 136                         if (err)
 137                                 goto out;
 138                 }
 139                 len   -= copy + partial_cnt;
 140                 kdata += copy + partial_cnt;
 141                 iov++;
 142         }
 143         *csump = csum;
 144 out:
 145         return err;
 146
 147 out_fault:
 148         err = -EFAULT;
 149         goto out;
 150 }
 151 EXPORT_SYMBOL(csum_partial_copy_fromiovecend);
 152
 153 unsigned long iov_pages(const struct iovec *iov, int offset,
 154                         unsigned long nr_segs)
 155 {
 156         unsigned long seg, base;
 157         int pages = 0, len, size;
 158
 159         while (nr_segs && (offset >= iov->iov_len)) {
 160                 offset -= iov->iov_len;
 161                 ++iov;
 162                 --nr_segs;
 163         }
 164
 165         for (seg = 0; seg < nr_segs; seg++) {
 166                 base = (unsigned long)iov[seg].iov_base + offset;
 167                 len = iov[seg].iov_len - offset;
 168                 size = ((base & ~PAGE_MASK) + len + ~PAGE_MASK) >> PAGE_SHIFT;
 169                 pages += size;
 170                 offset = 0;
 171         }
 172
 173         return pages;
 174 }
 175 EXPORT_SYMBOL(iov_pages);