blob: b61869429f4ced5a2ed08b178c20fc998bbfdaf2 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/kernel.h>
22#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#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 *
Jesper Juhle49332b2005-05-01 08:59:08 -070034 * Save time not doing access_ok. copy_*_user will make this work
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 * in any case.
36 */
37
Maciej Żenczykowski43db3622012-03-11 12:51:50 +000038int verify_iovec(struct msghdr *m, struct iovec *iov, struct sockaddr_storage *address, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -070039{
David S. Miller8acfe462010-10-28 11:41:55 -070040 int size, ct, err;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +090041
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 if (m->msg_namelen) {
43 if (mode == VERIFY_READ) {
Namhyung Kima700d8b2010-09-08 03:48:47 +000044 void __user *namep;
45 namep = (void __user __force *) m->msg_name;
46 err = move_addr_to_kernel(namep, m->msg_namelen,
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 address);
48 if (err < 0)
49 return err;
50 }
Hannes Frederic Sowaf3d33422013-11-21 03:14:22 +010051 if (m->msg_name)
52 m->msg_name = address;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 } else {
54 m->msg_name = NULL;
55 }
56
57 size = m->msg_iovlen * sizeof(struct iovec);
Namhyung Kima700d8b2010-09-08 03:48:47 +000058 if (copy_from_user(iov, (void __user __force *) m->msg_iov, size))
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 return -EFAULT;
60
61 m->msg_iov = iov;
62 err = 0;
63
64 for (ct = 0; ct < m->msg_iovlen; ct++) {
David S. Miller8acfe462010-10-28 11:41:55 -070065 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 }
73
74 return err;
75}
76
77/*
78 * Copy kernel to iovec. Returns -EFAULT on error.
Michael S. Tsirkin0a1ec072009-04-20 01:25:46 +000079 */
80
81int 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);
Sridhar Samudrala2faef522009-06-05 09:35:44 +000092 if (copy_to_user(iov->iov_base + offset, kdata, copy))
Michael S. Tsirkin0a1ec072009-04-20 01:25:46 +000093 return -EFAULT;
Sridhar Samudrala2faef522009-06-05 09:35:44 +000094 offset = 0;
Michael S. Tsirkin0a1ec072009-04-20 01:25:46 +000095 kdata += copy;
96 len -= copy;
97 }
98
99 return 0;
100}
Eric Dumazet9e34a5b2010-07-09 21:22:04 +0000101EXPORT_SYMBOL(memcpy_toiovecend);
Michael S. Tsirkin0a1ec072009-04-20 01:25:46 +0000102
103/*
Zhi Yong Wuab1a2d72013-10-28 14:01:50 +0800104 * Copy iovec to kernel. Returns -EFAULT on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 */
Michael S. Tsirkin6f26c9a2009-04-20 01:26:11 +0000106
107int memcpy_fromiovecend(unsigned char *kdata, const struct iovec *iov,
108 int offset, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109{
110 /* Skip over the finished iovecs */
111 while (offset >= iov->iov_len) {
112 offset -= iov->iov_len;
113 iov++;
114 }
115
116 while (len > 0) {
117 u8 __user *base = iov->iov_base + offset;
118 int copy = min_t(unsigned int, len, iov->iov_len - offset);
119
120 offset = 0;
121 if (copy_from_user(kdata, base, copy))
122 return -EFAULT;
123 len -= copy;
124 kdata += copy;
125 iov++;
126 }
127
128 return 0;
129}
Eric Dumazet9e34a5b2010-07-09 21:22:04 +0000130EXPORT_SYMBOL(memcpy_fromiovecend);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
132/*
133 * And now for the all-in-one: copy and checksum from a user iovec
134 * directly to a datagram
135 * Calls to csum_partial but the last must be in 32 bit chunks
136 *
137 * ip_build_xmit must ensure that when fragmenting only the last
138 * call to this function will be unaligned also.
139 */
140int csum_partial_copy_fromiovecend(unsigned char *kdata, struct iovec *iov,
Al Viro44bb9362006-11-14 21:36:14 -0800141 int offset, unsigned int len, __wsum *csump)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142{
Al Viro44bb9362006-11-14 21:36:14 -0800143 __wsum csum = *csump;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 int partial_cnt = 0, err = 0;
145
146 /* Skip over the finished iovecs */
147 while (offset >= iov->iov_len) {
148 offset -= iov->iov_len;
149 iov++;
150 }
151
152 while (len > 0) {
153 u8 __user *base = iov->iov_base + offset;
154 int copy = min_t(unsigned int, len, iov->iov_len - offset);
155
156 offset = 0;
157
158 /* There is a remnant from previous iov. */
159 if (partial_cnt) {
160 int par_len = 4 - partial_cnt;
161
162 /* iov component is too short ... */
163 if (par_len > copy) {
164 if (copy_from_user(kdata, base, copy))
165 goto out_fault;
166 kdata += copy;
167 base += copy;
168 partial_cnt += copy;
169 len -= copy;
170 iov++;
171 if (len)
172 continue;
173 *csump = csum_partial(kdata - partial_cnt,
174 partial_cnt, csum);
175 goto out;
176 }
177 if (copy_from_user(kdata, base, par_len))
178 goto out_fault;
179 csum = csum_partial(kdata - partial_cnt, 4, csum);
180 kdata += par_len;
181 base += par_len;
182 copy -= par_len;
183 len -= par_len;
184 partial_cnt = 0;
185 }
186
187 if (len > copy) {
188 partial_cnt = copy % 4;
189 if (partial_cnt) {
190 copy -= partial_cnt;
191 if (copy_from_user(kdata + copy, base + copy,
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900192 partial_cnt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 goto out_fault;
194 }
195 }
196
197 if (copy) {
198 csum = csum_and_copy_from_user(base, kdata, copy,
199 csum, &err);
200 if (err)
201 goto out;
202 }
203 len -= copy + partial_cnt;
204 kdata += copy + partial_cnt;
205 iov++;
206 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900207 *csump = csum;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208out:
209 return err;
210
211out_fault:
212 err = -EFAULT;
213 goto out;
214}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215EXPORT_SYMBOL(csum_partial_copy_fromiovecend);
Jason Wangb4bf0772013-08-06 17:45:03 +0800216
217unsigned long iov_pages(const struct iovec *iov, int offset,
218 unsigned long nr_segs)
219{
220 unsigned long seg, base;
221 int pages = 0, len, size;
222
223 while (nr_segs && (offset >= iov->iov_len)) {
224 offset -= iov->iov_len;
225 ++iov;
226 --nr_segs;
227 }
228
229 for (seg = 0; seg < nr_segs; seg++) {
230 base = (unsigned long)iov[seg].iov_base + offset;
231 len = iov[seg].iov_len - offset;
232 size = ((base & ~PAGE_MASK) + len + ~PAGE_MASK) >> PAGE_SHIFT;
233 pages += size;
234 offset = 0;
235 }
236
237 return pages;
238}
239EXPORT_SYMBOL(iov_pages);