mm/filemap.h

/*
 *	linux/mm/filemap.h
 *
 * Copyright (C) 1994-1999  Linus Torvalds
 */

#ifndef __FILEMAP_H
#define __FILEMAP_H

#include <linux/types.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/highmem.h>
#include <linux/uio.h>
#include <linux/uaccess.h>

size_t
__filemap_copy_from_user_iovec_inatomic(char *vaddr,
					const struct iovec *iov,
					size_t base,
					size_t bytes);

/*
 * Copy as much as we can into the page and return the number of bytes which
 * were sucessfully copied.  If a fault is encountered then return the number of
 * bytes which were copied.
 */
static inline size_t
filemap_copy_from_user_atomic(struct page *page, unsigned long offset,
			const struct iovec *iov, unsigned long nr_segs,
			size_t base, size_t bytes)
{
	char *kaddr;
	size_t copied;

	kaddr = kmap_atomic(page, KM_USER0);
	if (likely(nr_segs == 1)) {
		int left;
		char __user *buf = iov->iov_base + base;
		left = __copy_from_user_inatomic_nocache(kaddr + offset,
							buf, bytes);
		copied = bytes - left;
	} else {
		copied = __filemap_copy_from_user_iovec_inatomic(kaddr + offset,
							iov, base, bytes);
	}
	kunmap_atomic(kaddr, KM_USER0);

	return copied;
}

/*
 * This has the same sideeffects and return value as
 * filemap_copy_from_user_atomic().
 * The difference is that it attempts to resolve faults.
 */
static inline size_t
filemap_copy_from_user(struct page *page, unsigned long offset,
			const struct iovec *iov, unsigned long nr_segs,
			 size_t base, size_t bytes)
{
	char *kaddr;
	size_t copied;

	kaddr = kmap(page);
	if (likely(nr_segs == 1)) {
		int left;
		char __user *buf = iov->iov_base + base;
		left = __copy_from_user_nocache(kaddr + offset, buf, bytes);
		copied = bytes - left;
	} else {
		copied = __filemap_copy_from_user_iovec_inatomic(kaddr + offset,
							iov, base, bytes);
	}
	kunmap(page);
	return copied;
}

static inline void
filemap_set_next_iovec(const struct iovec **iovp, unsigned long nr_segs,
						 size_t *basep, size_t bytes)
{
	if (likely(nr_segs == 1)) {
		*basep += bytes;
	} else {
		const struct iovec *iov = *iovp;
		size_t base = *basep;

		while (bytes) {
			int copy = min(bytes, iov->iov_len - base);

			bytes -= copy;
			base += copy;
			if (iov->iov_len == base) {
				iov++;
				base = 0;
			}
		}
		*iovp = iov;
		*basep = base;
	}
}
#endif