18 #define iterate_iovec(i, n, __v, __p, skip, STEP) {	\  argument
21 	__p = i->iov;					\
46 #define iterate_kvec(i, n, __v, __p, skip, STEP) {	\  argument
48 	__p = i->kvec;					\
69 #define iterate_bvec(i, n, __v, __bi, skip, STEP) {	\  argument
74 	for_each_bvec(__v, i->bvec, __bi, __start) {	\
81 #define iterate_all_kinds(i, n, v, I, B, K) {			\  argument
83 		size_t skip = i->iov_offset;			\
84 		if (unlikely(i->type & ITER_BVEC)) {		\
87 			iterate_bvec(i, n, v, __bi, skip, (B))	\
88 		} else if (unlikely(i->type & ITER_KVEC)) {	\
91 			iterate_kvec(i, n, v, kvec, skip, (K))	\
92 		} else if (unlikely(i->type & ITER_DISCARD)) {	\
96 			iterate_iovec(i, n, v, iov, skip, (I))	\
101 #define iterate_and_advance(i, n, v, I, B, K) {			\  argument
102 	if (unlikely(i->count < n))				\
103 		n = i->count;					\
104 	if (i->count) {						\
105 		size_t skip = i->iov_offset;			\
106 		if (unlikely(i->type & ITER_BVEC)) {		\
107 			const struct bio_vec *bvec = i->bvec;	\
110 			iterate_bvec(i, n, v, __bi, skip, (B))	\
111 			i->bvec = __bvec_iter_bvec(i->bvec, __bi);	\
112 			i->nr_segs -= i->bvec - bvec;		\
114 		} else if (unlikely(i->type & ITER_KVEC)) {	\
117 			iterate_kvec(i, n, v, kvec, skip, (K))	\
122 			i->nr_segs -= kvec - i->kvec;		\
123 			i->kvec = kvec;				\
124 		} else if (unlikely(i->type & ITER_DISCARD)) {	\
129 			iterate_iovec(i, n, v, iov, skip, (I))	\
134 			i->nr_segs -= iov - i->iov;		\
135 			i->iov = iov;				\
137 		i->count -= n;					\
138 		i->iov_offset = skip;				\
165 			 struct iov_iter *i)  in copy_page_to_iter_iovec()  argument
172 	if (unlikely(bytes > i->count))  in copy_page_to_iter_iovec()
173 		bytes = i->count;  in copy_page_to_iter_iovec()
180 	iov = i->iov;  in copy_page_to_iter_iovec()
181 	skip = i->iov_offset;  in copy_page_to_iter_iovec()
241 	i->count -= wanted - bytes;  in copy_page_to_iter_iovec()
242 	i->nr_segs -= iov - i->iov;  in copy_page_to_iter_iovec()
243 	i->iov = iov;  in copy_page_to_iter_iovec()
244 	i->iov_offset = skip;  in copy_page_to_iter_iovec()
249 			 struct iov_iter *i)  in copy_page_from_iter_iovec()  argument
256 	if (unlikely(bytes > i->count))  in copy_page_from_iter_iovec()
257 		bytes = i->count;  in copy_page_from_iter_iovec()
264 	iov = i->iov;  in copy_page_from_iter_iovec()
265 	skip = i->iov_offset;  in copy_page_from_iter_iovec()
325 	i->count -= wanted - bytes;  in copy_page_from_iter_iovec()
326 	i->nr_segs -= iov - i->iov;  in copy_page_from_iter_iovec()
327 	i->iov = iov;  in copy_page_from_iter_iovec()
328 	i->iov_offset = skip;  in copy_page_from_iter_iovec()
333 static bool sanity(const struct iov_iter *i)  in sanity()  argument
335 	struct pipe_inode_info *pipe = i->pipe;  in sanity()
340 	unsigned int i_head = i->head;  in sanity()
343 	if (i->iov_offset) {  in sanity()
351 		if (unlikely(p->offset + p->len != i->iov_offset))  in sanity()
359 	printk(KERN_ERR "idx = %d, offset = %zd\n", i_head, i->iov_offset);  in sanity()
372 #define sanity(i) true  argument
376 			 struct iov_iter *i)  in copy_page_to_iter_pipe()  argument
378 	struct pipe_inode_info *pipe = i->pipe;  in copy_page_to_iter_pipe()
382 	unsigned int i_head = i->head;  in copy_page_to_iter_pipe()
385 	if (unlikely(bytes > i->count))  in copy_page_to_iter_pipe()
386 		bytes = i->count;  in copy_page_to_iter_pipe()
391 	if (!sanity(i))  in copy_page_to_iter_pipe()
394 	off = i->iov_offset;  in copy_page_to_iter_pipe()
400 			i->iov_offset += bytes;  in copy_page_to_iter_pipe()
416 	i->iov_offset = offset + bytes;  in copy_page_to_iter_pipe()
417 	i->head = i_head;  in copy_page_to_iter_pipe()
419 	i->count -= bytes;  in copy_page_to_iter_pipe()
427  * Return 0 on success, or non-zero if the memory could not be accessed (i.e.
430 int iov_iter_fault_in_readable(struct iov_iter *i, size_t bytes)  in iov_iter_fault_in_readable()  argument
432 	size_t skip = i->iov_offset;  in iov_iter_fault_in_readable()
437 	if (!(i->type & (ITER_BVEC|ITER_KVEC))) {  in iov_iter_fault_in_readable()
438 		iterate_iovec(i, bytes, v, iov, skip, ({  in iov_iter_fault_in_readable()
448 void iov_iter_init(struct iov_iter *i, unsigned int direction,  in iov_iter_init()  argument
457 		i->type = ITER_KVEC | direction;  in iov_iter_init()
458 		i->kvec = (struct kvec *)iov;  in iov_iter_init()
460 		i->type = ITER_IOVEC | direction;  in iov_iter_init()
461 		i->iov = iov;  in iov_iter_init()
463 	i->nr_segs = nr_segs;  in iov_iter_init()
464 	i->iov_offset = 0;  in iov_iter_init()
465 	i->count = count;  in iov_iter_init()
495 static inline void data_start(const struct iov_iter *i,  in data_start()  argument
498 	unsigned int p_mask = i->pipe->ring_size - 1;  in data_start()
499 	unsigned int iter_head = i->head;  in data_start()
500 	size_t off = i->iov_offset;  in data_start()
502 	if (off && (!allocated(&i->pipe->bufs[iter_head & p_mask]) ||  in data_start()
511 static size_t push_pipe(struct iov_iter *i, size_t size,  in push_pipe()  argument
514 	struct pipe_inode_info *pipe = i->pipe;  in push_pipe()
521 	if (unlikely(size > i->count))  in push_pipe()
522 		size = i->count;  in push_pipe()
527 	data_start(i, &iter_head, &off);  in push_pipe()
560 				struct iov_iter *i)  in copy_pipe_to_iter()  argument
562 	struct pipe_inode_info *pipe = i->pipe;  in copy_pipe_to_iter()
567 	if (!sanity(i))  in copy_pipe_to_iter()
570 	bytes = n = push_pipe(i, bytes, &i_head, &off);  in copy_pipe_to_iter()
576 		i->head = i_head;  in copy_pipe_to_iter()
577 		i->iov_offset = off + chunk;  in copy_pipe_to_iter()
583 	i->count -= bytes;  in copy_pipe_to_iter()
595 				__wsum *csum, struct iov_iter *i)  in csum_and_copy_to_pipe_iter()  argument
597 	struct pipe_inode_info *pipe = i->pipe;  in csum_and_copy_to_pipe_iter()
604 	if (!sanity(i))  in csum_and_copy_to_pipe_iter()
607 	bytes = n = push_pipe(i, bytes, &i_head, &r);  in csum_and_copy_to_pipe_iter()
615 		i->head = i_head;  in csum_and_copy_to_pipe_iter()
616 		i->iov_offset = r + chunk;  in csum_and_copy_to_pipe_iter()
623 	i->count -= bytes;  in csum_and_copy_to_pipe_iter()
628 size_t _copy_to_iter(const void *addr, size_t bytes, struct iov_iter *i)  in _copy_to_iter()  argument
631 	if (unlikely(iov_iter_is_pipe(i)))  in _copy_to_iter()
632 		return copy_pipe_to_iter(addr, bytes, i);  in _copy_to_iter()
633 	if (iter_is_iovec(i))  in _copy_to_iter()
635 	iterate_and_advance(i, bytes, v,  in _copy_to_iter()
670 				struct iov_iter *i)  in copy_mc_pipe_to_iter()  argument
672 	struct pipe_inode_info *pipe = i->pipe;  in copy_mc_pipe_to_iter()
677 	if (!sanity(i))  in copy_mc_pipe_to_iter()
680 	bytes = n = push_pipe(i, bytes, &i_head, &off);  in copy_mc_pipe_to_iter()
689 		i->head = i_head;  in copy_mc_pipe_to_iter()
690 		i->iov_offset = off + chunk - rem;  in copy_mc_pipe_to_iter()
699 	i->count -= xfer;  in copy_mc_pipe_to_iter()
726 size_t _copy_mc_to_iter(const void *addr, size_t bytes, struct iov_iter *i)  in _copy_mc_to_iter()  argument
731 	if (unlikely(iov_iter_is_pipe(i)))  in _copy_mc_to_iter()
732 		return copy_mc_pipe_to_iter(addr, bytes, i);  in _copy_mc_to_iter()
733 	if (iter_is_iovec(i))  in _copy_mc_to_iter()
735 	iterate_and_advance(i, bytes, v,  in _copy_mc_to_iter()
763 size_t _copy_from_iter(void *addr, size_t bytes, struct iov_iter *i)  in _copy_from_iter()  argument
766 	if (unlikely(iov_iter_is_pipe(i))) {  in _copy_from_iter()
770 	if (iter_is_iovec(i))  in _copy_from_iter()
772 	iterate_and_advance(i, bytes, v,  in _copy_from_iter()
783 bool _copy_from_iter_full(void *addr, size_t bytes, struct iov_iter *i)  in _copy_from_iter_full()  argument
786 	if (unlikely(iov_iter_is_pipe(i))) {  in _copy_from_iter_full()
790 	if (unlikely(i->count < bytes))  in _copy_from_iter_full()
793 	if (iter_is_iovec(i))  in _copy_from_iter_full()
795 	iterate_all_kinds(i, bytes, v, ({  in _copy_from_iter_full()
805 	iov_iter_advance(i, bytes);  in _copy_from_iter_full()
810 size_t _copy_from_iter_nocache(void *addr, size_t bytes, struct iov_iter *i)  in _copy_from_iter_nocache()  argument
813 	if (unlikely(iov_iter_is_pipe(i))) {  in _copy_from_iter_nocache()
817 	iterate_and_advance(i, bytes, v,  in _copy_from_iter_nocache()
844 size_t _copy_from_iter_flushcache(void *addr, size_t bytes, struct iov_iter *i)  in _copy_from_iter_flushcache()  argument
847 	if (unlikely(iov_iter_is_pipe(i))) {  in _copy_from_iter_flushcache()
851 	iterate_and_advance(i, bytes, v,  in _copy_from_iter_flushcache()
865 bool _copy_from_iter_full_nocache(void *addr, size_t bytes, struct iov_iter *i)  in _copy_from_iter_full_nocache()  argument
868 	if (unlikely(iov_iter_is_pipe(i))) {  in _copy_from_iter_full_nocache()
872 	if (unlikely(i->count < bytes))  in _copy_from_iter_full_nocache()
874 	iterate_all_kinds(i, bytes, v, ({  in _copy_from_iter_full_nocache()
884 	iov_iter_advance(i, bytes);  in _copy_from_iter_full_nocache()
914 			 struct iov_iter *i)  in copy_page_to_iter()  argument
918 	if (i->type & (ITER_BVEC|ITER_KVEC)) {  in copy_page_to_iter()
920 		size_t wanted = copy_to_iter(kaddr + offset, bytes, i);  in copy_page_to_iter()
923 	} else if (unlikely(iov_iter_is_discard(i)))  in copy_page_to_iter()
925 	else if (likely(!iov_iter_is_pipe(i)))  in copy_page_to_iter()
926 		return copy_page_to_iter_iovec(page, offset, bytes, i);  in copy_page_to_iter()
928 		return copy_page_to_iter_pipe(page, offset, bytes, i);  in copy_page_to_iter()
933 			 struct iov_iter *i)  in copy_page_from_iter()  argument
937 	if (unlikely(iov_iter_is_pipe(i) || iov_iter_is_discard(i))) {  in copy_page_from_iter()
941 	if (i->type & (ITER_BVEC|ITER_KVEC)) {  in copy_page_from_iter()
943 		size_t wanted = _copy_from_iter(kaddr + offset, bytes, i);  in copy_page_from_iter()
947 		return copy_page_from_iter_iovec(page, offset, bytes, i);  in copy_page_from_iter()
951 static size_t pipe_zero(size_t bytes, struct iov_iter *i)  in pipe_zero()  argument
953 	struct pipe_inode_info *pipe = i->pipe;  in pipe_zero()
958 	if (!sanity(i))  in pipe_zero()
961 	bytes = n = push_pipe(i, bytes, &i_head, &off);  in pipe_zero()
968 		i->head = i_head;  in pipe_zero()
969 		i->iov_offset = off + chunk;  in pipe_zero()
974 	i->count -= bytes;  in pipe_zero()
978 size_t iov_iter_zero(size_t bytes, struct iov_iter *i)  in iov_iter_zero()  argument
980 	if (unlikely(iov_iter_is_pipe(i)))  in iov_iter_zero()
981 		return pipe_zero(bytes, i);  in iov_iter_zero()
982 	iterate_and_advance(i, bytes, v,  in iov_iter_zero()
993 		struct iov_iter *i, unsigned long offset, size_t bytes)  in iov_iter_copy_from_user_atomic()  argument
1000 	if (unlikely(iov_iter_is_pipe(i) || iov_iter_is_discard(i))) {  in iov_iter_copy_from_user_atomic()
1005 	iterate_all_kinds(i, bytes, v,  in iov_iter_copy_from_user_atomic()
1016 static inline void pipe_truncate(struct iov_iter *i)  in pipe_truncate()  argument
1018 	struct pipe_inode_info *pipe = i->pipe;  in pipe_truncate()
1025 		unsigned int i_head = i->head;  in pipe_truncate()
1026 		size_t off = i->iov_offset;  in pipe_truncate()
1042 static void pipe_advance(struct iov_iter *i, size_t size)  in pipe_advance()  argument
1044 	struct pipe_inode_info *pipe = i->pipe;  in pipe_advance()
1045 	if (unlikely(i->count < size))  in pipe_advance()
1046 		size = i->count;  in pipe_advance()
1050 		unsigned int i_head = i->head;  in pipe_advance()
1051 		size_t off = i->iov_offset, left = size;  in pipe_advance()
1062 		i->head = i_head;  in pipe_advance()
1063 		i->iov_offset = buf->offset + left;  in pipe_advance()
1065 	i->count -= size;  in pipe_advance()
1067 	pipe_truncate(i);  in pipe_advance()
1070 void iov_iter_advance(struct iov_iter *i, size_t size)  in iov_iter_advance()  argument
1072 	if (unlikely(iov_iter_is_pipe(i))) {  in iov_iter_advance()
1073 		pipe_advance(i, size);  in iov_iter_advance()
1076 	if (unlikely(iov_iter_is_discard(i))) {  in iov_iter_advance()
1077 		i->count -= size;  in iov_iter_advance()
1080 	iterate_and_advance(i, size, v, 0, 0, 0)  in iov_iter_advance()
1084 void iov_iter_revert(struct iov_iter *i, size_t unroll)  in iov_iter_revert()  argument
1090 	i->count += unroll;  in iov_iter_revert()
1091 	if (unlikely(iov_iter_is_pipe(i))) {  in iov_iter_revert()
1092 		struct pipe_inode_info *pipe = i->pipe;  in iov_iter_revert()
1094 		unsigned int i_head = i->head;  in iov_iter_revert()
1095 		size_t off = i->iov_offset;  in iov_iter_revert()
1104 			if (!unroll && i_head == i->start_head) {  in iov_iter_revert()
1112 		i->iov_offset = off;  in iov_iter_revert()
1113 		i->head = i_head;  in iov_iter_revert()
1114 		pipe_truncate(i);  in iov_iter_revert()
1117 	if (unlikely(iov_iter_is_discard(i)))  in iov_iter_revert()
1119 	if (unroll <= i->iov_offset) {  in iov_iter_revert()
1120 		i->iov_offset -= unroll;  in iov_iter_revert()
1123 	unroll -= i->iov_offset;  in iov_iter_revert()
1124 	if (iov_iter_is_bvec(i)) {  in iov_iter_revert()
1125 		const struct bio_vec *bvec = i->bvec;  in iov_iter_revert()
1128 			i->nr_segs++;  in iov_iter_revert()
1130 				i->bvec = bvec;  in iov_iter_revert()
1131 				i->iov_offset = n - unroll;  in iov_iter_revert()
1137 		const struct iovec *iov = i->iov;  in iov_iter_revert()
1140 			i->nr_segs++;  in iov_iter_revert()
1142 				i->iov = iov;  in iov_iter_revert()
1143 				i->iov_offset = n - unroll;  in iov_iter_revert()
1155 size_t iov_iter_single_seg_count(const struct iov_iter *i)  in iov_iter_single_seg_count()  argument
1157 	if (unlikely(iov_iter_is_pipe(i)))  in iov_iter_single_seg_count()
1158 		return i->count;	// it is a silly place, anyway  in iov_iter_single_seg_count()
1159 	if (i->nr_segs == 1)  in iov_iter_single_seg_count()
1160 		return i->count;  in iov_iter_single_seg_count()
1161 	if (unlikely(iov_iter_is_discard(i)))  in iov_iter_single_seg_count()
1162 		return i->count;  in iov_iter_single_seg_count()
1163 	else if (iov_iter_is_bvec(i))  in iov_iter_single_seg_count()
1164 		return min(i->count, i->bvec->bv_len - i->iov_offset);  in iov_iter_single_seg_count()
1166 		return min(i->count, i->iov->iov_len - i->iov_offset);  in iov_iter_single_seg_count()
1170 void iov_iter_kvec(struct iov_iter *i, unsigned int direction,  in iov_iter_kvec()  argument
1175 	i->type = ITER_KVEC | (direction & (READ | WRITE));  in iov_iter_kvec()
1176 	i->kvec = kvec;  in iov_iter_kvec()
1177 	i->nr_segs = nr_segs;  in iov_iter_kvec()
1178 	i->iov_offset = 0;  in iov_iter_kvec()
1179 	i->count = count;  in iov_iter_kvec()
1183 void iov_iter_bvec(struct iov_iter *i, unsigned int direction,  in iov_iter_bvec()  argument
1188 	i->type = ITER_BVEC | (direction & (READ | WRITE));  in iov_iter_bvec()
1189 	i->bvec = bvec;  in iov_iter_bvec()
1190 	i->nr_segs = nr_segs;  in iov_iter_bvec()
1191 	i->iov_offset = 0;  in iov_iter_bvec()
1192 	i->count = count;  in iov_iter_bvec()
1196 void iov_iter_pipe(struct iov_iter *i, unsigned int direction,  in iov_iter_pipe()  argument
1202 	i->type = ITER_PIPE | READ;  in iov_iter_pipe()
1203 	i->pipe = pipe;  in iov_iter_pipe()
1204 	i->head = pipe->head;  in iov_iter_pipe()
1205 	i->iov_offset = 0;  in iov_iter_pipe()
1206 	i->count = count;  in iov_iter_pipe()
1207 	i->start_head = i->head;  in iov_iter_pipe()
1212  * iov_iter_discard - Initialise an I/O iterator that discards data
1213  * @i: The iterator to initialise.
1215  * @count: The size of the I/O buffer in bytes.
1217  * Set up an I/O iterator that just discards everything that's written to it.
1220 void iov_iter_discard(struct iov_iter *i, unsigned int direction, size_t count)  in iov_iter_discard()  argument
1223 	i->type = ITER_DISCARD | READ;  in iov_iter_discard()
1224 	i->count = count;  in iov_iter_discard()
1225 	i->iov_offset = 0;  in iov_iter_discard()
1229 unsigned long iov_iter_alignment(const struct iov_iter *i)  in iov_iter_alignment()  argument
1232 	size_t size = i->count;  in iov_iter_alignment()
1234 	if (unlikely(iov_iter_is_pipe(i))) {  in iov_iter_alignment()
1235 		unsigned int p_mask = i->pipe->ring_size - 1;  in iov_iter_alignment()
1237 		if (size && i->iov_offset && allocated(&i->pipe->bufs[i->head & p_mask]))  in iov_iter_alignment()
1238 			return size | i->iov_offset;  in iov_iter_alignment()
1241 	iterate_all_kinds(i, size, v,  in iov_iter_alignment()
1250 unsigned long iov_iter_gap_alignment(const struct iov_iter *i)  in iov_iter_gap_alignment()  argument
1253 	size_t size = i->count;  in iov_iter_gap_alignment()
1255 	if (unlikely(iov_iter_is_pipe(i) || iov_iter_is_discard(i))) {  in iov_iter_gap_alignment()
1260 	iterate_all_kinds(i, size, v,  in iov_iter_gap_alignment()
1272 static inline ssize_t __pipe_get_pages(struct iov_iter *i,  in __pipe_get_pages()  argument
1278 	struct pipe_inode_info *pipe = i->pipe;  in __pipe_get_pages()
1280 	ssize_t n = push_pipe(i, maxsize, &iter_head, start);  in __pipe_get_pages()
1295 static ssize_t pipe_get_pages(struct iov_iter *i,  in pipe_get_pages()  argument
1305 	if (!sanity(i))  in pipe_get_pages()
1308 	data_start(i, &iter_head, start);  in pipe_get_pages()
1310 	npages = pipe_space_for_user(iter_head, i->pipe->tail, i->pipe);  in pipe_get_pages()
1313 	return __pipe_get_pages(i, min(maxsize, capacity), pages, iter_head, start);  in pipe_get_pages()
1316 ssize_t iov_iter_get_pages(struct iov_iter *i,  in iov_iter_get_pages()  argument
1320 	if (maxsize > i->count)  in iov_iter_get_pages()
1321 		maxsize = i->count;  in iov_iter_get_pages()
1323 	if (unlikely(iov_iter_is_pipe(i)))  in iov_iter_get_pages()
1324 		return pipe_get_pages(i, pages, maxsize, maxpages, start);  in iov_iter_get_pages()
1325 	if (unlikely(iov_iter_is_discard(i)))  in iov_iter_get_pages()
1328 	iterate_all_kinds(i, maxsize, v, ({  in iov_iter_get_pages()
1339 				iov_iter_rw(i) != WRITE ?  FOLL_WRITE : 0,  in iov_iter_get_pages()
1362 static ssize_t pipe_get_pages_alloc(struct iov_iter *i,  in pipe_get_pages_alloc()  argument
1373 	if (!sanity(i))  in pipe_get_pages_alloc()
1376 	data_start(i, &iter_head, start);  in pipe_get_pages_alloc()
1378 	npages = pipe_space_for_user(iter_head, i->pipe->tail, i->pipe);  in pipe_get_pages_alloc()
1387 	n = __pipe_get_pages(i, maxsize, p, iter_head, start);  in pipe_get_pages_alloc()
1395 ssize_t iov_iter_get_pages_alloc(struct iov_iter *i,  in iov_iter_get_pages_alloc()  argument
1401 	if (maxsize > i->count)  in iov_iter_get_pages_alloc()
1402 		maxsize = i->count;  in iov_iter_get_pages_alloc()
1404 	if (unlikely(iov_iter_is_pipe(i)))  in iov_iter_get_pages_alloc()
1405 		return pipe_get_pages_alloc(i, pages, maxsize, start);  in iov_iter_get_pages_alloc()
1406 	if (unlikely(iov_iter_is_discard(i)))  in iov_iter_get_pages_alloc()
1409 	iterate_all_kinds(i, maxsize, v, ({  in iov_iter_get_pages_alloc()
1421 				iov_iter_rw(i) != WRITE ?  FOLL_WRITE : 0, p);  in iov_iter_get_pages_alloc()
1445 			       struct iov_iter *i)  in csum_and_copy_from_iter()  argument
1451 	if (unlikely(iov_iter_is_pipe(i) || iov_iter_is_discard(i))) {  in csum_and_copy_from_iter()
1455 	iterate_and_advance(i, bytes, v, ({  in csum_and_copy_from_iter()
1484 			       struct iov_iter *i)  in csum_and_copy_from_iter_full()  argument
1490 	if (unlikely(iov_iter_is_pipe(i) || iov_iter_is_discard(i))) {  in csum_and_copy_from_iter_full()
1494 	if (unlikely(i->count < bytes))  in csum_and_copy_from_iter_full()
1496 	iterate_all_kinds(i, bytes, v, ({  in csum_and_copy_from_iter_full()
1520 	iov_iter_advance(i, bytes);  in csum_and_copy_from_iter_full()
1526 			     struct iov_iter *i)  in csum_and_copy_to_iter()  argument
1533 	if (unlikely(iov_iter_is_pipe(i)))  in csum_and_copy_to_iter()
1534 		return csum_and_copy_to_pipe_iter(addr, bytes, csum, i);  in csum_and_copy_to_iter()
1537 	if (unlikely(iov_iter_is_discard(i))) {  in csum_and_copy_to_iter()
1541 	iterate_and_advance(i, bytes, v, ({  in csum_and_copy_to_iter()
1570 		struct iov_iter *i)  in hash_and_copy_to_iter()  argument
1577 	copied = copy_to_iter(addr, bytes, i);  in hash_and_copy_to_iter()
1588 int iov_iter_npages(const struct iov_iter *i, int maxpages)  in iov_iter_npages()  argument
1590 	size_t size = i->count;  in iov_iter_npages()
1595 	if (unlikely(iov_iter_is_discard(i)))  in iov_iter_npages()
1598 	if (unlikely(iov_iter_is_pipe(i))) {  in iov_iter_npages()
1599 		struct pipe_inode_info *pipe = i->pipe;  in iov_iter_npages()
1603 		if (!sanity(i))  in iov_iter_npages()
1606 		data_start(i, &iter_head, &off);  in iov_iter_npages()
1611 	} else iterate_all_kinds(i, size, v, ({  in iov_iter_npages()
1659 	int ret = -EFAULT, i;  in copy_compat_iovec_from_user()  local
1664 	for (i = 0; i < nr_segs; i++) {  in copy_compat_iovec_from_user()
1668 		unsafe_get_user(len, &uiov[i].iov_len, uaccess_end);  in copy_compat_iovec_from_user()
1669 		unsafe_get_user(buf, &uiov[i].iov_base, uaccess_end);  in copy_compat_iovec_from_user()
1676 		iov[i].iov_base = compat_ptr(buf);  in copy_compat_iovec_from_user()
1677 		iov[i].iov_len = len;  in copy_compat_iovec_from_user()
1738 		 struct iov_iter *i, bool compat)  in __import_iovec()  argument
1775 	iov_iter_init(i, type, iov, nr_segs, total_len);  in __import_iovec()
1794  * @i: Pointer to iterator that will be initialized on success.
1807 		 struct iovec **iovp, struct iov_iter *i)  in import_iovec()  argument
1809 	return __import_iovec(type, uvec, nr_segs, fast_segs, iovp, i,  in import_iovec()
1815 		 struct iovec *iov, struct iov_iter *i)  in import_single_range()  argument
1824 	iov_iter_init(i, rw, iov, 1, len);  in import_single_range()
1829 int iov_iter_for_each_range(struct iov_iter *i, size_t bytes,  in iov_iter_for_each_range()  argument
1838 	iterate_all_kinds(i, bytes, v, -EINVAL, ({  in iov_iter_for_each_range()