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