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