Commit 54fa39ac authored by Matthew Wilcox (Oracle)'s avatar Matthew Wilcox (Oracle) Committed by Linus Torvalds
Browse files

iomap: use mapping_seek_hole_data 

Enhance mapping_seek_hole_data() to handle partially uptodate pages and
convert the iomap seek code to call it.

Link: https://lkml.kernel.org/r/20201112212641.27837-9-willy@infradead.org


Signed-off-by: default avatarMatthew Wilcox (Oracle) <willy@infradead.org>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Dave Chinner <dchinner@redhat.com>
Cc: Hugh Dickins <hughd@google.com>
Cc: Jan Kara <jack@suse.cz>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Cc: William Kucharski <william.kucharski@oracle.com>
Cc: Yang Shi <yang.shi@linux.alibaba.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 41139aa4

fs/iomap/seek.c

+11 −114
Original line number Diff line number Diff line
@@ -10,122 +10,17 @@ 
#include <linux/pagemap.h>

#include <linux/pagevec.h>



/*

 * Seek for SEEK_DATA / SEEK_HOLE within @page, starting at @lastoff.

 * Returns true if found and updates @lastoff to the offset in file.

 */

static bool

page_seek_hole_data(struct inode *inode, struct page *page, loff_t *lastoff,

		int whence)

{

	const struct address_space_operations *ops = inode->i_mapping->a_ops;

	unsigned int bsize = i_blocksize(inode), off;

	bool seek_data = whence == SEEK_DATA;

	loff_t poff = page_offset(page);



	if (WARN_ON_ONCE(*lastoff >= poff + PAGE_SIZE))

		return false;



	if (*lastoff < poff) {

		/*

		 * Last offset smaller than the start of the page means we found

		 * a hole:

		 */

		if (whence == SEEK_HOLE)

			return true;

		*lastoff = poff;

	}



	/*

	 * Just check the page unless we can and should check block ranges:

	 */

	if (bsize == PAGE_SIZE || !ops->is_partially_uptodate)

		return PageUptodate(page) == seek_data;



	lock_page(page);

	if (unlikely(page->mapping != inode->i_mapping))

		goto out_unlock_not_found;



	for (off = 0; off < PAGE_SIZE; off += bsize) {

		if (offset_in_page(*lastoff) >= off + bsize)

			continue;

		if (ops->is_partially_uptodate(page, off, bsize) == seek_data) {

			unlock_page(page);

			return true;

		}

		*lastoff = poff + off + bsize;

	}



out_unlock_not_found:

	unlock_page(page);

	return false;

}



/*

 * Seek for SEEK_DATA / SEEK_HOLE in the page cache.

 *

 * Within unwritten extents, the page cache determines which parts are holes

 * and which are data: uptodate buffer heads count as data; everything else

 * counts as a hole.

 *

 * Returns the resulting offset on successs, and -ENOENT otherwise.

 */

static loff_t

page_cache_seek_hole_data(struct inode *inode, loff_t offset, loff_t length,

		int whence)

{

	pgoff_t index = offset >> PAGE_SHIFT;

	pgoff_t end = DIV_ROUND_UP(offset + length, PAGE_SIZE);

	loff_t lastoff = offset;

	struct pagevec pvec;



	if (length <= 0)

		return -ENOENT;



	pagevec_init(&pvec);



	do {

		unsigned nr_pages, i;



		nr_pages = pagevec_lookup_range(&pvec, inode->i_mapping, &index,

						end - 1);

		if (nr_pages == 0)

			break;



		for (i = 0; i < nr_pages; i++) {

			struct page *page = pvec.pages[i];



			if (page_seek_hole_data(inode, page, &lastoff, whence))

				goto check_range;

			lastoff = page_offset(page) + PAGE_SIZE;

		}

		pagevec_release(&pvec);

	} while (index < end);



	/* When no page at lastoff and we are not done, we found a hole. */

	if (whence != SEEK_HOLE)

		goto not_found;



check_range:

	if (lastoff < offset + length)

		goto out;

not_found:

	lastoff = -ENOENT;

out:

	pagevec_release(&pvec);

	return lastoff;

}





static loff_t

iomap_seek_hole_actor(struct inode *inode, loff_t offset, loff_t length,

iomap_seek_hole_actor(struct inode *inode, loff_t start, loff_t length,

		      void *data, struct iomap *iomap, struct iomap *srcmap)

{

	loff_t offset = start;



	switch (iomap->type) {

	case IOMAP_UNWRITTEN:

		offset = page_cache_seek_hole_data(inode, offset, length,

						   SEEK_HOLE);

		if (offset < 0)

		offset = mapping_seek_hole_data(inode->i_mapping, start,

				start + length, SEEK_HOLE);

		if (offset == start + length)

			return length;

		fallthrough;

	case IOMAP_HOLE:
@@ -164,15 +59,17 @@ iomap_seek_hole(struct inode *inode, loff_t offset, const struct iomap_ops *ops) 
EXPORT_SYMBOL_GPL(iomap_seek_hole);



static loff_t

iomap_seek_data_actor(struct inode *inode, loff_t offset, loff_t length,

iomap_seek_data_actor(struct inode *inode, loff_t start, loff_t length,

		      void *data, struct iomap *iomap, struct iomap *srcmap)

{

	loff_t offset = start;



	switch (iomap->type) {

	case IOMAP_HOLE:

		return length;

	case IOMAP_UNWRITTEN:

		offset = page_cache_seek_hole_data(inode, offset, length,

						   SEEK_DATA);

		offset = mapping_seek_hole_data(inode->i_mapping, start,

				start + length, SEEK_DATA);

		if (offset < 0)

			return length;

		fallthrough;

mm/filemap.c

+32 −5
Original line number Diff line number Diff line
@@ -2553,11 +2553,36 @@ generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter) 
}

EXPORT_SYMBOL(generic_file_read_iter);



static inline bool page_seek_match(struct page *page, bool seek_data)

static inline loff_t page_seek_hole_data(struct xa_state *xas,

		struct address_space *mapping, struct page *page,

		loff_t start, loff_t end, bool seek_data)

{

	const struct address_space_operations *ops = mapping->a_ops;

	size_t offset, bsz = i_blocksize(mapping->host);



	if (xa_is_value(page) || PageUptodate(page))

		return seek_data;

	return !seek_data;

		return seek_data ? start : end;

	if (!ops->is_partially_uptodate)

		return seek_data ? end : start;



	xas_pause(xas);

	rcu_read_unlock();

	lock_page(page);

	if (unlikely(page->mapping != mapping))

		goto unlock;



	offset = offset_in_thp(page, start) & ~(bsz - 1);



	do {

		if (ops->is_partially_uptodate(page, offset, bsz) == seek_data)

			break;

		start = (start + bsz) & ~(bsz - 1);

		offset += bsz;

	} while (offset < thp_size(page));

unlock:

	unlock_page(page);

	rcu_read_lock();

	return start;

}



static inline
@@ -2607,9 +2632,11 @@ loff_t mapping_seek_hole_data(struct address_space *mapping, loff_t start, 
			start = pos;

		}



		if (page_seek_match(page, seek_data))

		pos += seek_page_size(&xas, page);

		start = page_seek_hole_data(&xas, mapping, page, start, pos,

				seek_data);

		if (start < pos)

			goto unlock;

		start = pos + seek_page_size(&xas, page);

		if (!xa_is_value(page))

			put_page(page);

	}