Linux Audio

Check our new training course

Loading...
v5.14.15
   1// SPDX-License-Identifier: GPL-2.0-only
   2#include <crypto/hash.h>
   3#include <linux/export.h>
   4#include <linux/bvec.h>
   5#include <linux/fault-inject-usercopy.h>
   6#include <linux/uio.h>
   7#include <linux/pagemap.h>
   8#include <linux/highmem.h>
   9#include <linux/slab.h>
  10#include <linux/vmalloc.h>
  11#include <linux/splice.h>
  12#include <linux/compat.h>
  13#include <net/checksum.h>
  14#include <linux/scatterlist.h>
  15#include <linux/instrumented.h>
 
  16
  17#define PIPE_PARANOIA /* for now */
  18
  19/* covers iovec and kvec alike */
  20#define iterate_iovec(i, n, base, len, off, __p, STEP) {	\
  21	size_t off = 0;						\
  22	size_t skip = i->iov_offset;				\
  23	do {							\
  24		len = min(n, __p->iov_len - skip);		\
  25		if (likely(len)) {				\
  26			base = __p->iov_base + skip;		\
  27			len -= (STEP);				\
  28			off += len;				\
  29			skip += len;				\
  30			n -= len;				\
  31			if (skip < __p->iov_len)		\
  32				break;				\
  33		}						\
  34		__p++;						\
  35		skip = 0;					\
  36	} while (n);						\
  37	i->iov_offset = skip;					\
  38	n = off;						\
  39}
  40
  41#define iterate_bvec(i, n, base, len, off, p, STEP) {		\
  42	size_t off = 0;						\
  43	unsigned skip = i->iov_offset;				\
  44	while (n) {						\
  45		unsigned offset = p->bv_offset + skip;		\
  46		unsigned left;					\
  47		void *kaddr = kmap_local_page(p->bv_page +	\
  48					offset / PAGE_SIZE);	\
  49		base = kaddr + offset % PAGE_SIZE;		\
  50		len = min(min(n, (size_t)(p->bv_len - skip)),	\
  51		     (size_t)(PAGE_SIZE - offset % PAGE_SIZE));	\
  52		left = (STEP);					\
  53		kunmap_local(kaddr);				\
  54		len -= left;					\
  55		off += len;					\
  56		skip += len;					\
  57		if (skip == p->bv_len) {			\
  58			skip = 0;				\
  59			p++;					\
  60		}						\
  61		n -= len;					\
  62		if (left)					\
  63			break;					\
  64	}							\
  65	i->iov_offset = skip;					\
  66	n = off;						\
  67}
  68
  69#define iterate_xarray(i, n, base, len, __off, STEP) {		\
  70	__label__ __out;					\
  71	size_t __off = 0;					\
  72	struct page *head = NULL;				\
  73	loff_t start = i->xarray_start + i->iov_offset;		\
  74	unsigned offset = start % PAGE_SIZE;			\
  75	pgoff_t index = start / PAGE_SIZE;			\
  76	int j;							\
  77								\
  78	XA_STATE(xas, i->xarray, index);			\
  79								\
  80	rcu_read_lock();					\
  81	xas_for_each(&xas, head, ULONG_MAX) {			\
  82		unsigned left;					\
  83		if (xas_retry(&xas, head))			\
  84			continue;				\
  85		if (WARN_ON(xa_is_value(head)))			\
  86			break;					\
  87		if (WARN_ON(PageHuge(head)))			\
  88			break;					\
  89		for (j = (head->index < index) ? index - head->index : 0; \
  90		     j < thp_nr_pages(head); j++) {		\
  91			void *kaddr = kmap_local_page(head + j);	\
  92			base = kaddr + offset;			\
  93			len = PAGE_SIZE - offset;		\
  94			len = min(n, len);			\
  95			left = (STEP);				\
  96			kunmap_local(kaddr);			\
  97			len -= left;				\
  98			__off += len;				\
  99			n -= len;				\
 100			if (left || n == 0)			\
 101				goto __out;			\
 102			offset = 0;				\
 103		}						\
 104	}							\
 105__out:								\
 106	rcu_read_unlock();					\
 107	i->iov_offset += __off;						\
 108	n = __off;						\
 109}
 110
 111#define __iterate_and_advance(i, n, base, len, off, I, K) {	\
 112	if (unlikely(i->count < n))				\
 113		n = i->count;					\
 114	if (likely(n)) {					\
 115		if (likely(iter_is_iovec(i))) {			\
 116			const struct iovec *iov = i->iov;	\
 117			void __user *base;			\
 118			size_t len;				\
 119			iterate_iovec(i, n, base, len, off,	\
 120						iov, (I))	\
 121			i->nr_segs -= iov - i->iov;		\
 122			i->iov = iov;				\
 123		} else if (iov_iter_is_bvec(i)) {		\
 124			const struct bio_vec *bvec = i->bvec;	\
 125			void *base;				\
 126			size_t len;				\
 127			iterate_bvec(i, n, base, len, off,	\
 128						bvec, (K))	\
 129			i->nr_segs -= bvec - i->bvec;		\
 130			i->bvec = bvec;				\
 131		} else if (iov_iter_is_kvec(i)) {		\
 132			const struct kvec *kvec = i->kvec;	\
 133			void *base;				\
 134			size_t len;				\
 135			iterate_iovec(i, n, base, len, off,	\
 136						kvec, (K))	\
 137			i->nr_segs -= kvec - i->kvec;		\
 138			i->kvec = kvec;				\
 139		} else if (iov_iter_is_xarray(i)) {		\
 140			void *base;				\
 141			size_t len;				\
 142			iterate_xarray(i, n, base, len, off,	\
 143							(K))	\
 144		}						\
 145		i->count -= n;					\
 146	}							\
 147}
 148#define iterate_and_advance(i, n, base, len, off, I, K) \
 149	__iterate_and_advance(i, n, base, len, off, I, ((void)(K),0))
 150
 151static int copyout(void __user *to, const void *from, size_t n)
 152{
 153	if (should_fail_usercopy())
 154		return n;
 155	if (access_ok(to, n)) {
 156		instrument_copy_to_user(to, from, n);
 157		n = raw_copy_to_user(to, from, n);
 
 158	}
 159	return n;
 160}
 161
 162static int copyin(void *to, const void __user *from, size_t n)
 
 
 163{
 
 
 164	if (should_fail_usercopy())
 165		return n;
 166	if (access_ok(from, n)) {
 167		instrument_copy_from_user(to, from, n);
 168		n = raw_copy_from_user(to, from, n);
 169	}
 170	return n;
 171}
 172
 173static size_t copy_page_to_iter_iovec(struct page *page, size_t offset, size_t bytes,
 174			 struct iov_iter *i)
 
 175{
 176	size_t skip, copy, left, wanted;
 177	const struct iovec *iov;
 178	char __user *buf;
 179	void *kaddr, *from;
 180
 181	if (unlikely(bytes > i->count))
 182		bytes = i->count;
 183
 184	if (unlikely(!bytes))
 185		return 0;
 186
 187	might_fault();
 188	wanted = bytes;
 189	iov = i->iov;
 190	skip = i->iov_offset;
 191	buf = iov->iov_base + skip;
 192	copy = min(bytes, iov->iov_len - skip);
 193
 194	if (IS_ENABLED(CONFIG_HIGHMEM) && !fault_in_pages_writeable(buf, copy)) {
 195		kaddr = kmap_atomic(page);
 196		from = kaddr + offset;
 197
 198		/* first chunk, usually the only one */
 199		left = copyout(buf, from, copy);
 200		copy -= left;
 201		skip += copy;
 202		from += copy;
 203		bytes -= copy;
 204
 205		while (unlikely(!left && bytes)) {
 206			iov++;
 207			buf = iov->iov_base;
 208			copy = min(bytes, iov->iov_len);
 209			left = copyout(buf, from, copy);
 210			copy -= left;
 211			skip = copy;
 212			from += copy;
 213			bytes -= copy;
 214		}
 215		if (likely(!bytes)) {
 216			kunmap_atomic(kaddr);
 217			goto done;
 218		}
 219		offset = from - kaddr;
 220		buf += copy;
 221		kunmap_atomic(kaddr);
 222		copy = min(bytes, iov->iov_len - skip);
 223	}
 224	/* Too bad - revert to non-atomic kmap */
 225
 226	kaddr = kmap(page);
 227	from = kaddr + offset;
 228	left = copyout(buf, from, copy);
 229	copy -= left;
 230	skip += copy;
 231	from += copy;
 232	bytes -= copy;
 233	while (unlikely(!left && bytes)) {
 234		iov++;
 235		buf = iov->iov_base;
 236		copy = min(bytes, iov->iov_len);
 237		left = copyout(buf, from, copy);
 238		copy -= left;
 239		skip = copy;
 240		from += copy;
 241		bytes -= copy;
 242	}
 243	kunmap(page);
 244
 245done:
 246	if (skip == iov->iov_len) {
 247		iov++;
 248		skip = 0;
 249	}
 250	i->count -= wanted - bytes;
 251	i->nr_segs -= iov - i->iov;
 252	i->iov = iov;
 253	i->iov_offset = skip;
 254	return wanted - bytes;
 255}
 256
 257static size_t copy_page_from_iter_iovec(struct page *page, size_t offset, size_t bytes,
 258			 struct iov_iter *i)
 
 259{
 260	size_t skip, copy, left, wanted;
 261	const struct iovec *iov;
 262	char __user *buf;
 263	void *kaddr, *to;
 264
 265	if (unlikely(bytes > i->count))
 266		bytes = i->count;
 267
 268	if (unlikely(!bytes))
 269		return 0;
 270
 271	might_fault();
 272	wanted = bytes;
 273	iov = i->iov;
 274	skip = i->iov_offset;
 275	buf = iov->iov_base + skip;
 276	copy = min(bytes, iov->iov_len - skip);
 277
 278	if (IS_ENABLED(CONFIG_HIGHMEM) && !fault_in_pages_readable(buf, copy)) {
 279		kaddr = kmap_atomic(page);
 280		to = kaddr + offset;
 281
 282		/* first chunk, usually the only one */
 283		left = copyin(to, buf, copy);
 284		copy -= left;
 285		skip += copy;
 286		to += copy;
 287		bytes -= copy;
 288
 289		while (unlikely(!left && bytes)) {
 290			iov++;
 291			buf = iov->iov_base;
 292			copy = min(bytes, iov->iov_len);
 293			left = copyin(to, buf, copy);
 294			copy -= left;
 295			skip = copy;
 296			to += copy;
 297			bytes -= copy;
 298		}
 299		if (likely(!bytes)) {
 300			kunmap_atomic(kaddr);
 301			goto done;
 302		}
 303		offset = to - kaddr;
 304		buf += copy;
 305		kunmap_atomic(kaddr);
 306		copy = min(bytes, iov->iov_len - skip);
 307	}
 308	/* Too bad - revert to non-atomic kmap */
 309
 310	kaddr = kmap(page);
 311	to = kaddr + offset;
 312	left = copyin(to, buf, copy);
 313	copy -= left;
 314	skip += copy;
 315	to += copy;
 316	bytes -= copy;
 317	while (unlikely(!left && bytes)) {
 318		iov++;
 319		buf = iov->iov_base;
 320		copy = min(bytes, iov->iov_len);
 321		left = copyin(to, buf, copy);
 322		copy -= left;
 323		skip = copy;
 324		to += copy;
 325		bytes -= copy;
 326	}
 327	kunmap(page);
 328
 329done:
 330	if (skip == iov->iov_len) {
 331		iov++;
 332		skip = 0;
 333	}
 334	i->count -= wanted - bytes;
 335	i->nr_segs -= iov - i->iov;
 336	i->iov = iov;
 337	i->iov_offset = skip;
 338	return wanted - bytes;
 339}
 340
 341#ifdef PIPE_PARANOIA
 342static bool sanity(const struct iov_iter *i)
 343{
 344	struct pipe_inode_info *pipe = i->pipe;
 345	unsigned int p_head = pipe->head;
 346	unsigned int p_tail = pipe->tail;
 347	unsigned int p_mask = pipe->ring_size - 1;
 348	unsigned int p_occupancy = pipe_occupancy(p_head, p_tail);
 349	unsigned int i_head = i->head;
 350	unsigned int idx;
 351
 352	if (i->iov_offset) {
 353		struct pipe_buffer *p;
 354		if (unlikely(p_occupancy == 0))
 355			goto Bad;	// pipe must be non-empty
 356		if (unlikely(i_head != p_head - 1))
 357			goto Bad;	// must be at the last buffer...
 358
 359		p = &pipe->bufs[i_head & p_mask];
 360		if (unlikely(p->offset + p->len != i->iov_offset))
 361			goto Bad;	// ... at the end of segment
 362	} else {
 363		if (i_head != p_head)
 364			goto Bad;	// must be right after the last buffer
 365	}
 366	return true;
 367Bad:
 368	printk(KERN_ERR "idx = %d, offset = %zd\n", i_head, i->iov_offset);
 369	printk(KERN_ERR "head = %d, tail = %d, buffers = %d\n",
 370			p_head, p_tail, pipe->ring_size);
 371	for (idx = 0; idx < pipe->ring_size; idx++)
 372		printk(KERN_ERR "[%p %p %d %d]\n",
 373			pipe->bufs[idx].ops,
 374			pipe->bufs[idx].page,
 375			pipe->bufs[idx].offset,
 376			pipe->bufs[idx].len);
 377	WARN_ON(1);
 378	return false;
 379}
 380#else
 381#define sanity(i) true
 382#endif
 383
 384static size_t copy_page_to_iter_pipe(struct page *page, size_t offset, size_t bytes,
 385			 struct iov_iter *i)
 
 386{
 387	struct pipe_inode_info *pipe = i->pipe;
 388	struct pipe_buffer *buf;
 389	unsigned int p_tail = pipe->tail;
 390	unsigned int p_mask = pipe->ring_size - 1;
 391	unsigned int i_head = i->head;
 392	size_t off;
 393
 394	if (unlikely(bytes > i->count))
 395		bytes = i->count;
 396
 397	if (unlikely(!bytes))
 398		return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 399
 400	if (!sanity(i))
 401		return 0;
 
 
 402
 403	off = i->iov_offset;
 404	buf = &pipe->bufs[i_head & p_mask];
 405	if (off) {
 406		if (offset == off && buf->page == page) {
 407			/* merge with the last one */
 408			buf->len += bytes;
 409			i->iov_offset += bytes;
 410			goto out;
 411		}
 412		i_head++;
 413		buf = &pipe->bufs[i_head & p_mask];
 414	}
 415	if (pipe_full(i_head, p_tail, pipe->max_usage))
 416		return 0;
 417
 418	buf->ops = &page_cache_pipe_buf_ops;
 419	get_page(page);
 420	buf->page = page;
 421	buf->offset = offset;
 422	buf->len = bytes;
 423
 424	pipe->head = i_head + 1;
 425	i->iov_offset = offset + bytes;
 426	i->head = i_head;
 427out:
 428	i->count -= bytes;
 429	return bytes;
 430}
 
 431
 432/*
 433 * Fault in one or more iovecs of the given iov_iter, to a maximum length of
 434 * bytes.  For each iovec, fault in each page that constitutes the iovec.
 
 
 
 
 
 435 *
 436 * Return 0 on success, or non-zero if the memory could not be accessed (i.e.
 437 * because it is an invalid address).
 
 
 438 */
 439int iov_iter_fault_in_readable(const struct iov_iter *i, size_t bytes)
 440{
 441	if (iter_is_iovec(i)) {
 
 
 
 
 
 442		const struct iovec *p;
 443		size_t skip;
 444
 445		if (bytes > i->count)
 446			bytes = i->count;
 447		for (p = i->iov, skip = i->iov_offset; bytes; p++, skip = 0) {
 448			size_t len = min(bytes, p->iov_len - skip);
 449			int err;
 450
 451			if (unlikely(!len))
 452				continue;
 453			err = fault_in_pages_readable(p->iov_base + skip, len);
 454			if (unlikely(err))
 455				return err;
 456			bytes -= len;
 457		}
 
 458	}
 459	return 0;
 460}
 461EXPORT_SYMBOL(iov_iter_fault_in_readable);
 462
 463void iov_iter_init(struct iov_iter *i, unsigned int direction,
 464			const struct iovec *iov, unsigned long nr_segs,
 465			size_t count)
 466{
 467	WARN_ON(direction & ~(READ | WRITE));
 468	*i = (struct iov_iter) {
 469		.iter_type = ITER_IOVEC,
 
 470		.data_source = direction,
 471		.iov = iov,
 472		.nr_segs = nr_segs,
 473		.iov_offset = 0,
 474		.count = count
 475	};
 476}
 477EXPORT_SYMBOL(iov_iter_init);
 478
 479static inline bool allocated(struct pipe_buffer *buf)
 480{
 481	return buf->ops == &default_pipe_buf_ops;
 482}
 483
 484static inline void data_start(const struct iov_iter *i,
 485			      unsigned int *iter_headp, size_t *offp)
 486{
 487	unsigned int p_mask = i->pipe->ring_size - 1;
 488	unsigned int iter_head = i->head;
 489	size_t off = i->iov_offset;
 490
 491	if (off && (!allocated(&i->pipe->bufs[iter_head & p_mask]) ||
 492		    off == PAGE_SIZE)) {
 493		iter_head++;
 494		off = 0;
 495	}
 496	*iter_headp = iter_head;
 497	*offp = off;
 498}
 499
 500static size_t push_pipe(struct iov_iter *i, size_t size,
 501			int *iter_headp, size_t *offp)
 502{
 503	struct pipe_inode_info *pipe = i->pipe;
 504	unsigned int p_tail = pipe->tail;
 505	unsigned int p_mask = pipe->ring_size - 1;
 506	unsigned int iter_head;
 507	size_t off;
 508	ssize_t left;
 509
 510	if (unlikely(size > i->count))
 511		size = i->count;
 512	if (unlikely(!size))
 513		return 0;
 514
 515	left = size;
 516	data_start(i, &iter_head, &off);
 517	*iter_headp = iter_head;
 518	*offp = off;
 519	if (off) {
 520		left -= PAGE_SIZE - off;
 521		if (left <= 0) {
 522			pipe->bufs[iter_head & p_mask].len += size;
 523			return size;
 524		}
 525		pipe->bufs[iter_head & p_mask].len = PAGE_SIZE;
 526		iter_head++;
 527	}
 528	while (!pipe_full(iter_head, p_tail, pipe->max_usage)) {
 529		struct pipe_buffer *buf = &pipe->bufs[iter_head & p_mask];
 530		struct page *page = alloc_page(GFP_USER);
 531		if (!page)
 532			break;
 533
 534		buf->ops = &default_pipe_buf_ops;
 535		buf->page = page;
 536		buf->offset = 0;
 537		buf->len = min_t(ssize_t, left, PAGE_SIZE);
 538		left -= buf->len;
 539		iter_head++;
 540		pipe->head = iter_head;
 541
 542		if (left == 0)
 543			return size;
 544	}
 545	return size - left;
 546}
 547
 548static size_t copy_pipe_to_iter(const void *addr, size_t bytes,
 549				struct iov_iter *i)
 550{
 551	struct pipe_inode_info *pipe = i->pipe;
 552	unsigned int p_mask = pipe->ring_size - 1;
 553	unsigned int i_head;
 554	size_t n, off;
 555
 556	if (!sanity(i))
 557		return 0;
 558
 559	bytes = n = push_pipe(i, bytes, &i_head, &off);
 560	if (unlikely(!n))
 561		return 0;
 562	do {
 563		size_t chunk = min_t(size_t, n, PAGE_SIZE - off);
 564		memcpy_to_page(pipe->bufs[i_head & p_mask].page, off, addr, chunk);
 565		i->head = i_head;
 566		i->iov_offset = off + chunk;
 567		n -= chunk;
 568		addr += chunk;
 569		off = 0;
 570		i_head++;
 571	} while (n);
 572	i->count -= bytes;
 573	return bytes;
 574}
 575
 576static __wsum csum_and_memcpy(void *to, const void *from, size_t len,
 577			      __wsum sum, size_t off)
 578{
 579	__wsum next = csum_partial_copy_nocheck(from, to, len);
 580	return csum_block_add(sum, next, off);
 581}
 582
 583static size_t csum_and_copy_to_pipe_iter(const void *addr, size_t bytes,
 584					 struct iov_iter *i, __wsum *sump)
 585{
 586	struct pipe_inode_info *pipe = i->pipe;
 587	unsigned int p_mask = pipe->ring_size - 1;
 588	__wsum sum = *sump;
 589	size_t off = 0;
 590	unsigned int i_head;
 591	size_t r;
 592
 593	if (!sanity(i))
 594		return 0;
 595
 596	bytes = push_pipe(i, bytes, &i_head, &r);
 597	while (bytes) {
 598		size_t chunk = min_t(size_t, bytes, PAGE_SIZE - r);
 599		char *p = kmap_local_page(pipe->bufs[i_head & p_mask].page);
 600		sum = csum_and_memcpy(p + r, addr + off, chunk, sum, off);
 601		kunmap_local(p);
 602		i->head = i_head;
 603		i->iov_offset = r + chunk;
 604		bytes -= chunk;
 605		off += chunk;
 606		r = 0;
 607		i_head++;
 608	}
 609	*sump = sum;
 610	i->count -= off;
 611	return off;
 612}
 613
 614size_t _copy_to_iter(const void *addr, size_t bytes, struct iov_iter *i)
 615{
 616	if (unlikely(iov_iter_is_pipe(i)))
 617		return copy_pipe_to_iter(addr, bytes, i);
 618	if (iter_is_iovec(i))
 619		might_fault();
 620	iterate_and_advance(i, bytes, base, len, off,
 621		copyout(base, addr + off, len),
 622		memcpy(base, addr + off, len)
 623	)
 624
 625	return bytes;
 626}
 627EXPORT_SYMBOL(_copy_to_iter);
 628
 629#ifdef CONFIG_ARCH_HAS_COPY_MC
 630static int copyout_mc(void __user *to, const void *from, size_t n)
 
 
 631{
 632	if (access_ok(to, n)) {
 633		instrument_copy_to_user(to, from, n);
 634		n = copy_mc_to_user((__force void *) to, from, n);
 
 635	}
 636	return n;
 637}
 638
 639static size_t copy_mc_pipe_to_iter(const void *addr, size_t bytes,
 640				struct iov_iter *i)
 
 641{
 642	struct pipe_inode_info *pipe = i->pipe;
 643	unsigned int p_mask = pipe->ring_size - 1;
 644	unsigned int i_head;
 645	size_t n, off, xfer = 0;
 646
 647	if (!sanity(i))
 648		return 0;
 649
 650	n = push_pipe(i, bytes, &i_head, &off);
 651	while (n) {
 652		size_t chunk = min_t(size_t, n, PAGE_SIZE - off);
 653		char *p = kmap_local_page(pipe->bufs[i_head & p_mask].page);
 654		unsigned long rem;
 655		rem = copy_mc_to_kernel(p + off, addr + xfer, chunk);
 656		chunk -= rem;
 657		kunmap_local(p);
 658		i->head = i_head;
 659		i->iov_offset = off + chunk;
 660		xfer += chunk;
 661		if (rem)
 662			break;
 663		n -= chunk;
 664		off = 0;
 665		i_head++;
 666	}
 667	i->count -= xfer;
 668	return xfer;
 669}
 670
 671/**
 672 * _copy_mc_to_iter - copy to iter with source memory error exception handling
 673 * @addr: source kernel address
 674 * @bytes: total transfer length
 675 * @iter: destination iterator
 676 *
 677 * The pmem driver deploys this for the dax operation
 678 * (dax_copy_to_iter()) for dax reads (bypass page-cache and the
 679 * block-layer). Upon #MC read(2) aborts and returns EIO or the bytes
 680 * successfully copied.
 681 *
 682 * The main differences between this and typical _copy_to_iter().
 683 *
 684 * * Typical tail/residue handling after a fault retries the copy
 685 *   byte-by-byte until the fault happens again. Re-triggering machine
 686 *   checks is potentially fatal so the implementation uses source
 687 *   alignment and poison alignment assumptions to avoid re-triggering
 688 *   hardware exceptions.
 689 *
 690 * * ITER_KVEC, ITER_PIPE, and ITER_BVEC can return short copies.
 691 *   Compare to copy_to_iter() where only ITER_IOVEC attempts might return
 692 *   a short copy.
 
 693 */
 694size_t _copy_mc_to_iter(const void *addr, size_t bytes, struct iov_iter *i)
 695{
 696	if (unlikely(iov_iter_is_pipe(i)))
 697		return copy_mc_pipe_to_iter(addr, bytes, i);
 698	if (iter_is_iovec(i))
 699		might_fault();
 700	__iterate_and_advance(i, bytes, base, len, off,
 701		copyout_mc(base, addr + off, len),
 702		copy_mc_to_kernel(base, addr + off, len)
 703	)
 704
 705	return bytes;
 706}
 707EXPORT_SYMBOL_GPL(_copy_mc_to_iter);
 708#endif /* CONFIG_ARCH_HAS_COPY_MC */
 709
 
 
 
 
 
 
 
 710size_t _copy_from_iter(void *addr, size_t bytes, struct iov_iter *i)
 711{
 712	if (unlikely(iov_iter_is_pipe(i))) {
 713		WARN_ON(1);
 714		return 0;
 715	}
 716	if (iter_is_iovec(i))
 717		might_fault();
 718	iterate_and_advance(i, bytes, base, len, off,
 719		copyin(addr + off, base, len),
 720		memcpy(addr + off, base, len)
 721	)
 722
 723	return bytes;
 
 
 724}
 725EXPORT_SYMBOL(_copy_from_iter);
 726
 
 
 
 
 
 
 
 727size_t _copy_from_iter_nocache(void *addr, size_t bytes, struct iov_iter *i)
 728{
 729	if (unlikely(iov_iter_is_pipe(i))) {
 730		WARN_ON(1);
 731		return 0;
 732	}
 733	iterate_and_advance(i, bytes, base, len, off,
 734		__copy_from_user_inatomic_nocache(addr + off, base, len),
 735		memcpy(addr + off, base, len)
 736	)
 737
 738	return bytes;
 
 
 739}
 740EXPORT_SYMBOL(_copy_from_iter_nocache);
 741
 742#ifdef CONFIG_ARCH_HAS_UACCESS_FLUSHCACHE
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 743/**
 744 * _copy_from_iter_flushcache - write destination through cpu cache
 745 * @addr: destination kernel address
 746 * @bytes: total transfer length
 747 * @iter: source iterator
 748 *
 749 * The pmem driver arranges for filesystem-dax to use this facility via
 750 * dax_copy_from_iter() for ensuring that writes to persistent memory
 751 * are flushed through the CPU cache. It is differentiated from
 752 * _copy_from_iter_nocache() in that guarantees all data is flushed for
 753 * all iterator types. The _copy_from_iter_nocache() only attempts to
 754 * bypass the cache for the ITER_IOVEC case, and on some archs may use
 755 * instructions that strand dirty-data in the cache.
 
 
 756 */
 757size_t _copy_from_iter_flushcache(void *addr, size_t bytes, struct iov_iter *i)
 758{
 759	if (unlikely(iov_iter_is_pipe(i))) {
 760		WARN_ON(1);
 761		return 0;
 762	}
 763	iterate_and_advance(i, bytes, base, len, off,
 764		__copy_from_user_flushcache(addr + off, base, len),
 765		memcpy_flushcache(addr + off, base, len)
 766	)
 767
 768	return bytes;
 
 
 769}
 770EXPORT_SYMBOL_GPL(_copy_from_iter_flushcache);
 771#endif
 772
 773static inline bool page_copy_sane(struct page *page, size_t offset, size_t n)
 774{
 775	struct page *head;
 776	size_t v = n + offset;
 777
 778	/*
 779	 * The general case needs to access the page order in order
 780	 * to compute the page size.
 781	 * However, we mostly deal with order-0 pages and thus can
 782	 * avoid a possible cache line miss for requests that fit all
 783	 * page orders.
 784	 */
 785	if (n <= v && v <= PAGE_SIZE)
 786		return true;
 787
 788	head = compound_head(page);
 789	v += (page - head) << PAGE_SHIFT;
 790
 791	if (likely(n <= v && v <= (page_size(head))))
 792		return true;
 793	WARN_ON(1);
 794	return false;
 795}
 796
 797static size_t __copy_page_to_iter(struct page *page, size_t offset, size_t bytes,
 798			 struct iov_iter *i)
 799{
 800	if (likely(iter_is_iovec(i)))
 801		return copy_page_to_iter_iovec(page, offset, bytes, i);
 802	if (iov_iter_is_bvec(i) || iov_iter_is_kvec(i) || iov_iter_is_xarray(i)) {
 
 
 
 
 
 803		void *kaddr = kmap_local_page(page);
 804		size_t wanted = _copy_to_iter(kaddr + offset, bytes, i);
 
 805		kunmap_local(kaddr);
 806		return wanted;
 807	}
 808	if (iov_iter_is_pipe(i))
 809		return copy_page_to_iter_pipe(page, offset, bytes, i);
 810	if (unlikely(iov_iter_is_discard(i))) {
 811		if (unlikely(i->count < bytes))
 812			bytes = i->count;
 813		i->count -= bytes;
 814		return bytes;
 815	}
 816	WARN_ON(1);
 817	return 0;
 818}
 
 819
 820size_t copy_page_to_iter(struct page *page, size_t offset, size_t bytes,
 821			 struct iov_iter *i)
 822{
 823	size_t res = 0;
 824	if (unlikely(!page_copy_sane(page, offset, bytes)))
 
 
 
 825		return 0;
 826	page += offset / PAGE_SIZE; // first subpage
 827	offset %= PAGE_SIZE;
 828	while (1) {
 829		size_t n = __copy_page_to_iter(page, offset,
 830				min(bytes, (size_t)PAGE_SIZE - offset), i);
 
 
 
 
 
 831		res += n;
 832		bytes -= n;
 833		if (!bytes || !n)
 834			break;
 835		offset += n;
 836		if (offset == PAGE_SIZE) {
 837			page++;
 838			offset = 0;
 839		}
 840	}
 841	return res;
 842}
 843EXPORT_SYMBOL(copy_page_to_iter);
 844
 845size_t copy_page_from_iter(struct page *page, size_t offset, size_t bytes,
 846			 struct iov_iter *i)
 847{
 848	if (unlikely(!page_copy_sane(page, offset, bytes)))
 
 849		return 0;
 850	if (likely(iter_is_iovec(i)))
 851		return copy_page_from_iter_iovec(page, offset, bytes, i);
 852	if (iov_iter_is_bvec(i) || iov_iter_is_kvec(i) || iov_iter_is_xarray(i)) {
 853		void *kaddr = kmap_local_page(page);
 854		size_t wanted = _copy_from_iter(kaddr + offset, bytes, i);
 
 855		kunmap_local(kaddr);
 856		return wanted;
 
 
 
 
 
 
 
 
 857	}
 858	WARN_ON(1);
 859	return 0;
 860}
 861EXPORT_SYMBOL(copy_page_from_iter);
 862
 863static size_t pipe_zero(size_t bytes, struct iov_iter *i)
 
 
 864{
 865	struct pipe_inode_info *pipe = i->pipe;
 866	unsigned int p_mask = pipe->ring_size - 1;
 867	unsigned int i_head;
 868	size_t n, off;
 869
 870	if (!sanity(i))
 871		return 0;
 872
 873	bytes = n = push_pipe(i, bytes, &i_head, &off);
 874	if (unlikely(!n))
 875		return 0;
 876
 877	do {
 878		size_t chunk = min_t(size_t, n, PAGE_SIZE - off);
 879		char *p = kmap_local_page(pipe->bufs[i_head & p_mask].page);
 880		memset(p + off, 0, chunk);
 881		kunmap_local(p);
 882		i->head = i_head;
 883		i->iov_offset = off + chunk;
 884		n -= chunk;
 885		off = 0;
 886		i_head++;
 887	} while (n);
 888	i->count -= bytes;
 889	return bytes;
 890}
 891
 892size_t iov_iter_zero(size_t bytes, struct iov_iter *i)
 893{
 894	if (unlikely(iov_iter_is_pipe(i)))
 895		return pipe_zero(bytes, i);
 896	iterate_and_advance(i, bytes, base, len, count,
 897		clear_user(base, len),
 898		memset(base, 0, len)
 899	)
 900
 901	return bytes;
 902}
 903EXPORT_SYMBOL(iov_iter_zero);
 904
 905size_t copy_page_from_iter_atomic(struct page *page, unsigned offset, size_t bytes,
 906				  struct iov_iter *i)
 907{
 908	char *kaddr = kmap_atomic(page), *p = kaddr + offset;
 909	if (unlikely(!page_copy_sane(page, offset, bytes))) {
 910		kunmap_atomic(kaddr);
 
 
 911		return 0;
 912	}
 913	if (unlikely(iov_iter_is_pipe(i) || iov_iter_is_discard(i))) {
 914		kunmap_atomic(kaddr);
 915		WARN_ON(1);
 916		return 0;
 917	}
 918	iterate_and_advance(i, bytes, base, len, off,
 919		copyin(p + off, base, len),
 920		memcpy(p + off, base, len)
 921	)
 922	kunmap_atomic(kaddr);
 923	return bytes;
 924}
 925EXPORT_SYMBOL(copy_page_from_iter_atomic);
 926
 927static inline void pipe_truncate(struct iov_iter *i)
 928{
 929	struct pipe_inode_info *pipe = i->pipe;
 930	unsigned int p_tail = pipe->tail;
 931	unsigned int p_head = pipe->head;
 932	unsigned int p_mask = pipe->ring_size - 1;
 933
 934	if (!pipe_empty(p_head, p_tail)) {
 935		struct pipe_buffer *buf;
 936		unsigned int i_head = i->head;
 937		size_t off = i->iov_offset;
 938
 939		if (off) {
 940			buf = &pipe->bufs[i_head & p_mask];
 941			buf->len = off - buf->offset;
 942			i_head++;
 943		}
 944		while (p_head != i_head) {
 945			p_head--;
 946			pipe_buf_release(pipe, &pipe->bufs[p_head & p_mask]);
 947		}
 948
 949		pipe->head = p_head;
 950	}
 951}
 952
 953static void pipe_advance(struct iov_iter *i, size_t size)
 954{
 955	struct pipe_inode_info *pipe = i->pipe;
 956	if (size) {
 957		struct pipe_buffer *buf;
 958		unsigned int p_mask = pipe->ring_size - 1;
 959		unsigned int i_head = i->head;
 960		size_t off = i->iov_offset, left = size;
 961
 962		if (off) /* make it relative to the beginning of buffer */
 963			left += off - pipe->bufs[i_head & p_mask].offset;
 964		while (1) {
 965			buf = &pipe->bufs[i_head & p_mask];
 966			if (left <= buf->len)
 967				break;
 968			left -= buf->len;
 969			i_head++;
 970		}
 971		i->head = i_head;
 972		i->iov_offset = buf->offset + left;
 973	}
 974	i->count -= size;
 975	/* ... and discard everything past that point */
 976	pipe_truncate(i);
 977}
 
 978
 979static void iov_iter_bvec_advance(struct iov_iter *i, size_t size)
 980{
 981	struct bvec_iter bi;
 982
 983	bi.bi_size = i->count;
 984	bi.bi_bvec_done = i->iov_offset;
 985	bi.bi_idx = 0;
 986	bvec_iter_advance(i->bvec, &bi, size);
 987
 988	i->bvec += bi.bi_idx;
 989	i->nr_segs -= bi.bi_idx;
 990	i->count = bi.bi_size;
 991	i->iov_offset = bi.bi_bvec_done;
 
 
 
 
 
 
 992}
 993
 994static void iov_iter_iovec_advance(struct iov_iter *i, size_t size)
 995{
 996	const struct iovec *iov, *end;
 997
 998	if (!i->count)
 999		return;
1000	i->count -= size;
1001
1002	size += i->iov_offset; // from beginning of current segment
1003	for (iov = i->iov, end = iov + i->nr_segs; iov < end; iov++) {
1004		if (likely(size < iov->iov_len))
1005			break;
1006		size -= iov->iov_len;
1007	}
1008	i->iov_offset = size;
1009	i->nr_segs -= iov - i->iov;
1010	i->iov = iov;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1011}
1012
1013void iov_iter_advance(struct iov_iter *i, size_t size)
1014{
1015	if (unlikely(i->count < size))
1016		size = i->count;
1017	if (likely(iter_is_iovec(i) || iov_iter_is_kvec(i))) {
 
 
 
1018		/* iovec and kvec have identical layouts */
1019		iov_iter_iovec_advance(i, size);
1020	} else if (iov_iter_is_bvec(i)) {
1021		iov_iter_bvec_advance(i, size);
1022	} else if (iov_iter_is_pipe(i)) {
1023		pipe_advance(i, size);
1024	} else if (unlikely(iov_iter_is_xarray(i))) {
1025		i->iov_offset += size;
1026		i->count -= size;
1027	} else if (iov_iter_is_discard(i)) {
1028		i->count -= size;
1029	}
1030}
1031EXPORT_SYMBOL(iov_iter_advance);
1032
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1033void iov_iter_revert(struct iov_iter *i, size_t unroll)
1034{
1035	if (!unroll)
1036		return;
1037	if (WARN_ON(unroll > MAX_RW_COUNT))
1038		return;
1039	i->count += unroll;
1040	if (unlikely(iov_iter_is_pipe(i))) {
1041		struct pipe_inode_info *pipe = i->pipe;
1042		unsigned int p_mask = pipe->ring_size - 1;
1043		unsigned int i_head = i->head;
1044		size_t off = i->iov_offset;
1045		while (1) {
1046			struct pipe_buffer *b = &pipe->bufs[i_head & p_mask];
1047			size_t n = off - b->offset;
1048			if (unroll < n) {
1049				off -= unroll;
1050				break;
1051			}
1052			unroll -= n;
1053			if (!unroll && i_head == i->start_head) {
1054				off = 0;
1055				break;
1056			}
1057			i_head--;
1058			b = &pipe->bufs[i_head & p_mask];
1059			off = b->offset + b->len;
1060		}
1061		i->iov_offset = off;
1062		i->head = i_head;
1063		pipe_truncate(i);
1064		return;
1065	}
1066	if (unlikely(iov_iter_is_discard(i)))
1067		return;
1068	if (unroll <= i->iov_offset) {
1069		i->iov_offset -= unroll;
1070		return;
1071	}
1072	unroll -= i->iov_offset;
1073	if (iov_iter_is_xarray(i)) {
1074		BUG(); /* We should never go beyond the start of the specified
1075			* range since we might then be straying into pages that
1076			* aren't pinned.
1077			*/
1078	} else if (iov_iter_is_bvec(i)) {
1079		const struct bio_vec *bvec = i->bvec;
1080		while (1) {
1081			size_t n = (--bvec)->bv_len;
1082			i->nr_segs++;
1083			if (unroll <= n) {
1084				i->bvec = bvec;
1085				i->iov_offset = n - unroll;
1086				return;
1087			}
1088			unroll -= n;
1089		}
 
 
 
1090	} else { /* same logics for iovec and kvec */
1091		const struct iovec *iov = i->iov;
1092		while (1) {
1093			size_t n = (--iov)->iov_len;
1094			i->nr_segs++;
1095			if (unroll <= n) {
1096				i->iov = iov;
1097				i->iov_offset = n - unroll;
1098				return;
1099			}
1100			unroll -= n;
1101		}
1102	}
1103}
1104EXPORT_SYMBOL(iov_iter_revert);
1105
1106/*
1107 * Return the count of just the current iov_iter segment.
1108 */
1109size_t iov_iter_single_seg_count(const struct iov_iter *i)
1110{
1111	if (i->nr_segs > 1) {
1112		if (likely(iter_is_iovec(i) || iov_iter_is_kvec(i)))
1113			return min(i->count, i->iov->iov_len - i->iov_offset);
1114		if (iov_iter_is_bvec(i))
1115			return min(i->count, i->bvec->bv_len - i->iov_offset);
1116	}
 
 
 
1117	return i->count;
1118}
1119EXPORT_SYMBOL(iov_iter_single_seg_count);
1120
1121void iov_iter_kvec(struct iov_iter *i, unsigned int direction,
1122			const struct kvec *kvec, unsigned long nr_segs,
1123			size_t count)
1124{
1125	WARN_ON(direction & ~(READ | WRITE));
1126	*i = (struct iov_iter){
1127		.iter_type = ITER_KVEC,
1128		.data_source = direction,
1129		.kvec = kvec,
1130		.nr_segs = nr_segs,
1131		.iov_offset = 0,
1132		.count = count
1133	};
1134}
1135EXPORT_SYMBOL(iov_iter_kvec);
1136
1137void iov_iter_bvec(struct iov_iter *i, unsigned int direction,
1138			const struct bio_vec *bvec, unsigned long nr_segs,
1139			size_t count)
1140{
1141	WARN_ON(direction & ~(READ | WRITE));
1142	*i = (struct iov_iter){
1143		.iter_type = ITER_BVEC,
1144		.data_source = direction,
1145		.bvec = bvec,
1146		.nr_segs = nr_segs,
1147		.iov_offset = 0,
1148		.count = count
1149	};
1150}
1151EXPORT_SYMBOL(iov_iter_bvec);
1152
1153void iov_iter_pipe(struct iov_iter *i, unsigned int direction,
1154			struct pipe_inode_info *pipe,
1155			size_t count)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1156{
1157	BUG_ON(direction != READ);
1158	WARN_ON(pipe_full(pipe->head, pipe->tail, pipe->ring_size));
1159	*i = (struct iov_iter){
1160		.iter_type = ITER_PIPE,
1161		.data_source = false,
1162		.pipe = pipe,
1163		.head = pipe->head,
1164		.start_head = pipe->head,
1165		.iov_offset = 0,
1166		.count = count
1167	};
1168}
1169EXPORT_SYMBOL(iov_iter_pipe);
1170
1171/**
1172 * iov_iter_xarray - Initialise an I/O iterator to use the pages in an xarray
1173 * @i: The iterator to initialise.
1174 * @direction: The direction of the transfer.
1175 * @xarray: The xarray to access.
1176 * @start: The start file position.
1177 * @count: The size of the I/O buffer in bytes.
1178 *
1179 * Set up an I/O iterator to either draw data out of the pages attached to an
1180 * inode or to inject data into those pages.  The pages *must* be prevented
1181 * from evaporation, either by taking a ref on them or locking them by the
1182 * caller.
1183 */
1184void iov_iter_xarray(struct iov_iter *i, unsigned int direction,
1185		     struct xarray *xarray, loff_t start, size_t count)
1186{
1187	BUG_ON(direction & ~1);
1188	*i = (struct iov_iter) {
1189		.iter_type = ITER_XARRAY,
1190		.data_source = direction,
1191		.xarray = xarray,
1192		.xarray_start = start,
1193		.count = count,
1194		.iov_offset = 0
1195	};
1196}
1197EXPORT_SYMBOL(iov_iter_xarray);
1198
1199/**
1200 * iov_iter_discard - Initialise an I/O iterator that discards data
1201 * @i: The iterator to initialise.
1202 * @direction: The direction of the transfer.
1203 * @count: The size of the I/O buffer in bytes.
1204 *
1205 * Set up an I/O iterator that just discards everything that's written to it.
1206 * It's only available as a READ iterator.
1207 */
1208void iov_iter_discard(struct iov_iter *i, unsigned int direction, size_t count)
1209{
1210	BUG_ON(direction != READ);
1211	*i = (struct iov_iter){
1212		.iter_type = ITER_DISCARD,
1213		.data_source = false,
1214		.count = count,
1215		.iov_offset = 0
1216	};
1217}
1218EXPORT_SYMBOL(iov_iter_discard);
1219
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1220static unsigned long iov_iter_alignment_iovec(const struct iov_iter *i)
1221{
 
1222	unsigned long res = 0;
1223	size_t size = i->count;
1224	size_t skip = i->iov_offset;
1225	unsigned k;
1226
1227	for (k = 0; k < i->nr_segs; k++, skip = 0) {
1228		size_t len = i->iov[k].iov_len - skip;
1229		if (len) {
1230			res |= (unsigned long)i->iov[k].iov_base + skip;
1231			if (len > size)
1232				len = size;
1233			res |= len;
1234			size -= len;
1235			if (!size)
1236				break;
1237		}
1238	}
 
 
1239	return res;
1240}
1241
1242static unsigned long iov_iter_alignment_bvec(const struct iov_iter *i)
1243{
 
1244	unsigned res = 0;
1245	size_t size = i->count;
1246	unsigned skip = i->iov_offset;
1247	unsigned k;
1248
1249	for (k = 0; k < i->nr_segs; k++, skip = 0) {
1250		size_t len = i->bvec[k].bv_len - skip;
1251		res |= (unsigned long)i->bvec[k].bv_offset + skip;
1252		if (len > size)
1253			len = size;
1254		res |= len;
 
1255		size -= len;
1256		if (!size)
1257			break;
1258	}
1259	return res;
1260}
1261
1262unsigned long iov_iter_alignment(const struct iov_iter *i)
1263{
 
 
 
 
 
 
 
1264	/* iovec and kvec have identical layouts */
1265	if (likely(iter_is_iovec(i) || iov_iter_is_kvec(i)))
1266		return iov_iter_alignment_iovec(i);
1267
1268	if (iov_iter_is_bvec(i))
1269		return iov_iter_alignment_bvec(i);
1270
1271	if (iov_iter_is_pipe(i)) {
1272		unsigned int p_mask = i->pipe->ring_size - 1;
1273		size_t size = i->count;
1274
1275		if (size && i->iov_offset && allocated(&i->pipe->bufs[i->head & p_mask]))
1276			return size | i->iov_offset;
1277		return size;
1278	}
1279
1280	if (iov_iter_is_xarray(i))
1281		return (i->xarray_start + i->iov_offset) | i->count;
1282
1283	return 0;
1284}
1285EXPORT_SYMBOL(iov_iter_alignment);
1286
1287unsigned long iov_iter_gap_alignment(const struct iov_iter *i)
1288{
1289	unsigned long res = 0;
1290	unsigned long v = 0;
1291	size_t size = i->count;
1292	unsigned k;
1293
 
 
 
1294	if (WARN_ON(!iter_is_iovec(i)))
1295		return ~0U;
1296
1297	for (k = 0; k < i->nr_segs; k++) {
1298		if (i->iov[k].iov_len) {
1299			unsigned long base = (unsigned long)i->iov[k].iov_base;
 
1300			if (v) // if not the first one
1301				res |= base | v; // this start | previous end
1302			v = base + i->iov[k].iov_len;
1303			if (size <= i->iov[k].iov_len)
1304				break;
1305			size -= i->iov[k].iov_len;
1306		}
1307	}
1308	return res;
1309}
1310EXPORT_SYMBOL(iov_iter_gap_alignment);
1311
1312static inline ssize_t __pipe_get_pages(struct iov_iter *i,
1313				size_t maxsize,
1314				struct page **pages,
1315				int iter_head,
1316				size_t *start)
1317{
1318	struct pipe_inode_info *pipe = i->pipe;
1319	unsigned int p_mask = pipe->ring_size - 1;
1320	ssize_t n = push_pipe(i, maxsize, &iter_head, start);
1321	if (!n)
1322		return -EFAULT;
1323
1324	maxsize = n;
1325	n += *start;
1326	while (n > 0) {
1327		get_page(*pages++ = pipe->bufs[iter_head & p_mask].page);
1328		iter_head++;
1329		n -= PAGE_SIZE;
 
1330	}
1331
1332	return maxsize;
1333}
1334
1335static ssize_t pipe_get_pages(struct iov_iter *i,
1336		   struct page **pages, size_t maxsize, unsigned maxpages,
1337		   size_t *start)
1338{
1339	unsigned int iter_head, npages;
1340	size_t capacity;
 
 
 
 
 
 
 
 
 
1341
1342	if (!sanity(i))
1343		return -EFAULT;
 
 
 
1344
1345	data_start(i, &iter_head, start);
1346	/* Amount of free space: some of this one + all after this one */
1347	npages = pipe_space_for_user(iter_head, i->pipe->tail, i->pipe);
1348	capacity = min(npages, maxpages) * PAGE_SIZE - *start;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1349
1350	return __pipe_get_pages(i, min(maxsize, capacity), pages, iter_head, start);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1351}
1352
1353static ssize_t iter_xarray_populate_pages(struct page **pages, struct xarray *xa,
1354					  pgoff_t index, unsigned int nr_pages)
1355{
1356	XA_STATE(xas, xa, index);
1357	struct page *page;
1358	unsigned int ret = 0;
1359
1360	rcu_read_lock();
1361	for (page = xas_load(&xas); page; page = xas_next(&xas)) {
1362		if (xas_retry(&xas, page))
1363			continue;
1364
1365		/* Has the page moved or been split? */
1366		if (unlikely(page != xas_reload(&xas))) {
1367			xas_reset(&xas);
1368			continue;
1369		}
1370
1371		pages[ret] = find_subpage(page, xas.xa_index);
1372		get_page(pages[ret]);
1373		if (++ret == nr_pages)
1374			break;
1375	}
1376	rcu_read_unlock();
1377	return ret;
1378}
1379
1380static ssize_t iter_xarray_get_pages(struct iov_iter *i,
1381				     struct page **pages, size_t maxsize,
1382				     unsigned maxpages, size_t *_start_offset)
1383{
1384	unsigned nr, offset;
1385	pgoff_t index, count;
1386	size_t size = maxsize, actual;
1387	loff_t pos;
1388
1389	if (!size || !maxpages)
1390		return 0;
1391
1392	pos = i->xarray_start + i->iov_offset;
1393	index = pos >> PAGE_SHIFT;
1394	offset = pos & ~PAGE_MASK;
1395	*_start_offset = offset;
1396
1397	count = 1;
1398	if (size > PAGE_SIZE - offset) {
1399		size -= PAGE_SIZE - offset;
1400		count += size >> PAGE_SHIFT;
1401		size &= ~PAGE_MASK;
1402		if (size)
1403			count++;
1404	}
1405
1406	if (count > maxpages)
1407		count = maxpages;
1408
1409	nr = iter_xarray_populate_pages(pages, i->xarray, index, count);
1410	if (nr == 0)
1411		return 0;
1412
1413	actual = PAGE_SIZE * nr;
1414	actual -= offset;
1415	if (nr == count && size > 0) {
1416		unsigned last_offset = (nr > 1) ? 0 : offset;
1417		actual -= PAGE_SIZE - (last_offset + size);
1418	}
1419	return actual;
1420}
1421
1422/* must be done on non-empty ITER_IOVEC one */
1423static unsigned long first_iovec_segment(const struct iov_iter *i,
1424					 size_t *size, size_t *start,
1425					 size_t maxsize, unsigned maxpages)
1426{
1427	size_t skip;
1428	long k;
1429
 
 
 
1430	for (k = 0, skip = i->iov_offset; k < i->nr_segs; k++, skip = 0) {
1431		unsigned long addr = (unsigned long)i->iov[k].iov_base + skip;
1432		size_t len = i->iov[k].iov_len - skip;
1433
1434		if (unlikely(!len))
1435			continue;
1436		if (len > maxsize)
1437			len = maxsize;
1438		len += (*start = addr % PAGE_SIZE);
1439		if (len > maxpages * PAGE_SIZE)
1440			len = maxpages * PAGE_SIZE;
1441		*size = len;
1442		return addr & PAGE_MASK;
1443	}
1444	BUG(); // if it had been empty, we wouldn't get called
1445}
1446
1447/* must be done on non-empty ITER_BVEC one */
1448static struct page *first_bvec_segment(const struct iov_iter *i,
1449				       size_t *size, size_t *start,
1450				       size_t maxsize, unsigned maxpages)
1451{
1452	struct page *page;
1453	size_t skip = i->iov_offset, len;
1454
1455	len = i->bvec->bv_len - skip;
1456	if (len > maxsize)
1457		len = maxsize;
1458	skip += i->bvec->bv_offset;
1459	page = i->bvec->bv_page + skip / PAGE_SIZE;
1460	len += (*start = skip % PAGE_SIZE);
1461	if (len > maxpages * PAGE_SIZE)
1462		len = maxpages * PAGE_SIZE;
1463	*size = len;
1464	return page;
1465}
1466
1467ssize_t iov_iter_get_pages(struct iov_iter *i,
1468		   struct page **pages, size_t maxsize, unsigned maxpages,
1469		   size_t *start)
1470{
1471	size_t len;
1472	int n, res;
1473
1474	if (maxsize > i->count)
1475		maxsize = i->count;
1476	if (!maxsize)
1477		return 0;
 
 
1478
1479	if (likely(iter_is_iovec(i))) {
1480		unsigned long addr;
 
1481
1482		addr = first_iovec_segment(i, &len, start, maxsize, maxpages);
1483		n = DIV_ROUND_UP(len, PAGE_SIZE);
1484		res = get_user_pages_fast(addr, n,
1485				iov_iter_rw(i) != WRITE ?  FOLL_WRITE : 0,
1486				pages);
1487		if (unlikely(res < 0))
 
 
 
 
 
 
 
1488			return res;
1489		return (res == n ? len : res * PAGE_SIZE) - *start;
 
 
1490	}
1491	if (iov_iter_is_bvec(i)) {
 
1492		struct page *page;
1493
1494		page = first_bvec_segment(i, &len, start, maxsize, maxpages);
1495		n = DIV_ROUND_UP(len, PAGE_SIZE);
1496		while (n--)
1497			get_page(*pages++ = page++);
1498		return len - *start;
 
 
 
 
 
 
 
 
 
 
 
1499	}
1500	if (iov_iter_is_pipe(i))
1501		return pipe_get_pages(i, pages, maxsize, maxpages, start);
1502	if (iov_iter_is_xarray(i))
1503		return iter_xarray_get_pages(i, pages, maxsize, maxpages, start);
1504	return -EFAULT;
1505}
1506EXPORT_SYMBOL(iov_iter_get_pages);
1507
1508static struct page **get_pages_array(size_t n)
1509{
1510	return kvmalloc_array(n, sizeof(struct page *), GFP_KERNEL);
1511}
1512
1513static ssize_t pipe_get_pages_alloc(struct iov_iter *i,
1514		   struct page ***pages, size_t maxsize,
1515		   size_t *start)
1516{
1517	struct page **p;
1518	unsigned int iter_head, npages;
1519	ssize_t n;
1520
1521	if (!sanity(i))
1522		return -EFAULT;
1523
1524	data_start(i, &iter_head, start);
1525	/* Amount of free space: some of this one + all after this one */
1526	npages = pipe_space_for_user(iter_head, i->pipe->tail, i->pipe);
1527	n = npages * PAGE_SIZE - *start;
1528	if (maxsize > n)
1529		maxsize = n;
1530	else
1531		npages = DIV_ROUND_UP(maxsize + *start, PAGE_SIZE);
1532	p = get_pages_array(npages);
1533	if (!p)
1534		return -ENOMEM;
1535	n = __pipe_get_pages(i, maxsize, p, iter_head, start);
1536	if (n > 0)
1537		*pages = p;
1538	else
1539		kvfree(p);
1540	return n;
1541}
1542
1543static ssize_t iter_xarray_get_pages_alloc(struct iov_iter *i,
1544					   struct page ***pages, size_t maxsize,
1545					   size_t *_start_offset)
1546{
1547	struct page **p;
1548	unsigned nr, offset;
1549	pgoff_t index, count;
1550	size_t size = maxsize, actual;
1551	loff_t pos;
1552
1553	if (!size)
1554		return 0;
1555
1556	pos = i->xarray_start + i->iov_offset;
1557	index = pos >> PAGE_SHIFT;
1558	offset = pos & ~PAGE_MASK;
1559	*_start_offset = offset;
1560
1561	count = 1;
1562	if (size > PAGE_SIZE - offset) {
1563		size -= PAGE_SIZE - offset;
1564		count += size >> PAGE_SHIFT;
1565		size &= ~PAGE_MASK;
1566		if (size)
1567			count++;
1568	}
1569
1570	p = get_pages_array(count);
1571	if (!p)
1572		return -ENOMEM;
1573	*pages = p;
1574
1575	nr = iter_xarray_populate_pages(p, i->xarray, index, count);
1576	if (nr == 0)
1577		return 0;
 
1578
1579	actual = PAGE_SIZE * nr;
1580	actual -= offset;
1581	if (nr == count && size > 0) {
1582		unsigned last_offset = (nr > 1) ? 0 : offset;
1583		actual -= PAGE_SIZE - (last_offset + size);
1584	}
1585	return actual;
1586}
 
1587
1588ssize_t iov_iter_get_pages_alloc(struct iov_iter *i,
1589		   struct page ***pages, size_t maxsize,
1590		   size_t *start)
1591{
1592	struct page **p;
1593	size_t len;
1594	int n, res;
1595
1596	if (maxsize > i->count)
1597		maxsize = i->count;
1598	if (!maxsize)
1599		return 0;
1600
1601	if (likely(iter_is_iovec(i))) {
1602		unsigned long addr;
1603
1604		addr = first_iovec_segment(i, &len, start, maxsize, ~0U);
1605		n = DIV_ROUND_UP(len, PAGE_SIZE);
1606		p = get_pages_array(n);
1607		if (!p)
1608			return -ENOMEM;
1609		res = get_user_pages_fast(addr, n,
1610				iov_iter_rw(i) != WRITE ?  FOLL_WRITE : 0, p);
1611		if (unlikely(res < 0)) {
1612			kvfree(p);
1613			return res;
1614		}
1615		*pages = p;
1616		return (res == n ? len : res * PAGE_SIZE) - *start;
1617	}
1618	if (iov_iter_is_bvec(i)) {
1619		struct page *page;
1620
1621		page = first_bvec_segment(i, &len, start, maxsize, ~0U);
1622		n = DIV_ROUND_UP(len, PAGE_SIZE);
1623		*pages = p = get_pages_array(n);
1624		if (!p)
1625			return -ENOMEM;
1626		while (n--)
1627			get_page(*p++ = page++);
1628		return len - *start;
1629	}
1630	if (iov_iter_is_pipe(i))
1631		return pipe_get_pages_alloc(i, pages, maxsize, start);
1632	if (iov_iter_is_xarray(i))
1633		return iter_xarray_get_pages_alloc(i, pages, maxsize, start);
1634	return -EFAULT;
1635}
1636EXPORT_SYMBOL(iov_iter_get_pages_alloc);
1637
1638size_t csum_and_copy_from_iter(void *addr, size_t bytes, __wsum *csum,
1639			       struct iov_iter *i)
1640{
1641	__wsum sum, next;
1642	sum = *csum;
1643	if (unlikely(iov_iter_is_pipe(i) || iov_iter_is_discard(i))) {
1644		WARN_ON(1);
1645		return 0;
1646	}
1647	iterate_and_advance(i, bytes, base, len, off, ({
1648		next = csum_and_copy_from_user(base, addr + off, len);
1649		sum = csum_block_add(sum, next, off);
1650		next ? 0 : len;
1651	}), ({
1652		sum = csum_and_memcpy(addr + off, base, len, sum, off);
1653	})
1654	)
1655	*csum = sum;
1656	return bytes;
1657}
1658EXPORT_SYMBOL(csum_and_copy_from_iter);
1659
1660size_t csum_and_copy_to_iter(const void *addr, size_t bytes, void *_csstate,
1661			     struct iov_iter *i)
1662{
1663	struct csum_state *csstate = _csstate;
1664	__wsum sum, next;
1665
1666	if (unlikely(iov_iter_is_discard(i))) {
1667		WARN_ON(1);	/* for now */
1668		return 0;
1669	}
1670
1671	sum = csum_shift(csstate->csum, csstate->off);
1672	if (unlikely(iov_iter_is_pipe(i)))
1673		bytes = csum_and_copy_to_pipe_iter(addr, bytes, i, &sum);
1674	else iterate_and_advance(i, bytes, base, len, off, ({
1675		next = csum_and_copy_to_user(addr + off, base, len);
1676		sum = csum_block_add(sum, next, off);
1677		next ? 0 : len;
1678	}), ({
1679		sum = csum_and_memcpy(base, addr + off, len, sum, off);
1680	})
1681	)
1682	csstate->csum = csum_shift(sum, csstate->off);
1683	csstate->off += bytes;
1684	return bytes;
1685}
1686EXPORT_SYMBOL(csum_and_copy_to_iter);
1687
1688size_t hash_and_copy_to_iter(const void *addr, size_t bytes, void *hashp,
1689		struct iov_iter *i)
1690{
1691#ifdef CONFIG_CRYPTO_HASH
1692	struct ahash_request *hash = hashp;
1693	struct scatterlist sg;
1694	size_t copied;
1695
1696	copied = copy_to_iter(addr, bytes, i);
1697	sg_init_one(&sg, addr, copied);
1698	ahash_request_set_crypt(hash, &sg, NULL, copied);
1699	crypto_ahash_update(hash);
1700	return copied;
1701#else
1702	return 0;
1703#endif
1704}
1705EXPORT_SYMBOL(hash_and_copy_to_iter);
1706
1707static int iov_npages(const struct iov_iter *i, int maxpages)
1708{
1709	size_t skip = i->iov_offset, size = i->count;
1710	const struct iovec *p;
1711	int npages = 0;
1712
1713	for (p = i->iov; size; skip = 0, p++) {
1714		unsigned offs = offset_in_page(p->iov_base + skip);
1715		size_t len = min(p->iov_len - skip, size);
1716
1717		if (len) {
1718			size -= len;
1719			npages += DIV_ROUND_UP(offs + len, PAGE_SIZE);
1720			if (unlikely(npages > maxpages))
1721				return maxpages;
1722		}
1723	}
1724	return npages;
1725}
1726
1727static int bvec_npages(const struct iov_iter *i, int maxpages)
1728{
1729	size_t skip = i->iov_offset, size = i->count;
1730	const struct bio_vec *p;
1731	int npages = 0;
1732
1733	for (p = i->bvec; size; skip = 0, p++) {
1734		unsigned offs = (p->bv_offset + skip) % PAGE_SIZE;
1735		size_t len = min(p->bv_len - skip, size);
1736
1737		size -= len;
1738		npages += DIV_ROUND_UP(offs + len, PAGE_SIZE);
1739		if (unlikely(npages > maxpages))
1740			return maxpages;
1741	}
1742	return npages;
1743}
1744
1745int iov_iter_npages(const struct iov_iter *i, int maxpages)
1746{
1747	if (unlikely(!i->count))
1748		return 0;
 
 
 
 
 
1749	/* iovec and kvec have identical layouts */
1750	if (likely(iter_is_iovec(i) || iov_iter_is_kvec(i)))
1751		return iov_npages(i, maxpages);
1752	if (iov_iter_is_bvec(i))
1753		return bvec_npages(i, maxpages);
1754	if (iov_iter_is_pipe(i)) {
1755		unsigned int iter_head;
1756		int npages;
1757		size_t off;
1758
1759		if (!sanity(i))
1760			return 0;
1761
1762		data_start(i, &iter_head, &off);
1763		/* some of this one + all after this one */
1764		npages = pipe_space_for_user(iter_head, i->pipe->tail, i->pipe);
1765		return min(npages, maxpages);
1766	}
1767	if (iov_iter_is_xarray(i)) {
1768		unsigned offset = (i->xarray_start + i->iov_offset) % PAGE_SIZE;
1769		int npages = DIV_ROUND_UP(offset + i->count, PAGE_SIZE);
1770		return min(npages, maxpages);
1771	}
1772	return 0;
1773}
1774EXPORT_SYMBOL(iov_iter_npages);
1775
1776const void *dup_iter(struct iov_iter *new, struct iov_iter *old, gfp_t flags)
1777{
1778	*new = *old;
1779	if (unlikely(iov_iter_is_pipe(new))) {
1780		WARN_ON(1);
1781		return NULL;
1782	}
1783	if (unlikely(iov_iter_is_discard(new) || iov_iter_is_xarray(new)))
1784		return NULL;
1785	if (iov_iter_is_bvec(new))
1786		return new->bvec = kmemdup(new->bvec,
1787				    new->nr_segs * sizeof(struct bio_vec),
1788				    flags);
1789	else
1790		/* iovec and kvec have identical layout */
1791		return new->iov = kmemdup(new->iov,
1792				   new->nr_segs * sizeof(struct iovec),
1793				   flags);
 
1794}
1795EXPORT_SYMBOL(dup_iter);
1796
1797static int copy_compat_iovec_from_user(struct iovec *iov,
1798		const struct iovec __user *uvec, unsigned long nr_segs)
1799{
1800	const struct compat_iovec __user *uiov =
1801		(const struct compat_iovec __user *)uvec;
1802	int ret = -EFAULT, i;
 
1803
1804	if (!user_access_begin(uiov, nr_segs * sizeof(*uiov)))
1805		return -EFAULT;
1806
1807	for (i = 0; i < nr_segs; i++) {
1808		compat_uptr_t buf;
1809		compat_ssize_t len;
1810
1811		unsafe_get_user(len, &uiov[i].iov_len, uaccess_end);
1812		unsafe_get_user(buf, &uiov[i].iov_base, uaccess_end);
1813
1814		/* check for compat_size_t not fitting in compat_ssize_t .. */
1815		if (len < 0) {
1816			ret = -EINVAL;
1817			goto uaccess_end;
1818		}
1819		iov[i].iov_base = compat_ptr(buf);
1820		iov[i].iov_len = len;
1821	}
1822
1823	ret = 0;
1824uaccess_end:
1825	user_access_end();
1826	return ret;
1827}
1828
1829static int copy_iovec_from_user(struct iovec *iov,
1830		const struct iovec __user *uvec, unsigned long nr_segs)
1831{
1832	unsigned long seg;
1833
1834	if (copy_from_user(iov, uvec, nr_segs * sizeof(*uvec)))
1835		return -EFAULT;
1836	for (seg = 0; seg < nr_segs; seg++) {
1837		if ((ssize_t)iov[seg].iov_len < 0)
1838			return -EINVAL;
1839	}
1840
1841	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1842}
1843
1844struct iovec *iovec_from_user(const struct iovec __user *uvec,
1845		unsigned long nr_segs, unsigned long fast_segs,
1846		struct iovec *fast_iov, bool compat)
1847{
1848	struct iovec *iov = fast_iov;
1849	int ret;
1850
1851	/*
1852	 * SuS says "The readv() function *may* fail if the iovcnt argument was
1853	 * less than or equal to 0, or greater than {IOV_MAX}.  Linux has
1854	 * traditionally returned zero for zero segments, so...
1855	 */
1856	if (nr_segs == 0)
1857		return iov;
1858	if (nr_segs > UIO_MAXIOV)
1859		return ERR_PTR(-EINVAL);
1860	if (nr_segs > fast_segs) {
1861		iov = kmalloc_array(nr_segs, sizeof(struct iovec), GFP_KERNEL);
1862		if (!iov)
1863			return ERR_PTR(-ENOMEM);
1864	}
1865
1866	if (compat)
1867		ret = copy_compat_iovec_from_user(iov, uvec, nr_segs);
1868	else
1869		ret = copy_iovec_from_user(iov, uvec, nr_segs);
1870	if (ret) {
1871		if (iov != fast_iov)
1872			kfree(iov);
1873		return ERR_PTR(ret);
1874	}
1875
1876	return iov;
1877}
1878
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1879ssize_t __import_iovec(int type, const struct iovec __user *uvec,
1880		 unsigned nr_segs, unsigned fast_segs, struct iovec **iovp,
1881		 struct iov_iter *i, bool compat)
1882{
1883	ssize_t total_len = 0;
1884	unsigned long seg;
1885	struct iovec *iov;
1886
 
 
 
1887	iov = iovec_from_user(uvec, nr_segs, fast_segs, *iovp, compat);
1888	if (IS_ERR(iov)) {
1889		*iovp = NULL;
1890		return PTR_ERR(iov);
1891	}
1892
1893	/*
1894	 * According to the Single Unix Specification we should return EINVAL if
1895	 * an element length is < 0 when cast to ssize_t or if the total length
1896	 * would overflow the ssize_t return value of the system call.
1897	 *
1898	 * Linux caps all read/write calls to MAX_RW_COUNT, and avoids the
1899	 * overflow case.
1900	 */
1901	for (seg = 0; seg < nr_segs; seg++) {
1902		ssize_t len = (ssize_t)iov[seg].iov_len;
1903
1904		if (!access_ok(iov[seg].iov_base, len)) {
1905			if (iov != *iovp)
1906				kfree(iov);
1907			*iovp = NULL;
1908			return -EFAULT;
1909		}
1910
1911		if (len > MAX_RW_COUNT - total_len) {
1912			len = MAX_RW_COUNT - total_len;
1913			iov[seg].iov_len = len;
1914		}
1915		total_len += len;
1916	}
1917
1918	iov_iter_init(i, type, iov, nr_segs, total_len);
1919	if (iov == *iovp)
1920		*iovp = NULL;
1921	else
1922		*iovp = iov;
1923	return total_len;
1924}
1925
1926/**
1927 * import_iovec() - Copy an array of &struct iovec from userspace
1928 *     into the kernel, check that it is valid, and initialize a new
1929 *     &struct iov_iter iterator to access it.
1930 *
1931 * @type: One of %READ or %WRITE.
1932 * @uvec: Pointer to the userspace array.
1933 * @nr_segs: Number of elements in userspace array.
1934 * @fast_segs: Number of elements in @iov.
1935 * @iovp: (input and output parameter) Pointer to pointer to (usually small
1936 *     on-stack) kernel array.
1937 * @i: Pointer to iterator that will be initialized on success.
1938 *
1939 * If the array pointed to by *@iov is large enough to hold all @nr_segs,
1940 * then this function places %NULL in *@iov on return. Otherwise, a new
1941 * array will be allocated and the result placed in *@iov. This means that
1942 * the caller may call kfree() on *@iov regardless of whether the small
1943 * on-stack array was used or not (and regardless of whether this function
1944 * returns an error or not).
1945 *
1946 * Return: Negative error code on error, bytes imported on success
1947 */
1948ssize_t import_iovec(int type, const struct iovec __user *uvec,
1949		 unsigned nr_segs, unsigned fast_segs,
1950		 struct iovec **iovp, struct iov_iter *i)
1951{
1952	return __import_iovec(type, uvec, nr_segs, fast_segs, iovp, i,
1953			      in_compat_syscall());
1954}
1955EXPORT_SYMBOL(import_iovec);
1956
1957int import_single_range(int rw, void __user *buf, size_t len,
1958		 struct iovec *iov, struct iov_iter *i)
1959{
1960	if (len > MAX_RW_COUNT)
1961		len = MAX_RW_COUNT;
1962	if (unlikely(!access_ok(buf, len)))
1963		return -EFAULT;
1964
1965	iov->iov_base = buf;
1966	iov->iov_len = len;
1967	iov_iter_init(i, rw, iov, 1, len);
1968	return 0;
1969}
1970EXPORT_SYMBOL(import_single_range);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
v6.13.7
   1// SPDX-License-Identifier: GPL-2.0-only
 
   2#include <linux/export.h>
   3#include <linux/bvec.h>
   4#include <linux/fault-inject-usercopy.h>
   5#include <linux/uio.h>
   6#include <linux/pagemap.h>
   7#include <linux/highmem.h>
   8#include <linux/slab.h>
   9#include <linux/vmalloc.h>
  10#include <linux/splice.h>
  11#include <linux/compat.h>
 
  12#include <linux/scatterlist.h>
  13#include <linux/instrumented.h>
  14#include <linux/iov_iter.h>
  15
  16static __always_inline
  17size_t copy_to_user_iter(void __user *iter_to, size_t progress,
  18			 size_t len, void *from, void *priv2)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  19{
  20	if (should_fail_usercopy())
  21		return len;
  22	if (access_ok(iter_to, len)) {
  23		from += progress;
  24		instrument_copy_to_user(iter_to, from, len);
  25		len = raw_copy_to_user(iter_to, from, len);
  26	}
  27	return len;
  28}
  29
  30static __always_inline
  31size_t copy_to_user_iter_nofault(void __user *iter_to, size_t progress,
  32				 size_t len, void *from, void *priv2)
  33{
  34	ssize_t res;
  35
  36	if (should_fail_usercopy())
  37		return len;
  38
  39	from += progress;
  40	res = copy_to_user_nofault(iter_to, from, len);
  41	return res < 0 ? len : res;
 
  42}
  43
  44static __always_inline
  45size_t copy_from_user_iter(void __user *iter_from, size_t progress,
  46			   size_t len, void *to, void *priv2)
  47{
  48	size_t res = len;
 
 
 
 
 
 
 
 
 
  49
  50	if (should_fail_usercopy())
  51		return len;
  52	if (access_ok(iter_from, len)) {
  53		to += progress;
  54		instrument_copy_from_user_before(to, iter_from, len);
  55		res = raw_copy_from_user(to, iter_from, len);
  56		instrument_copy_from_user_after(to, iter_from, len, res);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  57	}
  58	return res;
 
 
 
 
  59}
  60
  61static __always_inline
  62size_t memcpy_to_iter(void *iter_to, size_t progress,
  63		      size_t len, void *from, void *priv2)
  64{
  65	memcpy(iter_to, from + progress, len);
  66	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  67}
 
 
 
  68
  69static __always_inline
  70size_t memcpy_from_iter(void *iter_from, size_t progress,
  71			size_t len, void *to, void *priv2)
  72{
  73	memcpy(to + progress, iter_from, len);
  74	return 0;
  75}
 
 
 
 
 
 
  76
  77/*
  78 * fault_in_iov_iter_readable - fault in iov iterator for reading
  79 * @i: iterator
  80 * @size: maximum length
  81 *
  82 * Fault in one or more iovecs of the given iov_iter, to a maximum length of
  83 * @size.  For each iovec, fault in each page that constitutes the iovec.
  84 *
  85 * Returns the number of bytes not faulted in (like copy_to_user() and
  86 * copy_from_user()).
  87 *
  88 * Always returns 0 for non-userspace iterators.
  89 */
  90size_t fault_in_iov_iter_readable(const struct iov_iter *i, size_t size)
  91{
  92	if (iter_is_ubuf(i)) {
  93		size_t n = min(size, iov_iter_count(i));
  94		n -= fault_in_readable(i->ubuf + i->iov_offset, n);
  95		return size - n;
  96	} else if (iter_is_iovec(i)) {
  97		size_t count = min(size, iov_iter_count(i));
  98		const struct iovec *p;
  99		size_t skip;
 100
 101		size -= count;
 102		for (p = iter_iov(i), skip = i->iov_offset; count; p++, skip = 0) {
 103			size_t len = min(count, p->iov_len - skip);
 104			size_t ret;
 105
 106			if (unlikely(!len))
 107				continue;
 108			ret = fault_in_readable(p->iov_base + skip, len);
 109			count -= len - ret;
 110			if (ret)
 111				break;
 
 
 112		}
 113		return count + size;
 
 114	}
 115	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 116}
 117EXPORT_SYMBOL(fault_in_iov_iter_readable);
 118
 119/*
 120 * fault_in_iov_iter_writeable - fault in iov iterator for writing
 121 * @i: iterator
 122 * @size: maximum length
 123 *
 124 * Faults in the iterator using get_user_pages(), i.e., without triggering
 125 * hardware page faults.  This is primarily useful when we already know that
 126 * some or all of the pages in @i aren't in memory.
 127 *
 128 * Returns the number of bytes not faulted in, like copy_to_user() and
 129 * copy_from_user().
 130 *
 131 * Always returns 0 for non-user-space iterators.
 132 */
 133size_t fault_in_iov_iter_writeable(const struct iov_iter *i, size_t size)
 134{
 135	if (iter_is_ubuf(i)) {
 136		size_t n = min(size, iov_iter_count(i));
 137		n -= fault_in_safe_writeable(i->ubuf + i->iov_offset, n);
 138		return size - n;
 139	} else if (iter_is_iovec(i)) {
 140		size_t count = min(size, iov_iter_count(i));
 141		const struct iovec *p;
 142		size_t skip;
 143
 144		size -= count;
 145		for (p = iter_iov(i), skip = i->iov_offset; count; p++, skip = 0) {
 146			size_t len = min(count, p->iov_len - skip);
 147			size_t ret;
 
 148
 149			if (unlikely(!len))
 150				continue;
 151			ret = fault_in_safe_writeable(p->iov_base + skip, len);
 152			count -= len - ret;
 153			if (ret)
 154				break;
 155		}
 156		return count + size;
 157	}
 158	return 0;
 159}
 160EXPORT_SYMBOL(fault_in_iov_iter_writeable);
 161
 162void iov_iter_init(struct iov_iter *i, unsigned int direction,
 163			const struct iovec *iov, unsigned long nr_segs,
 164			size_t count)
 165{
 166	WARN_ON(direction & ~(READ | WRITE));
 167	*i = (struct iov_iter) {
 168		.iter_type = ITER_IOVEC,
 169		.nofault = false,
 170		.data_source = direction,
 171		.__iov = iov,
 172		.nr_segs = nr_segs,
 173		.iov_offset = 0,
 174		.count = count
 175	};
 176}
 177EXPORT_SYMBOL(iov_iter_init);
 178
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 179size_t _copy_to_iter(const void *addr, size_t bytes, struct iov_iter *i)
 180{
 181	if (WARN_ON_ONCE(i->data_source))
 182		return 0;
 183	if (user_backed_iter(i))
 184		might_fault();
 185	return iterate_and_advance(i, bytes, (void *)addr,
 186				   copy_to_user_iter, memcpy_to_iter);
 
 
 
 
 187}
 188EXPORT_SYMBOL(_copy_to_iter);
 189
 190#ifdef CONFIG_ARCH_HAS_COPY_MC
 191static __always_inline
 192size_t copy_to_user_iter_mc(void __user *iter_to, size_t progress,
 193			    size_t len, void *from, void *priv2)
 194{
 195	if (access_ok(iter_to, len)) {
 196		from += progress;
 197		instrument_copy_to_user(iter_to, from, len);
 198		len = copy_mc_to_user(iter_to, from, len);
 199	}
 200	return len;
 201}
 202
 203static __always_inline
 204size_t memcpy_to_iter_mc(void *iter_to, size_t progress,
 205			 size_t len, void *from, void *priv2)
 206{
 207	return copy_mc_to_kernel(iter_to, from + progress, len);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 208}
 209
 210/**
 211 * _copy_mc_to_iter - copy to iter with source memory error exception handling
 212 * @addr: source kernel address
 213 * @bytes: total transfer length
 214 * @i: destination iterator
 215 *
 216 * The pmem driver deploys this for the dax operation
 217 * (dax_copy_to_iter()) for dax reads (bypass page-cache and the
 218 * block-layer). Upon #MC read(2) aborts and returns EIO or the bytes
 219 * successfully copied.
 220 *
 221 * The main differences between this and typical _copy_to_iter().
 222 *
 223 * * Typical tail/residue handling after a fault retries the copy
 224 *   byte-by-byte until the fault happens again. Re-triggering machine
 225 *   checks is potentially fatal so the implementation uses source
 226 *   alignment and poison alignment assumptions to avoid re-triggering
 227 *   hardware exceptions.
 228 *
 229 * * ITER_KVEC and ITER_BVEC can return short copies.  Compare to
 230 *   copy_to_iter() where only ITER_IOVEC attempts might return a short copy.
 231 *
 232 * Return: number of bytes copied (may be %0)
 233 */
 234size_t _copy_mc_to_iter(const void *addr, size_t bytes, struct iov_iter *i)
 235{
 236	if (WARN_ON_ONCE(i->data_source))
 237		return 0;
 238	if (user_backed_iter(i))
 239		might_fault();
 240	return iterate_and_advance(i, bytes, (void *)addr,
 241				   copy_to_user_iter_mc, memcpy_to_iter_mc);
 
 
 
 
 242}
 243EXPORT_SYMBOL_GPL(_copy_mc_to_iter);
 244#endif /* CONFIG_ARCH_HAS_COPY_MC */
 245
 246static __always_inline
 247size_t __copy_from_iter(void *addr, size_t bytes, struct iov_iter *i)
 248{
 249	return iterate_and_advance(i, bytes, addr,
 250				   copy_from_user_iter, memcpy_from_iter);
 251}
 252
 253size_t _copy_from_iter(void *addr, size_t bytes, struct iov_iter *i)
 254{
 255	if (WARN_ON_ONCE(!i->data_source))
 
 256		return 0;
 
 
 
 
 
 
 
 257
 258	if (user_backed_iter(i))
 259		might_fault();
 260	return __copy_from_iter(addr, bytes, i);
 261}
 262EXPORT_SYMBOL(_copy_from_iter);
 263
 264static __always_inline
 265size_t copy_from_user_iter_nocache(void __user *iter_from, size_t progress,
 266				   size_t len, void *to, void *priv2)
 267{
 268	return __copy_from_user_inatomic_nocache(to + progress, iter_from, len);
 269}
 270
 271size_t _copy_from_iter_nocache(void *addr, size_t bytes, struct iov_iter *i)
 272{
 273	if (WARN_ON_ONCE(!i->data_source))
 
 274		return 0;
 
 
 
 
 
 275
 276	return iterate_and_advance(i, bytes, addr,
 277				   copy_from_user_iter_nocache,
 278				   memcpy_from_iter);
 279}
 280EXPORT_SYMBOL(_copy_from_iter_nocache);
 281
 282#ifdef CONFIG_ARCH_HAS_UACCESS_FLUSHCACHE
 283static __always_inline
 284size_t copy_from_user_iter_flushcache(void __user *iter_from, size_t progress,
 285				      size_t len, void *to, void *priv2)
 286{
 287	return __copy_from_user_flushcache(to + progress, iter_from, len);
 288}
 289
 290static __always_inline
 291size_t memcpy_from_iter_flushcache(void *iter_from, size_t progress,
 292				   size_t len, void *to, void *priv2)
 293{
 294	memcpy_flushcache(to + progress, iter_from, len);
 295	return 0;
 296}
 297
 298/**
 299 * _copy_from_iter_flushcache - write destination through cpu cache
 300 * @addr: destination kernel address
 301 * @bytes: total transfer length
 302 * @i: source iterator
 303 *
 304 * The pmem driver arranges for filesystem-dax to use this facility via
 305 * dax_copy_from_iter() for ensuring that writes to persistent memory
 306 * are flushed through the CPU cache. It is differentiated from
 307 * _copy_from_iter_nocache() in that guarantees all data is flushed for
 308 * all iterator types. The _copy_from_iter_nocache() only attempts to
 309 * bypass the cache for the ITER_IOVEC case, and on some archs may use
 310 * instructions that strand dirty-data in the cache.
 311 *
 312 * Return: number of bytes copied (may be %0)
 313 */
 314size_t _copy_from_iter_flushcache(void *addr, size_t bytes, struct iov_iter *i)
 315{
 316	if (WARN_ON_ONCE(!i->data_source))
 
 317		return 0;
 
 
 
 
 
 318
 319	return iterate_and_advance(i, bytes, addr,
 320				   copy_from_user_iter_flushcache,
 321				   memcpy_from_iter_flushcache);
 322}
 323EXPORT_SYMBOL_GPL(_copy_from_iter_flushcache);
 324#endif
 325
 326static inline bool page_copy_sane(struct page *page, size_t offset, size_t n)
 327{
 328	struct page *head;
 329	size_t v = n + offset;
 330
 331	/*
 332	 * The general case needs to access the page order in order
 333	 * to compute the page size.
 334	 * However, we mostly deal with order-0 pages and thus can
 335	 * avoid a possible cache line miss for requests that fit all
 336	 * page orders.
 337	 */
 338	if (n <= v && v <= PAGE_SIZE)
 339		return true;
 340
 341	head = compound_head(page);
 342	v += (page - head) << PAGE_SHIFT;
 343
 344	if (WARN_ON(n > v || v > page_size(head)))
 345		return false;
 346	return true;
 
 347}
 348
 349size_t copy_page_to_iter(struct page *page, size_t offset, size_t bytes,
 350			 struct iov_iter *i)
 351{
 352	size_t res = 0;
 353	if (!page_copy_sane(page, offset, bytes))
 354		return 0;
 355	if (WARN_ON_ONCE(i->data_source))
 356		return 0;
 357	page += offset / PAGE_SIZE; // first subpage
 358	offset %= PAGE_SIZE;
 359	while (1) {
 360		void *kaddr = kmap_local_page(page);
 361		size_t n = min(bytes, (size_t)PAGE_SIZE - offset);
 362		n = _copy_to_iter(kaddr + offset, n, i);
 363		kunmap_local(kaddr);
 364		res += n;
 365		bytes -= n;
 366		if (!bytes || !n)
 367			break;
 368		offset += n;
 369		if (offset == PAGE_SIZE) {
 370			page++;
 371			offset = 0;
 372		}
 373	}
 374	return res;
 
 375}
 376EXPORT_SYMBOL(copy_page_to_iter);
 377
 378size_t copy_page_to_iter_nofault(struct page *page, unsigned offset, size_t bytes,
 379				 struct iov_iter *i)
 380{
 381	size_t res = 0;
 382
 383	if (!page_copy_sane(page, offset, bytes))
 384		return 0;
 385	if (WARN_ON_ONCE(i->data_source))
 386		return 0;
 387	page += offset / PAGE_SIZE; // first subpage
 388	offset %= PAGE_SIZE;
 389	while (1) {
 390		void *kaddr = kmap_local_page(page);
 391		size_t n = min(bytes, (size_t)PAGE_SIZE - offset);
 392
 393		n = iterate_and_advance(i, n, kaddr + offset,
 394					copy_to_user_iter_nofault,
 395					memcpy_to_iter);
 396		kunmap_local(kaddr);
 397		res += n;
 398		bytes -= n;
 399		if (!bytes || !n)
 400			break;
 401		offset += n;
 402		if (offset == PAGE_SIZE) {
 403			page++;
 404			offset = 0;
 405		}
 406	}
 407	return res;
 408}
 409EXPORT_SYMBOL(copy_page_to_iter_nofault);
 410
 411size_t copy_page_from_iter(struct page *page, size_t offset, size_t bytes,
 412			 struct iov_iter *i)
 413{
 414	size_t res = 0;
 415	if (!page_copy_sane(page, offset, bytes))
 416		return 0;
 417	page += offset / PAGE_SIZE; // first subpage
 418	offset %= PAGE_SIZE;
 419	while (1) {
 420		void *kaddr = kmap_local_page(page);
 421		size_t n = min(bytes, (size_t)PAGE_SIZE - offset);
 422		n = _copy_from_iter(kaddr + offset, n, i);
 423		kunmap_local(kaddr);
 424		res += n;
 425		bytes -= n;
 426		if (!bytes || !n)
 427			break;
 428		offset += n;
 429		if (offset == PAGE_SIZE) {
 430			page++;
 431			offset = 0;
 432		}
 433	}
 434	return res;
 
 435}
 436EXPORT_SYMBOL(copy_page_from_iter);
 437
 438static __always_inline
 439size_t zero_to_user_iter(void __user *iter_to, size_t progress,
 440			 size_t len, void *priv, void *priv2)
 441{
 442	return clear_user(iter_to, len);
 443}
 
 
 
 
 
 
 
 
 
 444
 445static __always_inline
 446size_t zero_to_iter(void *iter_to, size_t progress,
 447		    size_t len, void *priv, void *priv2)
 448{
 449	memset(iter_to, 0, len);
 450	return 0;
 
 
 
 
 
 
 
 451}
 452
 453size_t iov_iter_zero(size_t bytes, struct iov_iter *i)
 454{
 455	return iterate_and_advance(i, bytes, NULL,
 456				   zero_to_user_iter, zero_to_iter);
 
 
 
 
 
 
 457}
 458EXPORT_SYMBOL(iov_iter_zero);
 459
 460size_t copy_page_from_iter_atomic(struct page *page, size_t offset,
 461		size_t bytes, struct iov_iter *i)
 462{
 463	size_t n, copied = 0;
 464	bool uses_kmap = IS_ENABLED(CONFIG_DEBUG_KMAP_LOCAL_FORCE_MAP) ||
 465			 PageHighMem(page);
 466
 467	if (!page_copy_sane(page, offset, bytes))
 468		return 0;
 469	if (WARN_ON_ONCE(!i->data_source))
 
 
 
 470		return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 471
 472	do {
 473		char *p;
 
 
 474
 475		n = bytes - copied;
 476		if (uses_kmap) {
 477			page += offset / PAGE_SIZE;
 478			offset %= PAGE_SIZE;
 479			n = min_t(size_t, n, PAGE_SIZE - offset);
 
 
 
 480		}
 481
 482		p = kmap_atomic(page) + offset;
 483		n = __copy_from_iter(p, n, i);
 484		kunmap_atomic(p);
 485		copied += n;
 486		offset += n;
 487	} while (uses_kmap && copied != bytes && n > 0);
 
 
 
 
 
 
 488
 489	return copied;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 490}
 491EXPORT_SYMBOL(copy_page_from_iter_atomic);
 492
 493static void iov_iter_bvec_advance(struct iov_iter *i, size_t size)
 494{
 495	const struct bio_vec *bvec, *end;
 496
 497	if (!i->count)
 498		return;
 499	i->count -= size;
 
 500
 501	size += i->iov_offset;
 502
 503	for (bvec = i->bvec, end = bvec + i->nr_segs; bvec < end; bvec++) {
 504		if (likely(size < bvec->bv_len))
 505			break;
 506		size -= bvec->bv_len;
 507	}
 508	i->iov_offset = size;
 509	i->nr_segs -= bvec - i->bvec;
 510	i->bvec = bvec;
 511}
 512
 513static void iov_iter_iovec_advance(struct iov_iter *i, size_t size)
 514{
 515	const struct iovec *iov, *end;
 516
 517	if (!i->count)
 518		return;
 519	i->count -= size;
 520
 521	size += i->iov_offset; // from beginning of current segment
 522	for (iov = iter_iov(i), end = iov + i->nr_segs; iov < end; iov++) {
 523		if (likely(size < iov->iov_len))
 524			break;
 525		size -= iov->iov_len;
 526	}
 527	i->iov_offset = size;
 528	i->nr_segs -= iov - iter_iov(i);
 529	i->__iov = iov;
 530}
 531
 532static void iov_iter_folioq_advance(struct iov_iter *i, size_t size)
 533{
 534	const struct folio_queue *folioq = i->folioq;
 535	unsigned int slot = i->folioq_slot;
 536
 537	if (!i->count)
 538		return;
 539	i->count -= size;
 540
 541	if (slot >= folioq_nr_slots(folioq)) {
 542		folioq = folioq->next;
 543		slot = 0;
 544	}
 545
 546	size += i->iov_offset; /* From beginning of current segment. */
 547	do {
 548		size_t fsize = folioq_folio_size(folioq, slot);
 549
 550		if (likely(size < fsize))
 551			break;
 552		size -= fsize;
 553		slot++;
 554		if (slot >= folioq_nr_slots(folioq) && folioq->next) {
 555			folioq = folioq->next;
 556			slot = 0;
 557		}
 558	} while (size);
 559
 560	i->iov_offset = size;
 561	i->folioq_slot = slot;
 562	i->folioq = folioq;
 563}
 564
 565void iov_iter_advance(struct iov_iter *i, size_t size)
 566{
 567	if (unlikely(i->count < size))
 568		size = i->count;
 569	if (likely(iter_is_ubuf(i)) || unlikely(iov_iter_is_xarray(i))) {
 570		i->iov_offset += size;
 571		i->count -= size;
 572	} else if (likely(iter_is_iovec(i) || iov_iter_is_kvec(i))) {
 573		/* iovec and kvec have identical layouts */
 574		iov_iter_iovec_advance(i, size);
 575	} else if (iov_iter_is_bvec(i)) {
 576		iov_iter_bvec_advance(i, size);
 577	} else if (iov_iter_is_folioq(i)) {
 578		iov_iter_folioq_advance(i, size);
 
 
 
 579	} else if (iov_iter_is_discard(i)) {
 580		i->count -= size;
 581	}
 582}
 583EXPORT_SYMBOL(iov_iter_advance);
 584
 585static void iov_iter_folioq_revert(struct iov_iter *i, size_t unroll)
 586{
 587	const struct folio_queue *folioq = i->folioq;
 588	unsigned int slot = i->folioq_slot;
 589
 590	for (;;) {
 591		size_t fsize;
 592
 593		if (slot == 0) {
 594			folioq = folioq->prev;
 595			slot = folioq_nr_slots(folioq);
 596		}
 597		slot--;
 598
 599		fsize = folioq_folio_size(folioq, slot);
 600		if (unroll <= fsize) {
 601			i->iov_offset = fsize - unroll;
 602			break;
 603		}
 604		unroll -= fsize;
 605	}
 606
 607	i->folioq_slot = slot;
 608	i->folioq = folioq;
 609}
 610
 611void iov_iter_revert(struct iov_iter *i, size_t unroll)
 612{
 613	if (!unroll)
 614		return;
 615	if (WARN_ON(unroll > MAX_RW_COUNT))
 616		return;
 617	i->count += unroll;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 618	if (unlikely(iov_iter_is_discard(i)))
 619		return;
 620	if (unroll <= i->iov_offset) {
 621		i->iov_offset -= unroll;
 622		return;
 623	}
 624	unroll -= i->iov_offset;
 625	if (iov_iter_is_xarray(i) || iter_is_ubuf(i)) {
 626		BUG(); /* We should never go beyond the start of the specified
 627			* range since we might then be straying into pages that
 628			* aren't pinned.
 629			*/
 630	} else if (iov_iter_is_bvec(i)) {
 631		const struct bio_vec *bvec = i->bvec;
 632		while (1) {
 633			size_t n = (--bvec)->bv_len;
 634			i->nr_segs++;
 635			if (unroll <= n) {
 636				i->bvec = bvec;
 637				i->iov_offset = n - unroll;
 638				return;
 639			}
 640			unroll -= n;
 641		}
 642	} else if (iov_iter_is_folioq(i)) {
 643		i->iov_offset = 0;
 644		iov_iter_folioq_revert(i, unroll);
 645	} else { /* same logics for iovec and kvec */
 646		const struct iovec *iov = iter_iov(i);
 647		while (1) {
 648			size_t n = (--iov)->iov_len;
 649			i->nr_segs++;
 650			if (unroll <= n) {
 651				i->__iov = iov;
 652				i->iov_offset = n - unroll;
 653				return;
 654			}
 655			unroll -= n;
 656		}
 657	}
 658}
 659EXPORT_SYMBOL(iov_iter_revert);
 660
 661/*
 662 * Return the count of just the current iov_iter segment.
 663 */
 664size_t iov_iter_single_seg_count(const struct iov_iter *i)
 665{
 666	if (i->nr_segs > 1) {
 667		if (likely(iter_is_iovec(i) || iov_iter_is_kvec(i)))
 668			return min(i->count, iter_iov(i)->iov_len - i->iov_offset);
 669		if (iov_iter_is_bvec(i))
 670			return min(i->count, i->bvec->bv_len - i->iov_offset);
 671	}
 672	if (unlikely(iov_iter_is_folioq(i)))
 673		return !i->count ? 0 :
 674			umin(folioq_folio_size(i->folioq, i->folioq_slot), i->count);
 675	return i->count;
 676}
 677EXPORT_SYMBOL(iov_iter_single_seg_count);
 678
 679void iov_iter_kvec(struct iov_iter *i, unsigned int direction,
 680			const struct kvec *kvec, unsigned long nr_segs,
 681			size_t count)
 682{
 683	WARN_ON(direction & ~(READ | WRITE));
 684	*i = (struct iov_iter){
 685		.iter_type = ITER_KVEC,
 686		.data_source = direction,
 687		.kvec = kvec,
 688		.nr_segs = nr_segs,
 689		.iov_offset = 0,
 690		.count = count
 691	};
 692}
 693EXPORT_SYMBOL(iov_iter_kvec);
 694
 695void iov_iter_bvec(struct iov_iter *i, unsigned int direction,
 696			const struct bio_vec *bvec, unsigned long nr_segs,
 697			size_t count)
 698{
 699	WARN_ON(direction & ~(READ | WRITE));
 700	*i = (struct iov_iter){
 701		.iter_type = ITER_BVEC,
 702		.data_source = direction,
 703		.bvec = bvec,
 704		.nr_segs = nr_segs,
 705		.iov_offset = 0,
 706		.count = count
 707	};
 708}
 709EXPORT_SYMBOL(iov_iter_bvec);
 710
 711/**
 712 * iov_iter_folio_queue - Initialise an I/O iterator to use the folios in a folio queue
 713 * @i: The iterator to initialise.
 714 * @direction: The direction of the transfer.
 715 * @folioq: The starting point in the folio queue.
 716 * @first_slot: The first slot in the folio queue to use
 717 * @offset: The offset into the folio in the first slot to start at
 718 * @count: The size of the I/O buffer in bytes.
 719 *
 720 * Set up an I/O iterator to either draw data out of the pages attached to an
 721 * inode or to inject data into those pages.  The pages *must* be prevented
 722 * from evaporation, either by taking a ref on them or locking them by the
 723 * caller.
 724 */
 725void iov_iter_folio_queue(struct iov_iter *i, unsigned int direction,
 726			  const struct folio_queue *folioq, unsigned int first_slot,
 727			  unsigned int offset, size_t count)
 728{
 729	BUG_ON(direction & ~1);
 730	*i = (struct iov_iter) {
 731		.iter_type = ITER_FOLIOQ,
 732		.data_source = direction,
 733		.folioq = folioq,
 734		.folioq_slot = first_slot,
 735		.count = count,
 736		.iov_offset = offset,
 
 
 737	};
 738}
 739EXPORT_SYMBOL(iov_iter_folio_queue);
 740
 741/**
 742 * iov_iter_xarray - Initialise an I/O iterator to use the pages in an xarray
 743 * @i: The iterator to initialise.
 744 * @direction: The direction of the transfer.
 745 * @xarray: The xarray to access.
 746 * @start: The start file position.
 747 * @count: The size of the I/O buffer in bytes.
 748 *
 749 * Set up an I/O iterator to either draw data out of the pages attached to an
 750 * inode or to inject data into those pages.  The pages *must* be prevented
 751 * from evaporation, either by taking a ref on them or locking them by the
 752 * caller.
 753 */
 754void iov_iter_xarray(struct iov_iter *i, unsigned int direction,
 755		     struct xarray *xarray, loff_t start, size_t count)
 756{
 757	BUG_ON(direction & ~1);
 758	*i = (struct iov_iter) {
 759		.iter_type = ITER_XARRAY,
 760		.data_source = direction,
 761		.xarray = xarray,
 762		.xarray_start = start,
 763		.count = count,
 764		.iov_offset = 0
 765	};
 766}
 767EXPORT_SYMBOL(iov_iter_xarray);
 768
 769/**
 770 * iov_iter_discard - Initialise an I/O iterator that discards data
 771 * @i: The iterator to initialise.
 772 * @direction: The direction of the transfer.
 773 * @count: The size of the I/O buffer in bytes.
 774 *
 775 * Set up an I/O iterator that just discards everything that's written to it.
 776 * It's only available as a READ iterator.
 777 */
 778void iov_iter_discard(struct iov_iter *i, unsigned int direction, size_t count)
 779{
 780	BUG_ON(direction != READ);
 781	*i = (struct iov_iter){
 782		.iter_type = ITER_DISCARD,
 783		.data_source = false,
 784		.count = count,
 785		.iov_offset = 0
 786	};
 787}
 788EXPORT_SYMBOL(iov_iter_discard);
 789
 790static bool iov_iter_aligned_iovec(const struct iov_iter *i, unsigned addr_mask,
 791				   unsigned len_mask)
 792{
 793	const struct iovec *iov = iter_iov(i);
 794	size_t size = i->count;
 795	size_t skip = i->iov_offset;
 796
 797	do {
 798		size_t len = iov->iov_len - skip;
 799
 800		if (len > size)
 801			len = size;
 802		if (len & len_mask)
 803			return false;
 804		if ((unsigned long)(iov->iov_base + skip) & addr_mask)
 805			return false;
 806
 807		iov++;
 808		size -= len;
 809		skip = 0;
 810	} while (size);
 811
 812	return true;
 813}
 814
 815static bool iov_iter_aligned_bvec(const struct iov_iter *i, unsigned addr_mask,
 816				  unsigned len_mask)
 817{
 818	const struct bio_vec *bvec = i->bvec;
 819	unsigned skip = i->iov_offset;
 820	size_t size = i->count;
 821
 822	do {
 823		size_t len = bvec->bv_len;
 824
 825		if (len > size)
 826			len = size;
 827		if (len & len_mask)
 828			return false;
 829		if ((unsigned long)(bvec->bv_offset + skip) & addr_mask)
 830			return false;
 831
 832		bvec++;
 833		size -= len;
 834		skip = 0;
 835	} while (size);
 836
 837	return true;
 838}
 839
 840/**
 841 * iov_iter_is_aligned() - Check if the addresses and lengths of each segments
 842 * 	are aligned to the parameters.
 843 *
 844 * @i: &struct iov_iter to restore
 845 * @addr_mask: bit mask to check against the iov element's addresses
 846 * @len_mask: bit mask to check against the iov element's lengths
 847 *
 848 * Return: false if any addresses or lengths intersect with the provided masks
 849 */
 850bool iov_iter_is_aligned(const struct iov_iter *i, unsigned addr_mask,
 851			 unsigned len_mask)
 852{
 853	if (likely(iter_is_ubuf(i))) {
 854		if (i->count & len_mask)
 855			return false;
 856		if ((unsigned long)(i->ubuf + i->iov_offset) & addr_mask)
 857			return false;
 858		return true;
 859	}
 860
 861	if (likely(iter_is_iovec(i) || iov_iter_is_kvec(i)))
 862		return iov_iter_aligned_iovec(i, addr_mask, len_mask);
 863
 864	if (iov_iter_is_bvec(i))
 865		return iov_iter_aligned_bvec(i, addr_mask, len_mask);
 866
 867	/* With both xarray and folioq types, we're dealing with whole folios. */
 868	if (iov_iter_is_xarray(i)) {
 869		if (i->count & len_mask)
 870			return false;
 871		if ((i->xarray_start + i->iov_offset) & addr_mask)
 872			return false;
 873	}
 874	if (iov_iter_is_folioq(i)) {
 875		if (i->count & len_mask)
 876			return false;
 877		if (i->iov_offset & addr_mask)
 878			return false;
 879	}
 880
 881	return true;
 882}
 883EXPORT_SYMBOL_GPL(iov_iter_is_aligned);
 884
 885static unsigned long iov_iter_alignment_iovec(const struct iov_iter *i)
 886{
 887	const struct iovec *iov = iter_iov(i);
 888	unsigned long res = 0;
 889	size_t size = i->count;
 890	size_t skip = i->iov_offset;
 
 891
 892	do {
 893		size_t len = iov->iov_len - skip;
 894		if (len) {
 895			res |= (unsigned long)iov->iov_base + skip;
 896			if (len > size)
 897				len = size;
 898			res |= len;
 899			size -= len;
 
 
 900		}
 901		iov++;
 902		skip = 0;
 903	} while (size);
 904	return res;
 905}
 906
 907static unsigned long iov_iter_alignment_bvec(const struct iov_iter *i)
 908{
 909	const struct bio_vec *bvec = i->bvec;
 910	unsigned res = 0;
 911	size_t size = i->count;
 912	unsigned skip = i->iov_offset;
 
 913
 914	do {
 915		size_t len = bvec->bv_len - skip;
 916		res |= (unsigned long)bvec->bv_offset + skip;
 917		if (len > size)
 918			len = size;
 919		res |= len;
 920		bvec++;
 921		size -= len;
 922		skip = 0;
 923	} while (size);
 924
 925	return res;
 926}
 927
 928unsigned long iov_iter_alignment(const struct iov_iter *i)
 929{
 930	if (likely(iter_is_ubuf(i))) {
 931		size_t size = i->count;
 932		if (size)
 933			return ((unsigned long)i->ubuf + i->iov_offset) | size;
 934		return 0;
 935	}
 936
 937	/* iovec and kvec have identical layouts */
 938	if (likely(iter_is_iovec(i) || iov_iter_is_kvec(i)))
 939		return iov_iter_alignment_iovec(i);
 940
 941	if (iov_iter_is_bvec(i))
 942		return iov_iter_alignment_bvec(i);
 943
 944	/* With both xarray and folioq types, we're dealing with whole folios. */
 945	if (iov_iter_is_folioq(i))
 946		return i->iov_offset | i->count;
 
 
 
 
 
 
 947	if (iov_iter_is_xarray(i))
 948		return (i->xarray_start + i->iov_offset) | i->count;
 949
 950	return 0;
 951}
 952EXPORT_SYMBOL(iov_iter_alignment);
 953
 954unsigned long iov_iter_gap_alignment(const struct iov_iter *i)
 955{
 956	unsigned long res = 0;
 957	unsigned long v = 0;
 958	size_t size = i->count;
 959	unsigned k;
 960
 961	if (iter_is_ubuf(i))
 962		return 0;
 963
 964	if (WARN_ON(!iter_is_iovec(i)))
 965		return ~0U;
 966
 967	for (k = 0; k < i->nr_segs; k++) {
 968		const struct iovec *iov = iter_iov(i) + k;
 969		if (iov->iov_len) {
 970			unsigned long base = (unsigned long)iov->iov_base;
 971			if (v) // if not the first one
 972				res |= base | v; // this start | previous end
 973			v = base + iov->iov_len;
 974			if (size <= iov->iov_len)
 975				break;
 976			size -= iov->iov_len;
 977		}
 978	}
 979	return res;
 980}
 981EXPORT_SYMBOL(iov_iter_gap_alignment);
 982
 983static int want_pages_array(struct page ***res, size_t size,
 984			    size_t start, unsigned int maxpages)
 985{
 986	unsigned int count = DIV_ROUND_UP(size + start, PAGE_SIZE);
 
 
 
 
 
 
 
 987
 988	if (count > maxpages)
 989		count = maxpages;
 990	WARN_ON(!count);	// caller should've prevented that
 991	if (!*res) {
 992		*res = kvmalloc_array(count, sizeof(struct page *), GFP_KERNEL);
 993		if (!*res)
 994			return 0;
 995	}
 996	return count;
 
 997}
 998
 999static ssize_t iter_folioq_get_pages(struct iov_iter *iter,
1000				     struct page ***ppages, size_t maxsize,
1001				     unsigned maxpages, size_t *_start_offset)
1002{
1003	const struct folio_queue *folioq = iter->folioq;
1004	struct page **pages;
1005	unsigned int slot = iter->folioq_slot;
1006	size_t extracted = 0, count = iter->count, iov_offset = iter->iov_offset;
1007
1008	if (slot >= folioq_nr_slots(folioq)) {
1009		folioq = folioq->next;
1010		slot = 0;
1011		if (WARN_ON(iov_offset != 0))
1012			return -EIO;
1013	}
1014
1015	maxpages = want_pages_array(ppages, maxsize, iov_offset & ~PAGE_MASK, maxpages);
1016	if (!maxpages)
1017		return -ENOMEM;
1018	*_start_offset = iov_offset & ~PAGE_MASK;
1019	pages = *ppages;
1020
1021	for (;;) {
1022		struct folio *folio = folioq_folio(folioq, slot);
1023		size_t offset = iov_offset, fsize = folioq_folio_size(folioq, slot);
1024		size_t part = PAGE_SIZE - offset % PAGE_SIZE;
1025
1026		if (offset < fsize) {
1027			part = umin(part, umin(maxsize - extracted, fsize - offset));
1028			count -= part;
1029			iov_offset += part;
1030			extracted += part;
1031
1032			*pages = folio_page(folio, offset / PAGE_SIZE);
1033			get_page(*pages);
1034			pages++;
1035			maxpages--;
1036		}
1037
1038		if (maxpages == 0 || extracted >= maxsize)
1039			break;
1040
1041		if (iov_offset >= fsize) {
1042			iov_offset = 0;
1043			slot++;
1044			if (slot == folioq_nr_slots(folioq) && folioq->next) {
1045				folioq = folioq->next;
1046				slot = 0;
1047			}
1048		}
1049	}
1050
1051	iter->count = count;
1052	iter->iov_offset = iov_offset;
1053	iter->folioq = folioq;
1054	iter->folioq_slot = slot;
1055	return extracted;
1056}
1057
1058static ssize_t iter_xarray_populate_pages(struct page **pages, struct xarray *xa,
1059					  pgoff_t index, unsigned int nr_pages)
1060{
1061	XA_STATE(xas, xa, index);
1062	struct page *page;
1063	unsigned int ret = 0;
1064
1065	rcu_read_lock();
1066	for (page = xas_load(&xas); page; page = xas_next(&xas)) {
1067		if (xas_retry(&xas, page))
1068			continue;
1069
1070		/* Has the page moved or been split? */
1071		if (unlikely(page != xas_reload(&xas))) {
1072			xas_reset(&xas);
1073			continue;
1074		}
1075
1076		pages[ret] = find_subpage(page, xas.xa_index);
1077		get_page(pages[ret]);
1078		if (++ret == nr_pages)
1079			break;
1080	}
1081	rcu_read_unlock();
1082	return ret;
1083}
1084
1085static ssize_t iter_xarray_get_pages(struct iov_iter *i,
1086				     struct page ***pages, size_t maxsize,
1087				     unsigned maxpages, size_t *_start_offset)
1088{
1089	unsigned nr, offset, count;
1090	pgoff_t index;
 
1091	loff_t pos;
1092
 
 
 
1093	pos = i->xarray_start + i->iov_offset;
1094	index = pos >> PAGE_SHIFT;
1095	offset = pos & ~PAGE_MASK;
1096	*_start_offset = offset;
1097
1098	count = want_pages_array(pages, maxsize, offset, maxpages);
1099	if (!count)
1100		return -ENOMEM;
1101	nr = iter_xarray_populate_pages(*pages, i->xarray, index, count);
 
 
 
 
 
 
 
 
 
1102	if (nr == 0)
1103		return 0;
1104
1105	maxsize = min_t(size_t, nr * PAGE_SIZE - offset, maxsize);
1106	i->iov_offset += maxsize;
1107	i->count -= maxsize;
1108	return maxsize;
 
 
 
1109}
1110
1111/* must be done on non-empty ITER_UBUF or ITER_IOVEC one */
1112static unsigned long first_iovec_segment(const struct iov_iter *i, size_t *size)
 
 
1113{
1114	size_t skip;
1115	long k;
1116
1117	if (iter_is_ubuf(i))
1118		return (unsigned long)i->ubuf + i->iov_offset;
1119
1120	for (k = 0, skip = i->iov_offset; k < i->nr_segs; k++, skip = 0) {
1121		const struct iovec *iov = iter_iov(i) + k;
1122		size_t len = iov->iov_len - skip;
1123
1124		if (unlikely(!len))
1125			continue;
1126		if (*size > len)
1127			*size = len;
1128		return (unsigned long)iov->iov_base + skip;
 
 
 
 
1129	}
1130	BUG(); // if it had been empty, we wouldn't get called
1131}
1132
1133/* must be done on non-empty ITER_BVEC one */
1134static struct page *first_bvec_segment(const struct iov_iter *i,
1135				       size_t *size, size_t *start)
 
1136{
1137	struct page *page;
1138	size_t skip = i->iov_offset, len;
1139
1140	len = i->bvec->bv_len - skip;
1141	if (*size > len)
1142		*size = len;
1143	skip += i->bvec->bv_offset;
1144	page = i->bvec->bv_page + skip / PAGE_SIZE;
1145	*start = skip % PAGE_SIZE;
 
 
 
1146	return page;
1147}
1148
1149static ssize_t __iov_iter_get_pages_alloc(struct iov_iter *i,
1150		   struct page ***pages, size_t maxsize,
1151		   unsigned int maxpages, size_t *start)
1152{
1153	unsigned int n, gup_flags = 0;
 
1154
1155	if (maxsize > i->count)
1156		maxsize = i->count;
1157	if (!maxsize)
1158		return 0;
1159	if (maxsize > MAX_RW_COUNT)
1160		maxsize = MAX_RW_COUNT;
1161
1162	if (likely(user_backed_iter(i))) {
1163		unsigned long addr;
1164		int res;
1165
1166		if (iov_iter_rw(i) != WRITE)
1167			gup_flags |= FOLL_WRITE;
1168		if (i->nofault)
1169			gup_flags |= FOLL_NOFAULT;
1170
1171		addr = first_iovec_segment(i, &maxsize);
1172		*start = addr % PAGE_SIZE;
1173		addr &= PAGE_MASK;
1174		n = want_pages_array(pages, maxsize, *start, maxpages);
1175		if (!n)
1176			return -ENOMEM;
1177		res = get_user_pages_fast(addr, n, gup_flags, *pages);
1178		if (unlikely(res <= 0))
1179			return res;
1180		maxsize = min_t(size_t, maxsize, res * PAGE_SIZE - *start);
1181		iov_iter_advance(i, maxsize);
1182		return maxsize;
1183	}
1184	if (iov_iter_is_bvec(i)) {
1185		struct page **p;
1186		struct page *page;
1187
1188		page = first_bvec_segment(i, &maxsize, start);
1189		n = want_pages_array(pages, maxsize, *start, maxpages);
1190		if (!n)
1191			return -ENOMEM;
1192		p = *pages;
1193		for (int k = 0; k < n; k++)
1194			get_page(p[k] = page + k);
1195		maxsize = min_t(size_t, maxsize, n * PAGE_SIZE - *start);
1196		i->count -= maxsize;
1197		i->iov_offset += maxsize;
1198		if (i->iov_offset == i->bvec->bv_len) {
1199			i->iov_offset = 0;
1200			i->bvec++;
1201			i->nr_segs--;
1202		}
1203		return maxsize;
1204	}
1205	if (iov_iter_is_folioq(i))
1206		return iter_folioq_get_pages(i, pages, maxsize, maxpages, start);
1207	if (iov_iter_is_xarray(i))
1208		return iter_xarray_get_pages(i, pages, maxsize, maxpages, start);
1209	return -EFAULT;
1210}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1211
1212ssize_t iov_iter_get_pages2(struct iov_iter *i, struct page **pages,
1213		size_t maxsize, unsigned maxpages, size_t *start)
 
1214{
1215	if (!maxpages)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1216		return 0;
1217	BUG_ON(!pages);
1218
1219	return __iov_iter_get_pages_alloc(i, &pages, maxsize, maxpages, start);
 
 
 
 
 
 
1220}
1221EXPORT_SYMBOL(iov_iter_get_pages2);
1222
1223ssize_t iov_iter_get_pages_alloc2(struct iov_iter *i,
1224		struct page ***pages, size_t maxsize, size_t *start)
 
1225{
1226	ssize_t len;
 
 
1227
1228	*pages = NULL;
 
 
 
 
 
 
1229
1230	len = __iov_iter_get_pages_alloc(i, pages, maxsize, ~0U, start);
1231	if (len <= 0) {
1232		kvfree(*pages);
1233		*pages = NULL;
 
 
 
 
 
 
 
 
 
1234	}
1235	return len;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1236}
1237EXPORT_SYMBOL(iov_iter_get_pages_alloc2);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1238
1239static int iov_npages(const struct iov_iter *i, int maxpages)
1240{
1241	size_t skip = i->iov_offset, size = i->count;
1242	const struct iovec *p;
1243	int npages = 0;
1244
1245	for (p = iter_iov(i); size; skip = 0, p++) {
1246		unsigned offs = offset_in_page(p->iov_base + skip);
1247		size_t len = min(p->iov_len - skip, size);
1248
1249		if (len) {
1250			size -= len;
1251			npages += DIV_ROUND_UP(offs + len, PAGE_SIZE);
1252			if (unlikely(npages > maxpages))
1253				return maxpages;
1254		}
1255	}
1256	return npages;
1257}
1258
1259static int bvec_npages(const struct iov_iter *i, int maxpages)
1260{
1261	size_t skip = i->iov_offset, size = i->count;
1262	const struct bio_vec *p;
1263	int npages = 0;
1264
1265	for (p = i->bvec; size; skip = 0, p++) {
1266		unsigned offs = (p->bv_offset + skip) % PAGE_SIZE;
1267		size_t len = min(p->bv_len - skip, size);
1268
1269		size -= len;
1270		npages += DIV_ROUND_UP(offs + len, PAGE_SIZE);
1271		if (unlikely(npages > maxpages))
1272			return maxpages;
1273	}
1274	return npages;
1275}
1276
1277int iov_iter_npages(const struct iov_iter *i, int maxpages)
1278{
1279	if (unlikely(!i->count))
1280		return 0;
1281	if (likely(iter_is_ubuf(i))) {
1282		unsigned offs = offset_in_page(i->ubuf + i->iov_offset);
1283		int npages = DIV_ROUND_UP(offs + i->count, PAGE_SIZE);
1284		return min(npages, maxpages);
1285	}
1286	/* iovec and kvec have identical layouts */
1287	if (likely(iter_is_iovec(i) || iov_iter_is_kvec(i)))
1288		return iov_npages(i, maxpages);
1289	if (iov_iter_is_bvec(i))
1290		return bvec_npages(i, maxpages);
1291	if (iov_iter_is_folioq(i)) {
1292		unsigned offset = i->iov_offset % PAGE_SIZE;
1293		int npages = DIV_ROUND_UP(offset + i->count, PAGE_SIZE);
 
 
 
 
 
 
 
 
1294		return min(npages, maxpages);
1295	}
1296	if (iov_iter_is_xarray(i)) {
1297		unsigned offset = (i->xarray_start + i->iov_offset) % PAGE_SIZE;
1298		int npages = DIV_ROUND_UP(offset + i->count, PAGE_SIZE);
1299		return min(npages, maxpages);
1300	}
1301	return 0;
1302}
1303EXPORT_SYMBOL(iov_iter_npages);
1304
1305const void *dup_iter(struct iov_iter *new, struct iov_iter *old, gfp_t flags)
1306{
1307	*new = *old;
 
 
 
 
 
 
1308	if (iov_iter_is_bvec(new))
1309		return new->bvec = kmemdup(new->bvec,
1310				    new->nr_segs * sizeof(struct bio_vec),
1311				    flags);
1312	else if (iov_iter_is_kvec(new) || iter_is_iovec(new))
1313		/* iovec and kvec have identical layout */
1314		return new->__iov = kmemdup(new->__iov,
1315				   new->nr_segs * sizeof(struct iovec),
1316				   flags);
1317	return NULL;
1318}
1319EXPORT_SYMBOL(dup_iter);
1320
1321static __noclone int copy_compat_iovec_from_user(struct iovec *iov,
1322		const struct iovec __user *uvec, u32 nr_segs)
1323{
1324	const struct compat_iovec __user *uiov =
1325		(const struct compat_iovec __user *)uvec;
1326	int ret = -EFAULT;
1327	u32 i;
1328
1329	if (!user_access_begin(uiov, nr_segs * sizeof(*uiov)))
1330		return -EFAULT;
1331
1332	for (i = 0; i < nr_segs; i++) {
1333		compat_uptr_t buf;
1334		compat_ssize_t len;
1335
1336		unsafe_get_user(len, &uiov[i].iov_len, uaccess_end);
1337		unsafe_get_user(buf, &uiov[i].iov_base, uaccess_end);
1338
1339		/* check for compat_size_t not fitting in compat_ssize_t .. */
1340		if (len < 0) {
1341			ret = -EINVAL;
1342			goto uaccess_end;
1343		}
1344		iov[i].iov_base = compat_ptr(buf);
1345		iov[i].iov_len = len;
1346	}
1347
1348	ret = 0;
1349uaccess_end:
1350	user_access_end();
1351	return ret;
1352}
1353
1354static __noclone int copy_iovec_from_user(struct iovec *iov,
1355		const struct iovec __user *uiov, unsigned long nr_segs)
1356{
1357	int ret = -EFAULT;
1358
1359	if (!user_access_begin(uiov, nr_segs * sizeof(*uiov)))
1360		return -EFAULT;
 
 
 
 
1361
1362	do {
1363		void __user *buf;
1364		ssize_t len;
1365
1366		unsafe_get_user(len, &uiov->iov_len, uaccess_end);
1367		unsafe_get_user(buf, &uiov->iov_base, uaccess_end);
1368
1369		/* check for size_t not fitting in ssize_t .. */
1370		if (unlikely(len < 0)) {
1371			ret = -EINVAL;
1372			goto uaccess_end;
1373		}
1374		iov->iov_base = buf;
1375		iov->iov_len = len;
1376
1377		uiov++; iov++;
1378	} while (--nr_segs);
1379
1380	ret = 0;
1381uaccess_end:
1382	user_access_end();
1383	return ret;
1384}
1385
1386struct iovec *iovec_from_user(const struct iovec __user *uvec,
1387		unsigned long nr_segs, unsigned long fast_segs,
1388		struct iovec *fast_iov, bool compat)
1389{
1390	struct iovec *iov = fast_iov;
1391	int ret;
1392
1393	/*
1394	 * SuS says "The readv() function *may* fail if the iovcnt argument was
1395	 * less than or equal to 0, or greater than {IOV_MAX}.  Linux has
1396	 * traditionally returned zero for zero segments, so...
1397	 */
1398	if (nr_segs == 0)
1399		return iov;
1400	if (nr_segs > UIO_MAXIOV)
1401		return ERR_PTR(-EINVAL);
1402	if (nr_segs > fast_segs) {
1403		iov = kmalloc_array(nr_segs, sizeof(struct iovec), GFP_KERNEL);
1404		if (!iov)
1405			return ERR_PTR(-ENOMEM);
1406	}
1407
1408	if (unlikely(compat))
1409		ret = copy_compat_iovec_from_user(iov, uvec, nr_segs);
1410	else
1411		ret = copy_iovec_from_user(iov, uvec, nr_segs);
1412	if (ret) {
1413		if (iov != fast_iov)
1414			kfree(iov);
1415		return ERR_PTR(ret);
1416	}
1417
1418	return iov;
1419}
1420
1421/*
1422 * Single segment iovec supplied by the user, import it as ITER_UBUF.
1423 */
1424static ssize_t __import_iovec_ubuf(int type, const struct iovec __user *uvec,
1425				   struct iovec **iovp, struct iov_iter *i,
1426				   bool compat)
1427{
1428	struct iovec *iov = *iovp;
1429	ssize_t ret;
1430
1431	*iovp = NULL;
1432
1433	if (compat)
1434		ret = copy_compat_iovec_from_user(iov, uvec, 1);
1435	else
1436		ret = copy_iovec_from_user(iov, uvec, 1);
1437	if (unlikely(ret))
1438		return ret;
1439
1440	ret = import_ubuf(type, iov->iov_base, iov->iov_len, i);
1441	if (unlikely(ret))
1442		return ret;
1443	return i->count;
1444}
1445
1446ssize_t __import_iovec(int type, const struct iovec __user *uvec,
1447		 unsigned nr_segs, unsigned fast_segs, struct iovec **iovp,
1448		 struct iov_iter *i, bool compat)
1449{
1450	ssize_t total_len = 0;
1451	unsigned long seg;
1452	struct iovec *iov;
1453
1454	if (nr_segs == 1)
1455		return __import_iovec_ubuf(type, uvec, iovp, i, compat);
1456
1457	iov = iovec_from_user(uvec, nr_segs, fast_segs, *iovp, compat);
1458	if (IS_ERR(iov)) {
1459		*iovp = NULL;
1460		return PTR_ERR(iov);
1461	}
1462
1463	/*
1464	 * According to the Single Unix Specification we should return EINVAL if
1465	 * an element length is < 0 when cast to ssize_t or if the total length
1466	 * would overflow the ssize_t return value of the system call.
1467	 *
1468	 * Linux caps all read/write calls to MAX_RW_COUNT, and avoids the
1469	 * overflow case.
1470	 */
1471	for (seg = 0; seg < nr_segs; seg++) {
1472		ssize_t len = (ssize_t)iov[seg].iov_len;
1473
1474		if (!access_ok(iov[seg].iov_base, len)) {
1475			if (iov != *iovp)
1476				kfree(iov);
1477			*iovp = NULL;
1478			return -EFAULT;
1479		}
1480
1481		if (len > MAX_RW_COUNT - total_len) {
1482			len = MAX_RW_COUNT - total_len;
1483			iov[seg].iov_len = len;
1484		}
1485		total_len += len;
1486	}
1487
1488	iov_iter_init(i, type, iov, nr_segs, total_len);
1489	if (iov == *iovp)
1490		*iovp = NULL;
1491	else
1492		*iovp = iov;
1493	return total_len;
1494}
1495
1496/**
1497 * import_iovec() - Copy an array of &struct iovec from userspace
1498 *     into the kernel, check that it is valid, and initialize a new
1499 *     &struct iov_iter iterator to access it.
1500 *
1501 * @type: One of %READ or %WRITE.
1502 * @uvec: Pointer to the userspace array.
1503 * @nr_segs: Number of elements in userspace array.
1504 * @fast_segs: Number of elements in @iov.
1505 * @iovp: (input and output parameter) Pointer to pointer to (usually small
1506 *     on-stack) kernel array.
1507 * @i: Pointer to iterator that will be initialized on success.
1508 *
1509 * If the array pointed to by *@iov is large enough to hold all @nr_segs,
1510 * then this function places %NULL in *@iov on return. Otherwise, a new
1511 * array will be allocated and the result placed in *@iov. This means that
1512 * the caller may call kfree() on *@iov regardless of whether the small
1513 * on-stack array was used or not (and regardless of whether this function
1514 * returns an error or not).
1515 *
1516 * Return: Negative error code on error, bytes imported on success
1517 */
1518ssize_t import_iovec(int type, const struct iovec __user *uvec,
1519		 unsigned nr_segs, unsigned fast_segs,
1520		 struct iovec **iovp, struct iov_iter *i)
1521{
1522	return __import_iovec(type, uvec, nr_segs, fast_segs, iovp, i,
1523			      in_compat_syscall());
1524}
1525EXPORT_SYMBOL(import_iovec);
1526
1527int import_ubuf(int rw, void __user *buf, size_t len, struct iov_iter *i)
 
1528{
1529	if (len > MAX_RW_COUNT)
1530		len = MAX_RW_COUNT;
1531	if (unlikely(!access_ok(buf, len)))
1532		return -EFAULT;
1533
1534	iov_iter_ubuf(i, rw, buf, len);
 
 
1535	return 0;
1536}
1537EXPORT_SYMBOL_GPL(import_ubuf);
1538
1539/**
1540 * iov_iter_restore() - Restore a &struct iov_iter to the same state as when
1541 *     iov_iter_save_state() was called.
1542 *
1543 * @i: &struct iov_iter to restore
1544 * @state: state to restore from
1545 *
1546 * Used after iov_iter_save_state() to bring restore @i, if operations may
1547 * have advanced it.
1548 *
1549 * Note: only works on ITER_IOVEC, ITER_BVEC, and ITER_KVEC
1550 */
1551void iov_iter_restore(struct iov_iter *i, struct iov_iter_state *state)
1552{
1553	if (WARN_ON_ONCE(!iov_iter_is_bvec(i) && !iter_is_iovec(i) &&
1554			 !iter_is_ubuf(i)) && !iov_iter_is_kvec(i))
1555		return;
1556	i->iov_offset = state->iov_offset;
1557	i->count = state->count;
1558	if (iter_is_ubuf(i))
1559		return;
1560	/*
1561	 * For the *vec iters, nr_segs + iov is constant - if we increment
1562	 * the vec, then we also decrement the nr_segs count. Hence we don't
1563	 * need to track both of these, just one is enough and we can deduct
1564	 * the other from that. ITER_KVEC and ITER_IOVEC are the same struct
1565	 * size, so we can just increment the iov pointer as they are unionzed.
1566	 * ITER_BVEC _may_ be the same size on some archs, but on others it is
1567	 * not. Be safe and handle it separately.
1568	 */
1569	BUILD_BUG_ON(sizeof(struct iovec) != sizeof(struct kvec));
1570	if (iov_iter_is_bvec(i))
1571		i->bvec -= state->nr_segs - i->nr_segs;
1572	else
1573		i->__iov -= state->nr_segs - i->nr_segs;
1574	i->nr_segs = state->nr_segs;
1575}
1576
1577/*
1578 * Extract a list of contiguous pages from an ITER_FOLIOQ iterator.  This does
1579 * not get references on the pages, nor does it get a pin on them.
1580 */
1581static ssize_t iov_iter_extract_folioq_pages(struct iov_iter *i,
1582					     struct page ***pages, size_t maxsize,
1583					     unsigned int maxpages,
1584					     iov_iter_extraction_t extraction_flags,
1585					     size_t *offset0)
1586{
1587	const struct folio_queue *folioq = i->folioq;
1588	struct page **p;
1589	unsigned int nr = 0;
1590	size_t extracted = 0, offset, slot = i->folioq_slot;
1591
1592	if (slot >= folioq_nr_slots(folioq)) {
1593		folioq = folioq->next;
1594		slot = 0;
1595		if (WARN_ON(i->iov_offset != 0))
1596			return -EIO;
1597	}
1598
1599	offset = i->iov_offset & ~PAGE_MASK;
1600	*offset0 = offset;
1601
1602	maxpages = want_pages_array(pages, maxsize, offset, maxpages);
1603	if (!maxpages)
1604		return -ENOMEM;
1605	p = *pages;
1606
1607	for (;;) {
1608		struct folio *folio = folioq_folio(folioq, slot);
1609		size_t offset = i->iov_offset, fsize = folioq_folio_size(folioq, slot);
1610		size_t part = PAGE_SIZE - offset % PAGE_SIZE;
1611
1612		if (offset < fsize) {
1613			part = umin(part, umin(maxsize - extracted, fsize - offset));
1614			i->count -= part;
1615			i->iov_offset += part;
1616			extracted += part;
1617
1618			p[nr++] = folio_page(folio, offset / PAGE_SIZE);
1619		}
1620
1621		if (nr >= maxpages || extracted >= maxsize)
1622			break;
1623
1624		if (i->iov_offset >= fsize) {
1625			i->iov_offset = 0;
1626			slot++;
1627			if (slot == folioq_nr_slots(folioq) && folioq->next) {
1628				folioq = folioq->next;
1629				slot = 0;
1630			}
1631		}
1632	}
1633
1634	i->folioq = folioq;
1635	i->folioq_slot = slot;
1636	return extracted;
1637}
1638
1639/*
1640 * Extract a list of contiguous pages from an ITER_XARRAY iterator.  This does not
1641 * get references on the pages, nor does it get a pin on them.
1642 */
1643static ssize_t iov_iter_extract_xarray_pages(struct iov_iter *i,
1644					     struct page ***pages, size_t maxsize,
1645					     unsigned int maxpages,
1646					     iov_iter_extraction_t extraction_flags,
1647					     size_t *offset0)
1648{
1649	struct page *page, **p;
1650	unsigned int nr = 0, offset;
1651	loff_t pos = i->xarray_start + i->iov_offset;
1652	pgoff_t index = pos >> PAGE_SHIFT;
1653	XA_STATE(xas, i->xarray, index);
1654
1655	offset = pos & ~PAGE_MASK;
1656	*offset0 = offset;
1657
1658	maxpages = want_pages_array(pages, maxsize, offset, maxpages);
1659	if (!maxpages)
1660		return -ENOMEM;
1661	p = *pages;
1662
1663	rcu_read_lock();
1664	for (page = xas_load(&xas); page; page = xas_next(&xas)) {
1665		if (xas_retry(&xas, page))
1666			continue;
1667
1668		/* Has the page moved or been split? */
1669		if (unlikely(page != xas_reload(&xas))) {
1670			xas_reset(&xas);
1671			continue;
1672		}
1673
1674		p[nr++] = find_subpage(page, xas.xa_index);
1675		if (nr == maxpages)
1676			break;
1677	}
1678	rcu_read_unlock();
1679
1680	maxsize = min_t(size_t, nr * PAGE_SIZE - offset, maxsize);
1681	iov_iter_advance(i, maxsize);
1682	return maxsize;
1683}
1684
1685/*
1686 * Extract a list of virtually contiguous pages from an ITER_BVEC iterator.
1687 * This does not get references on the pages, nor does it get a pin on them.
1688 */
1689static ssize_t iov_iter_extract_bvec_pages(struct iov_iter *i,
1690					   struct page ***pages, size_t maxsize,
1691					   unsigned int maxpages,
1692					   iov_iter_extraction_t extraction_flags,
1693					   size_t *offset0)
1694{
1695	size_t skip = i->iov_offset, size = 0;
1696	struct bvec_iter bi;
1697	int k = 0;
1698
1699	if (i->nr_segs == 0)
1700		return 0;
1701
1702	if (i->iov_offset == i->bvec->bv_len) {
1703		i->iov_offset = 0;
1704		i->nr_segs--;
1705		i->bvec++;
1706		skip = 0;
1707	}
1708	bi.bi_idx = 0;
1709	bi.bi_size = maxsize;
1710	bi.bi_bvec_done = skip;
1711
1712	maxpages = want_pages_array(pages, maxsize, skip, maxpages);
1713
1714	while (bi.bi_size && bi.bi_idx < i->nr_segs) {
1715		struct bio_vec bv = bvec_iter_bvec(i->bvec, bi);
1716
1717		/*
1718		 * The iov_iter_extract_pages interface only allows an offset
1719		 * into the first page.  Break out of the loop if we see an
1720		 * offset into subsequent pages, the caller will have to call
1721		 * iov_iter_extract_pages again for the reminder.
1722		 */
1723		if (k) {
1724			if (bv.bv_offset)
1725				break;
1726		} else {
1727			*offset0 = bv.bv_offset;
1728		}
1729
1730		(*pages)[k++] = bv.bv_page;
1731		size += bv.bv_len;
1732
1733		if (k >= maxpages)
1734			break;
1735
1736		/*
1737		 * We are done when the end of the bvec doesn't align to a page
1738		 * boundary as that would create a hole in the returned space.
1739		 * The caller will handle this with another call to
1740		 * iov_iter_extract_pages.
1741		 */
1742		if (bv.bv_offset + bv.bv_len != PAGE_SIZE)
1743			break;
1744
1745		bvec_iter_advance_single(i->bvec, &bi, bv.bv_len);
1746	}
1747
1748	iov_iter_advance(i, size);
1749	return size;
1750}
1751
1752/*
1753 * Extract a list of virtually contiguous pages from an ITER_KVEC iterator.
1754 * This does not get references on the pages, nor does it get a pin on them.
1755 */
1756static ssize_t iov_iter_extract_kvec_pages(struct iov_iter *i,
1757					   struct page ***pages, size_t maxsize,
1758					   unsigned int maxpages,
1759					   iov_iter_extraction_t extraction_flags,
1760					   size_t *offset0)
1761{
1762	struct page **p, *page;
1763	const void *kaddr;
1764	size_t skip = i->iov_offset, offset, len, size;
1765	int k;
1766
1767	for (;;) {
1768		if (i->nr_segs == 0)
1769			return 0;
1770		size = min(maxsize, i->kvec->iov_len - skip);
1771		if (size)
1772			break;
1773		i->iov_offset = 0;
1774		i->nr_segs--;
1775		i->kvec++;
1776		skip = 0;
1777	}
1778
1779	kaddr = i->kvec->iov_base + skip;
1780	offset = (unsigned long)kaddr & ~PAGE_MASK;
1781	*offset0 = offset;
1782
1783	maxpages = want_pages_array(pages, size, offset, maxpages);
1784	if (!maxpages)
1785		return -ENOMEM;
1786	p = *pages;
1787
1788	kaddr -= offset;
1789	len = offset + size;
1790	for (k = 0; k < maxpages; k++) {
1791		size_t seg = min_t(size_t, len, PAGE_SIZE);
1792
1793		if (is_vmalloc_or_module_addr(kaddr))
1794			page = vmalloc_to_page(kaddr);
1795		else
1796			page = virt_to_page(kaddr);
1797
1798		p[k] = page;
1799		len -= seg;
1800		kaddr += PAGE_SIZE;
1801	}
1802
1803	size = min_t(size_t, size, maxpages * PAGE_SIZE - offset);
1804	iov_iter_advance(i, size);
1805	return size;
1806}
1807
1808/*
1809 * Extract a list of contiguous pages from a user iterator and get a pin on
1810 * each of them.  This should only be used if the iterator is user-backed
1811 * (IOBUF/UBUF).
1812 *
1813 * It does not get refs on the pages, but the pages must be unpinned by the
1814 * caller once the transfer is complete.
1815 *
1816 * This is safe to be used where background IO/DMA *is* going to be modifying
1817 * the buffer; using a pin rather than a ref makes forces fork() to give the
1818 * child a copy of the page.
1819 */
1820static ssize_t iov_iter_extract_user_pages(struct iov_iter *i,
1821					   struct page ***pages,
1822					   size_t maxsize,
1823					   unsigned int maxpages,
1824					   iov_iter_extraction_t extraction_flags,
1825					   size_t *offset0)
1826{
1827	unsigned long addr;
1828	unsigned int gup_flags = 0;
1829	size_t offset;
1830	int res;
1831
1832	if (i->data_source == ITER_DEST)
1833		gup_flags |= FOLL_WRITE;
1834	if (extraction_flags & ITER_ALLOW_P2PDMA)
1835		gup_flags |= FOLL_PCI_P2PDMA;
1836	if (i->nofault)
1837		gup_flags |= FOLL_NOFAULT;
1838
1839	addr = first_iovec_segment(i, &maxsize);
1840	*offset0 = offset = addr % PAGE_SIZE;
1841	addr &= PAGE_MASK;
1842	maxpages = want_pages_array(pages, maxsize, offset, maxpages);
1843	if (!maxpages)
1844		return -ENOMEM;
1845	res = pin_user_pages_fast(addr, maxpages, gup_flags, *pages);
1846	if (unlikely(res <= 0))
1847		return res;
1848	maxsize = min_t(size_t, maxsize, res * PAGE_SIZE - offset);
1849	iov_iter_advance(i, maxsize);
1850	return maxsize;
1851}
1852
1853/**
1854 * iov_iter_extract_pages - Extract a list of contiguous pages from an iterator
1855 * @i: The iterator to extract from
1856 * @pages: Where to return the list of pages
1857 * @maxsize: The maximum amount of iterator to extract
1858 * @maxpages: The maximum size of the list of pages
1859 * @extraction_flags: Flags to qualify request
1860 * @offset0: Where to return the starting offset into (*@pages)[0]
1861 *
1862 * Extract a list of contiguous pages from the current point of the iterator,
1863 * advancing the iterator.  The maximum number of pages and the maximum amount
1864 * of page contents can be set.
1865 *
1866 * If *@pages is NULL, a page list will be allocated to the required size and
1867 * *@pages will be set to its base.  If *@pages is not NULL, it will be assumed
1868 * that the caller allocated a page list at least @maxpages in size and this
1869 * will be filled in.
1870 *
1871 * @extraction_flags can have ITER_ALLOW_P2PDMA set to request peer-to-peer DMA
1872 * be allowed on the pages extracted.
1873 *
1874 * The iov_iter_extract_will_pin() function can be used to query how cleanup
1875 * should be performed.
1876 *
1877 * Extra refs or pins on the pages may be obtained as follows:
1878 *
1879 *  (*) If the iterator is user-backed (ITER_IOVEC/ITER_UBUF), pins will be
1880 *      added to the pages, but refs will not be taken.
1881 *      iov_iter_extract_will_pin() will return true.
1882 *
1883 *  (*) If the iterator is ITER_KVEC, ITER_BVEC, ITER_FOLIOQ or ITER_XARRAY, the
1884 *      pages are merely listed; no extra refs or pins are obtained.
1885 *      iov_iter_extract_will_pin() will return 0.
1886 *
1887 * Note also:
1888 *
1889 *  (*) Use with ITER_DISCARD is not supported as that has no content.
1890 *
1891 * On success, the function sets *@pages to the new pagelist, if allocated, and
1892 * sets *offset0 to the offset into the first page.
1893 *
1894 * It may also return -ENOMEM and -EFAULT.
1895 */
1896ssize_t iov_iter_extract_pages(struct iov_iter *i,
1897			       struct page ***pages,
1898			       size_t maxsize,
1899			       unsigned int maxpages,
1900			       iov_iter_extraction_t extraction_flags,
1901			       size_t *offset0)
1902{
1903	maxsize = min_t(size_t, min_t(size_t, maxsize, i->count), MAX_RW_COUNT);
1904	if (!maxsize)
1905		return 0;
1906
1907	if (likely(user_backed_iter(i)))
1908		return iov_iter_extract_user_pages(i, pages, maxsize,
1909						   maxpages, extraction_flags,
1910						   offset0);
1911	if (iov_iter_is_kvec(i))
1912		return iov_iter_extract_kvec_pages(i, pages, maxsize,
1913						   maxpages, extraction_flags,
1914						   offset0);
1915	if (iov_iter_is_bvec(i))
1916		return iov_iter_extract_bvec_pages(i, pages, maxsize,
1917						   maxpages, extraction_flags,
1918						   offset0);
1919	if (iov_iter_is_folioq(i))
1920		return iov_iter_extract_folioq_pages(i, pages, maxsize,
1921						     maxpages, extraction_flags,
1922						     offset0);
1923	if (iov_iter_is_xarray(i))
1924		return iov_iter_extract_xarray_pages(i, pages, maxsize,
1925						     maxpages, extraction_flags,
1926						     offset0);
1927	return -EFAULT;
1928}
1929EXPORT_SYMBOL_GPL(iov_iter_extract_pages);