xfs: Introduce a new function to find the desired type of offset from page cache

2/4

---
 fs/xfs/xfs_file.c |  203 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 203 insertions(+), 0 deletions(-)
index 98642cf..43f5e61 100644
@@ -36,6 +36,7 @@
 
 #include <linux/dcache.h>
 #include <linux/falloc.h>
+#include <linux/pagevec.h>
 
 static const struct vm_operations_struct xfs_file_vm_ops;
 

@@ -966,6 +967,208 @@ xfs_vm_page_mkwrite(
 	return block_page_mkwrite(vma, vmf, xfs_get_blocks);
 }
 
+/*
+ * This type is designed to indicate the type of offset we would like
+ * to search from page cache for either xfs_seek_data() or xfs_seek_hole().
+ */
+enum {
+	HOLE_OFF = 0,
+	DATA_OFF,
+};
+
+/*
+ * This routine is called to find out and return a data or hole offset
+ * from the page cache for unwritten extents according to the desired
+ * type for xfs_seek_data() or xfs_seek_hole().
+ *
+ * The argument offset is used to tell where we start to search from the
+ * page cache, and it will be filled with the desired type of offset if
+ * it was found, or it will keep unchanged.  map is used to figure out
+ * the end points of the range to lookup pages.
+ */
+STATIC bool
+xfs_find_get_desired_pgoff(
+	struct inode		*inode,
+	struct xfs_bmbt_irec	*map,
+	unsigned int		type,
+	loff_t			*offset)
+{
+	struct xfs_inode	*ip = XFS_I(inode);
+	struct xfs_mount	*mp = ip->i_mount;
+	struct pagevec		pvec;
+	pgoff_t			index;
+	pgoff_t			end;
+	loff_t			endoff;
+	loff_t			coff = *offset; /* current search offset */
+	bool			found = false;
+
+	pagevec_init(&pvec, 0);
+	index = XFS_FSB_TO_B(mp, XFS_B_TO_FSBT(mp, coff)) >> PAGE_CACHE_SHIFT;
+
+	/* The end offset to search for */
+	endoff = XFS_FSB_TO_B(mp, map->br_startoff + map->br_blockcount);
+	end = endoff >> PAGE_CACHE_SHIFT;
+
+	do {
+		unsigned int	i;
+		unsigned	nr_pages;
+		int		want = min_t(pgoff_t, end - index,
+					     (pgoff_t)PAGEVEC_SIZE - 1) + 1;
+
+		nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index,
+					  want);
+		/*
+		 * No page mapped into given range.  If we are searching holes
+		 * and if this is the first time we got into the loop, it means
+		 * that the given offset is landed in a hole and return ture.
+		 *
+		 * If we have already stepped through some block buffers to find
+		 * holes but those buffers are all contains data, in this case,
+		 * the current search offset is already aligned to block buffer
+		 * unit boundary and pointed to the end of the last mapped page.
+		 * If it's location is less than the end range given for search,
+		 * that means there should be a hole between them, so return the
+		 * current search offset if we are searching hole.
+		 */
+		if (nr_pages == 0) {
+			if (type == HOLE_OFF) {
+				if (coff == *offset)
+					found = true;
+				if (coff < endoff) {
+					found = true;
+					*offset = coff;
+				}
+			}
+			/* Search data but nothing found */
+			break;
+		}
+
+		/*
+		 * At least we found one page.  If this the first time we step
+		 * into the loop, and if the first page index offset is greater
+		 * than the given search offset, a hole was found, return true
+		 * if we are searching holes.
+		 */
+		if ((type == HOLE_OFF) && (coff == *offset)) {
+			if (coff < pvec.pages[0]->index << PAGE_CACHE_SHIFT) {
+				found = true;
+				break;
+			}
+		}
+
+		for (i = 0; i < nr_pages; i++) {
+			struct page		*page = pvec.pages[i];
+			struct buffer_head	*bh;
+			struct buffer_head	*head;
+			xfs_fileoff_t		last;
+
+			/*
+			 * Page index is out of range, we need to deal with
+			 * hole search condition in paticular if that is the
+			 * desired type for the lookup.
+			 * stepping into the block buffer checkup, it probably
+			 * means that there is no page mapped at all in the
+			 * specified range to search, so we found a hole.
+			 * If we have already done some block buffer checking
+			 * and found one or more data buffers before, in this
+			 * case, the coff is already updated and it point to
+			 * the end of the last data buffer, so the left range
+			 * behind it might be a hole.  In either case, we will
+			 * return the coff to indicate a hole's location because
+			 * it must be greater than or equal to the search start.
+			 */
+			if (page->index > end) {
+				if (type == HOLE_OFF && coff < endoff) {
+					*offset = coff;
+					found = true;
+				}
+				goto out;
+			}
+
+			if (!trylock_page(page))
+				goto out;
+
+			if (!page_has_buffers(page)) {
+				unlock_page(page);
+				continue;
+			}
+
+			last = XFS_B_TO_FSBT(mp,
+					     page->index << PAGE_CACHE_SHIFT);
+			bh = head = page_buffers(page);
+			do {
+				off_t		lastoff = 0;
+
+				/*
+				 * The 1st block buffer offset in current page.
+				 */
+				lastoff = XFS_FSB_TO_B(mp, last);
+				/*
+				 * An extent in XFS_EXT_UNWRITTEN has disk
+				 * blocks already mapped to it, but no data
+				 * has been committed to them yet.  If it has
+				 * dirty data in the page cache it can be
+				 * identified by having BH_Unwritten set in
+				 * each buffers.  Also, the buffer head state
+				 * might be in BH_Uptodate too if the buffer
+				 * writeback procedure was fired, we have to
+				 * check it up as well.
+				 */
+				if (buffer_unwritten(bh) ||
+				    buffer_uptodate(bh)) {
+					/*
+					 * Found a data buffer and we are
+					 * searching data, great.
+					 */
+					if (type == DATA_OFF)
+						found = true;
+				} else {
+					/*
+					 * Nothing was found and we are
+					 * searching holes, great.
+					 */
+					if (type == HOLE_OFF)
+						found = true;
+				}
+				if (found) {
+					/*
+					 * Return if we found the desired
+					 * page offset.
+					 */
+					*offset = max_t(loff_t, coff, lastoff);
+					unlock_page(page);
+					goto out;
+				}
+				/*
+				 * We either searching data but nothing was
+				 * found, or searching hole but found a data
+				 * block buffer.  In either case, probably the
+				 * next block buffer is what we are desired,
+				 * so that we need to round up the current
+				 * offset to it.
+				 */
+				coff = round_up(lastoff + 1, bh->b_size);
+				last++;
+			} while ((bh = bh->b_this_page) != head);
+			unlock_page(page);
+		}
+
+		/*
+		 * If the number of returned pages less than our desired,
+		 * there should no more pages mapped, search done.
+		 */
+		if (nr_pages < want)
+			break;
+
+		index = pvec.pages[i - 1]->index + 1;
+		pagevec_release(&pvec);
+	} while (index < end);
+
+out:
+	pagevec_release(&pvec);
+	return found;
+}
+
 STATIC loff_t
 xfs_seek_data(
 	struct file		*file,

1.7.4.1

_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
---
 fs/xfs/xfs_file.c |  203 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 203 insertions(+), 0 deletions(-)
index 98642cf..43f5e61 100644
@@ -36,6 +36,7 @@
 
 #include <linux/dcache.h>
 #include <linux/falloc.h>
+#include <linux/pagevec.h>
 
 static const struct vm_operations_struct xfs_file_vm_ops;
 

@@ -966,6 +967,208 @@ xfs_vm_page_mkwrite(
 	return block_page_mkwrite(vma, vmf, xfs_get_blocks);
 }
 
+/*
+ * This type is designed to indicate the type of offset we would like
+ * to search from page cache for either xfs_seek_data() or xfs_seek_hole().
+ */
+enum {
+	HOLE_OFF = 0,
+	DATA_OFF,
+};
+
+/*
+ * This routine is called to find out and return a data or hole offset
+ * from the page cache for unwritten extents according to the desired
+ * type for xfs_seek_data() or xfs_seek_hole().
+ *
+ * The argument offset is used to tell where we start to search from the
+ * page cache, and it will be filled with the desired type of offset if
+ * it was found, or it will keep unchanged.  map is used to figure out
+ * the end points of the range to lookup pages.
+ */
+STATIC bool
+xfs_find_get_desired_pgoff(
+	struct inode		*inode,
+	struct xfs_bmbt_irec	*map,
+	unsigned int		type,
+	loff_t			*offset)
+{
+	struct xfs_inode	*ip = XFS_I(inode);
+	struct xfs_mount	*mp = ip->i_mount;
+	struct pagevec		pvec;
+	pgoff_t			index;
+	pgoff_t			end;
+	loff_t			endoff;
+	loff_t			coff = *offset; /* current search offset */
+	bool			found = false;
+
+	pagevec_init(&pvec, 0);
+	index = XFS_FSB_TO_B(mp, XFS_B_TO_FSBT(mp, coff)) >> PAGE_CACHE_SHIFT;
+
+	/* The end offset to search for */
+	endoff = XFS_FSB_TO_B(mp, map->br_startoff + map->br_blockcount);
+	end = endoff >> PAGE_CACHE_SHIFT;
+
+	do {
+		unsigned int	i;
+		unsigned	nr_pages;
+		int		want = min_t(pgoff_t, end - index,
+					     (pgoff_t)PAGEVEC_SIZE - 1) + 1;
+
+		nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index,
+					  want);
+		/*
+		 * No page mapped into given range.  If we are searching holes
+		 * and if this is the first time we got into the loop, it means
+		 * that the given offset is landed in a hole and return ture.
+		 *
+		 * If we have already stepped through some block buffers to find
+		 * holes but those buffers are all contains data, in this case,
+		 * the current search offset is already aligned to block buffer
+		 * unit boundary and pointed to the end of the last mapped page.
+		 * If it's location is less than the end range given for search,
+		 * that means there should be a hole between them, so return the
+		 * current search offset if we are searching hole.
+		 */
+		if (nr_pages == 0) {
+			if (type == HOLE_OFF) {
+				if (coff == *offset)
+					found = true;
+				if (coff < endoff) {
+					found = true;
+					*offset = coff;
+				}
+			}
+			/* Search data but nothing found */
+			break;
+		}
+
+		/*
+		 * At least we found one page.  If this the first time we step
+		 * into the loop, and if the first page index offset is greater
+		 * than the given search offset, a hole was found, return true
+		 * if we are searching holes.
+		 */
+		if ((type == HOLE_OFF) && (coff == *offset)) {
+			if (coff < pvec.pages[0]->index << PAGE_CACHE_SHIFT) {
+				found = true;
+				break;
+			}
+		}
+
+		for (i = 0; i < nr_pages; i++) {
+			struct page		*page = pvec.pages[i];
+			struct buffer_head	*bh;
+			struct buffer_head	*head;
+			xfs_fileoff_t		last;
+
+			/*
+			 * Page index is out of range, we need to deal with
+			 * hole search condition in paticular if that is the
+			 * desired type for the lookup.
+			 * stepping into the block buffer checkup, it probably
+			 * means that there is no page mapped at all in the
+			 * specified range to search, so we found a hole.
+			 * If we have already done some block buffer checking
+			 * and found one or more data buffers before, in this
+			 * case, the coff is already updated and it point to
+			 * the end of the last data buffer, so the left range
+			 * behind it might be a hole.  In either case, we will
+			 * return the coff to indicate a hole's location because
+			 * it must be greater than or equal to the search start.
+			 */
+			if (page->index > end) {
+				if (type == HOLE_OFF && coff < endoff) {
+					*offset = coff;
+					found = true;
+				}
+				goto out;
+			}
+
+			if (!trylock_page(page))
+				goto out;
+
+			if (!page_has_buffers(page)) {
+				unlock_page(page);
+				continue;
+			}
+
+			last = XFS_B_TO_FSBT(mp,
+					     page->index << PAGE_CACHE_SHIFT);
+			bh = head = page_buffers(page);
+			do {
+				off_t		lastoff = 0;
+
+				/*
+				 * The 1st block buffer offset in current page.
+				 */
+				lastoff = XFS_FSB_TO_B(mp, last);
+				/*
+				 * An extent in XFS_EXT_UNWRITTEN has disk
+				 * blocks already mapped to it, but no data
+				 * has been committed to them yet.  If it has
+				 * dirty data in the page cache it can be
+				 * identified by having BH_Unwritten set in
+				 * each buffers.  Also, the buffer head state
+				 * might be in BH_Uptodate too if the buffer
+				 * writeback procedure was fired, we have to
+				 * check it up as well.
+				 */
+				if (buffer_unwritten(bh) ||
+				    buffer_uptodate(bh)) {
+					/*
+					 * Found a data buffer and we are
+					 * searching data, great.
+					 */
+					if (type == DATA_OFF)
+						found = true;
+				} else {
+					/*
+					 * Nothing was found and we are
+					 * searching holes, great.
+					 */
+					if (type == HOLE_OFF)
+						found = true;
+				}
+				if (found) {
+					/*
+					 * Return if we found the desired
+					 * page offset.
+					 */
+					*offset = max_t(loff_t, coff, lastoff);
+					unlock_page(page);
+					goto out;
+				}
+				/*
+				 * We either searching data but nothing was
+				 * found, or searching hole but found a data
+				 * block buffer.  In either case, probably the
+				 * next block buffer is what we are desired,
+				 * so that we need to round up the current
+				 * offset to it.
+				 */
+				coff = round_up(lastoff + 1, bh->b_size);
+				last++;

+			} while ((bh = bh->b_this_page) != head);
+			unlock_page(page);
+		}
+
+		/*
+		 * If the number of returned pages less than our desired,
+		 * there should no more pages mapped, search done.
+		 */
+		if (nr_pages < want)
+			break;

+
+		index = pvec.pages[i - 1]->index + 1;
+		pagevec_release(&pvec);
+	} while (index < end);
+
+out:
+	pagevec_release(&pvec);
+	return found;
+}
+
 STATIC loff_t
 xfs_seek_data(
 	struct file		*file,

---
 fs/xfs/xfs_file.c |  208 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 208 insertions(+), 0 deletions(-)
index 98642cf..69965a4 100644
@@ -36,6 +36,7 @@
 
 #include <linux/dcache.h>
 #include <linux/falloc.h>
+#include <linux/pagevec.h>
 
 static const struct vm_operations_struct xfs_file_vm_ops;
 

@@ -966,6 +967,213 @@ xfs_vm_page_mkwrite(
 	return block_page_mkwrite(vma, vmf, xfs_get_blocks);
 }
 
+/*
+ * This type is designed to indicate the type of offset we would like
+ * to search from page cache for either xfs_seek_data() or xfs_seek_hole().
+ */
+enum {
+	HOLE_OFF = 0,
+	DATA_OFF,
+};
+
+/*
+ * This routine is called to find out and return a data or hole offset
+ * from the page cache for unwritten extents according to the desired
+ * type for xfs_seek_data() or xfs_seek_hole().
+ *
+ * The argument offset is used to tell where we start to search from the
+ * page cache, and it will be filled with the desired type of offset if
+ * it was found, or it will keep unchanged.  map is used to figure out
+ * the end points of the range to lookup pages.
+ */
+STATIC bool
+xfs_find_get_desired_pgoff(
+	struct inode		*inode,
+	struct xfs_bmbt_irec	*map,
+	unsigned int		type,
+	loff_t			*offset)
+{
+	struct xfs_inode	*ip = XFS_I(inode);
+	struct xfs_mount	*mp = ip->i_mount;
+	struct pagevec		pvec;
+	pgoff_t			index;
+	pgoff_t			end;
+	loff_t			endoff;
+	loff_t			coff = *offset; /* current search offset */
+	bool			found = false;
+
+	pagevec_init(&pvec, 0);
+	index = XFS_FSB_TO_B(mp, XFS_B_TO_FSBT(mp, coff)) >> PAGE_CACHE_SHIFT;
+
+	/* The end offset to search for */
+	endoff = XFS_FSB_TO_B(mp, map->br_startoff + map->br_blockcount);
+	end = endoff >> PAGE_CACHE_SHIFT;
+
+	do {
+		unsigned int	i;
+		unsigned	nr_pages;
+		int		want = min_t(pgoff_t, end - index,
+					     (pgoff_t)PAGEVEC_SIZE - 1) + 1;
+
+		nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index,
+					  want);
+		/*
+		 * No page mapped into given range.  If we are searching holes
+		 * and if this is the first time we got into the loop, it means
+		 * that the given offset is landed in a hole and return ture.
+		 *
+		 * If we have already stepped through some block buffers to find
+		 * holes but those buffers are all contains data, in this case,
+		 * the current search offset is already aligned to block buffer
+		 * unit boundary and pointed to the end of the last mapped page.
+		 * If it's location is less than the end range given for search,
+		 * that means there should be a hole between them, so return the
+		 * current search offset if we are searching hole.
+		 */
+		if (nr_pages == 0) {
+			if (type == HOLE_OFF) {
+				if (coff == *offset)
+					found = true;
+				if (coff < endoff) {
+					found = true;
+					*offset = coff;
+				}
+			}
+			/* Search data but nothing found */
+			break;
+		}
+
+		/*
+		 * At least we found one page.  If this the first time we step
+		 * into the loop, and if the first page index offset is greater
+		 * than the given search offset, a hole was found, return true
+		 * if we are searching holes.
+		 */
+		if ((type == HOLE_OFF) && (coff == *offset)) {
+			if (coff < pvec.pages[0]->index << PAGE_CACHE_SHIFT) {
+				found = true;
+				break;
+			}
+		}
+
+		for (i = 0; i < nr_pages; i++) {
+			struct page		*page = pvec.pages[i];
+			struct buffer_head	*bh;
+			struct buffer_head	*head;
+			xfs_fileoff_t		last;
+
+			/*
+			 * Page index is out of range, we need to deal with
+			 * hole search condition in paticular if that is the
+			 * desired type for the lookup.
+			 * stepping into the block buffer checkup, it probably
+			 * means that there is no page mapped at all in the
+			 * specified range to search, so we found a hole.
+			 * If we have already done some block buffer checking
+			 * and found one or more data buffers before, in this
+			 * case, the coff is already updated and it point to
+			 * the end of the last data buffer, so the left range
+			 * behind it might be a hole.  In either case, we will
+			 * return the coff to indicate a hole's location because
+			 * it must be greater than or equal to the search start.
+			 */
+			if (page->index > end) {
+				if (type == HOLE_OFF && coff < endoff) {
+					*offset = coff;
+					found = true;
+				}
+				goto out;
+			}
+
+			if (!trylock_page(page))
+				goto out;
+
+			if (!page_has_buffers(page)) {
+				unlock_page(page);
+				continue;
+			}
+
+			last = XFS_B_TO_FSBT(mp,
+					     page->index << PAGE_CACHE_SHIFT);
+			bh = head = page_buffers(page);
+			do {
+				off_t		lastoff = 0;
+
+				/*
+				 * The 1st block buffer offset in current page.
+				 */
+				lastoff = XFS_FSB_TO_B(mp, last);
+				/*
+				 * An extent in XFS_EXT_UNWRITTEN has disk
+				 * blocks already mapped to it, but no data
+				 * has been committed to them yet.  If it has
+				 * dirty data in the page cache it can be
+				 * identified by having BH_Unwritten set in
+				 * each buffers.  Also, the buffer head state
+				 * might be in BH_Uptodate too if the buffer
+				 * writeback procedure was fired, we have to
+				 * check it up as well.
+				 */
+				if (buffer_unwritten(bh) ||
+				    buffer_uptodate(bh)) {
+					/*
+					 * Found a data buffer and we are
+					 * searching data, great.
+					 */
+					if (type == DATA_OFF)
+						found = true;
+				} else {
+					/*
+					 * Nothing was found and we are
+					 * searching holes, great.
+					 */
+					if (type == HOLE_OFF)
+						found = true;
+				}
+				if (found) {
+					/*
+					 * Return if we found the desired
+					 * page offset.
+					 */
+					*offset = max_t(loff_t, coff, lastoff);
+					unlock_page(page);
+					goto out;
+				}
+				/*
+				 * We either searching data but nothing was
+				 * found, or searching hole but found a data
+				 * block buffer.  In either case, probably the
+				 * next block buffer is what we are desired,
+				 * so that we need to round up the current
+				 * offset to it.
+				 */
+				coff = round_up(lastoff + 1, bh->b_size);
+				last++;
+			} while ((bh = bh->b_this_page) != head);
+			unlock_page(page);
+		}
+
+		/*
+		 * If the number of returned pages less than our desired,
+		 * there should no more pages mapped, search done.
+		 */
+		if (nr_pages < want) {
+			if (type == HOLE_OFF) {
+				*offset = coff;
+				found = true;
+			}
+			break;
+		}
+
+		index = pvec.pages[i - 1]->index + 1;
+		pagevec_release(&pvec);
+	} while (index < end);
+
+out:
+	pagevec_release(&pvec);
+	return found;
+}
+
 STATIC loff_t
 xfs_seek_data(
 	struct file		*file,

1.7.4.1

_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
+		if (nr_pages == 0) {
+			if (type == HOLE_OFF) {
+				if (coff == *offset)
+					found = true;

+				if (coff<  endoff) {
+					found = true;
+					*offset = coff;
+				}
+			}

+        if (nr_pages == 0) {
+            if (type == HOLE_OFF) {
+                if (coff == *offset)
+                    found = true;

+                if (coff<  endoff) {
+                    found = true;
+                    *offset = coff;
+                }
+            }

+            /*
+             * Page index is out of range, we need to deal with
+             * hole search condition in paticular if that is the
+             * desired type for the lookup.
+             * stepping into the block buffer checkup, it probably
+             * means that there is no page mapped at all in the
+             * specified range to search, so we found a hole.
+             * If we have already done some block buffer checking
+             * and found one or more data buffers before, in this
+             * case, the coff is already updated and it point to
+             * the end of the last data buffer, so the left range
+             * behind it might be a hole.  In either case, we will
+             * return the coff to indicate a hole's location because
+             * it must be greater than or equal to the search start.
+             */

+STATIC bool
+xfs_find_get_desired_pgoff(
+	struct inode		*inode,
+	struct xfs_bmbt_irec	*map,
+	unsigned int		type,
+	loff_t			*offset)
+{
+	struct xfs_inode	*ip = XFS_I(inode);

+	struct xfs_mount	*mp = ip->i_mount;
+	struct pagevec		pvec;
+	pgoff_t			index;
+	pgoff_t			end;
+	loff_t			endoff;
+	loff_t			coff = *offset; /* current search offset */
+	bool			found = false;
+
+	pagevec_init(&pvec, 0);
+	index = XFS_FSB_TO_B(mp, XFS_B_TO_FSBT(mp, coff)) >> PAGE_CACHE_SHIFT;

	index = ((coff >> 12) << 12) >> 12
	index = ((coff >> 9) << 9) >> 12
	      = coff >> 12
	index = coff >> PAGE_CACHE_SHIFT;
+
+	/* The end offset to search for */
+	endoff = XFS_FSB_TO_B(mp, map->br_startoff + map->br_blockcount);
+	end = endoff >> PAGE_CACHE_SHIFT;

	endoff = (0 + 2) << 12 = 8192
	end = 8192 >> 12 = 2
+	do {
+		unsigned int	i;
+		unsigned	nr_pages;
+		int		want = min_t(pgoff_t, end - index,
+					     (pgoff_t)PAGEVEC_SIZE - 1) + 1;

	want = min(2 - 0, 13) + 1
	     = 3.
+		nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index,
+					  want);
+		/*
+		 * No page mapped into given range.  If we are searching holes
+		 * and if this is the first time we got into the loop, it means
+		 * that the given offset is landed in a hole and return ture.

+		 *
+		 * If we have already stepped through some block buffers to find
+		 * holes but those buffers are all contains data, in this case,
+		 * the current search offset is already aligned to block buffer
+		 * unit boundary and pointed to the end of the last mapped page.
+		 * If it's location is less than the end range given for search,
+		 * that means there should be a hole between them, so return the
+		 * current search offset if we are searching hole.
+		 */
+		if (nr_pages == 0) {
+			if (type == HOLE_OFF) {

+				if (coff == *offset)
+					found = true;
+				if (coff < endoff) {
+					found = true;
+					*offset = coff;
+				}
+			}
+			/* Search data but nothing found */
+			break;
+		}

			/* data search found nothing */
			if (type == DATA_OFF)
				break;

			ASSERT(type == HOLE_OFF);
			if (coff == *offset || coff < endoff) {
				found = true;
				*offset = coff;
			}
			break;
+
+		/*
+		 * At least we found one page.  If this the first time we step
+		 * into the loop, and if the first page index offset is greater
+		 * than the given search offset, a hole was found, return true
+		 * if we are searching holes.
+		 */
+		if ((type == HOLE_OFF) && (coff == *offset)) {

+			if (coff < pvec.pages[0]->index << PAGE_CACHE_SHIFT) {

+				found = true;
+				break;
+			}
+		}

		if (type == HOLE_OFF && coff == *offset &&
		    coff < page_offset(pvec.pages[0])) {
			found = true;
			break;
		}
+
+		for (i = 0; i < nr_pages; i++) {
+			struct page		*page = pvec.pages[i];
+			struct buffer_head	*bh;
+			struct buffer_head	*head;
+			xfs_fileoff_t		last;

+
+			/*
+			 * Page index is out of range, we need to deal with
+			 * hole search condition in paticular if that is the
+			 * desired type for the lookup.
+			 * stepping into the block buffer checkup, it probably

+			 * means that there is no page mapped at all in the
+			 * specified range to search, so we found a hole.
+			 * If we have already done some block buffer checking
+			 * and found one or more data buffers before, in this
+			 * case, the coff is already updated and it point to
+			 * the end of the last data buffer, so the left range
+			 * behind it might be a hole.  In either case, we will
+			 * return the coff to indicate a hole's location because
+			 * it must be greater than or equal to the search start.
+			 */

+			if (page->index > end) {
+				if (type == HOLE_OFF && coff < endoff) {
+					*offset = coff;
+					found = true;
+				}
+				goto out;
+			}
+
+			if (!trylock_page(page))
+				goto out;

+
+			if (!page_has_buffers(page)) {
+				unlock_page(page);
+				continue;
+			}
+
+			last = XFS_B_TO_FSBT(mp,
+					     page->index << PAGE_CACHE_SHIFT);

			last = page_offset(page);
+			bh = head = page_buffers(page);
+			do {
+				off_t		lastoff = 0;

				off_t	lastoff = last;
+				/*
+				 * An extent in XFS_EXT_UNWRITTEN has disk
+				 * blocks already mapped to it, but no data
+				 * has been committed to them yet.  If it has
+				 * dirty data in the page cache it can be
+				 * identified by having BH_Unwritten set in
+				 * each buffers.  Also, the buffer head state
+				 * might be in BH_Uptodate too if the buffer
+				 * writeback procedure was fired, we have to
+				 * check it up as well.
+				 */

+				if (buffer_unwritten(bh) ||
+				    buffer_uptodate(bh)) {
+					/*
+					 * Found a data buffer and we are
+					 * searching data, great.
+					 */
+					if (type == DATA_OFF)
+						found = true;
 
 
+				} else {
+					/*
+					 * Nothing was found and we are
+					 * searching holes, great.

+					 */
+					if (type == HOLE_OFF)
+						found = true;
+				}
+				if (found) {
+					/*
+					 * Return if we found the desired
+					 * page offset.
+					 */
+					*offset = max_t(loff_t, coff, lastoff);

+					unlock_page(page);
+					goto out;
+				}
+				/*
+				 * We either searching data but nothing was
+				 * found, or searching hole but found a data
+				 * block buffer.  In either case, probably the
+				 * next block buffer is what we are desired,
+				 * so that we need to round up the current
+				 * offset to it.
+				 */
+				coff = round_up(lastoff + 1, bh->b_size);

				coff = lastoff + bh->b_size;
+				last++;

				last += bh->b_size;
				last = offset
				do {
					lastoff = last;
					....
					if (found)
						return lastoff
					...
					coff = lastoff + bh->b_size;
					last += bh->b_size
				} while()
				coff = offset
				do {
					....
					if (found)
						return coff
					...
					coff += bh->b_size
				} while()
+			} while ((bh = bh->b_this_page) != head);
+			unlock_page(page);
+		}
+
+		/*
+		 * If the number of returned pages less than our desired,
+		 * there should no more pages mapped, search done.
+		 */
+		if (nr_pages < want)
+			break;
+
+		index = pvec.pages[i - 1]->index + 1;
+		pagevec_release(&pvec);
+	} while (index < end);
+
+out:
+	pagevec_release(&pvec);
+	return found;
+}
+
 STATIC loff_t
 xfs_seek_data(
 	struct file		*file,

1.7.4.1

_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs

-- 
This message has been scanned for viruses and
dangerous content by MailScanner, and is
believed to be clean.
Dave Chinner
[email protected]

_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
+STATIC bool
+xfs_find_get_desired_pgoff(
+	struct inode		*inode,
+	struct xfs_bmbt_irec	*map,
+	unsigned int		type,
+	loff_t			*offset)
+{
+	struct xfs_inode	*ip = XFS_I(inode);

+	struct xfs_mount	*mp = ip->i_mount;
+	struct pagevec		pvec;
+	pgoff_t			index;
+	pgoff_t			end;
+	loff_t			endoff;
+	loff_t			coff = *offset; /* current search offset */
+	bool			found = false;
+
+	pagevec_init(&pvec, 0);
+	index = XFS_FSB_TO_B(mp, XFS_B_TO_FSBT(mp, coff)) >> PAGE_CACHE_SHIFT;

	index = ((coff >> 12) << 12) >> 12
	index = ((coff >> 9) << 9) >> 12
	      = coff >> 12
	index = coff >> PAGE_CACHE_SHIFT;
+
+	/* The end offset to search for */
+	endoff = XFS_FSB_TO_B(mp, map->br_startoff + map->br_blockcount);
+	end = endoff >> PAGE_CACHE_SHIFT;

	endoff = (0 + 2) << 12 = 8192
	end = 8192 >> 12 = 2
+	do {
+		unsigned int	i;
+		unsigned	nr_pages;
+		int		want = min_t(pgoff_t, end - index,
+					     (pgoff_t)PAGEVEC_SIZE - 1) + 1;

	want = min(2 - 0, 13) + 1
	     = 3.
+		nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index,
+					  want);
+		/*
+		 * No page mapped into given range.  If we are searching holes
+		 * and if this is the first time we got into the loop, it means
+		 * that the given offset is landed in a hole and return ture.

+		 *
+		 * If we have already stepped through some block buffers to find
+		 * holes but those buffers are all contains data, in this case,
+		 * the current search offset is already aligned to block buffer
+		 * unit boundary and pointed to the end of the last mapped page.
+		 * If it's location is less than the end range given for search,
+		 * that means there should be a hole between them, so return the
+		 * current search offset if we are searching hole.
+		 */
+		if (nr_pages == 0) {
+			if (type == HOLE_OFF) {

+				if (coff == *offset)
+					found = true;
+				if (coff < endoff) {
+					found = true;
+					*offset = coff;
+				}
+			}
+			/* Search data but nothing found */
+			break;
+		}

			/* data search found nothing */
			if (type == DATA_OFF)
				break;
			ASSERT(type == HOLE_OFF);
			if (coff == *offset || coff < endoff) {
				found = true;
				*offset = coff;
			}
			break;
+
+		/*
+		 * At least we found one page.  If this the first time we step
+		 * into the loop, and if the first page index offset is greater
+		 * than the given search offset, a hole was found, return true
+		 * if we are searching holes.
+		 */
+		if ((type == HOLE_OFF) && (coff == *offset)) {

+			if (coff < pvec.pages[0]->index << PAGE_CACHE_SHIFT) {

+				found = true;
+				break;
+			}
+		}

		if (type == HOLE_OFF && coff == *offset &&
		    coff < page_offset(pvec.pages[0])) {
			found = true;
			break;
		}
+
+		for (i = 0; i < nr_pages; i++) {
+			struct page		*page = pvec.pages[i];
+			struct buffer_head	*bh;
+			struct buffer_head	*head;
+			xfs_fileoff_t		last;

+
+			/*
+			 * Page index is out of range, we need to deal with
+			 * hole search condition in paticular if that is the
+			 * desired type for the lookup.
+			 * stepping into the block buffer checkup, it probably

+			 * means that there is no page mapped at all in the
+			 * specified range to search, so we found a hole.
+			 * If we have already done some block buffer checking
+			 * and found one or more data buffers before, in this
+			 * case, the coff is already updated and it point to
+			 * the end of the last data buffer, so the left range
+			 * behind it might be a hole.  In either case, we will
+			 * return the coff to indicate a hole's location because
+			 * it must be greater than or equal to the search start.
+			 */

+			if (page->index > end) {
+				if (type == HOLE_OFF && coff < endoff) {
+					*offset = coff;
+					found = true;
+				}
+				goto out;
+			}
+
+			if (!trylock_page(page))
+				goto out;

+
+			if (!page_has_buffers(page)) {
+				unlock_page(page);
+				continue;
+			}
+
+			last = XFS_B_TO_FSBT(mp,
+					     page->index << PAGE_CACHE_SHIFT);

			last = page_offset(page);
+			bh = head = page_buffers(page);
+			do {
+				off_t		lastoff = 0;

				off_t	lastoff = last;
+				/*
+				 * An extent in XFS_EXT_UNWRITTEN has disk
+				 * blocks already mapped to it, but no data
+				 * has been committed to them yet.  If it has
+				 * dirty data in the page cache it can be
+				 * identified by having BH_Unwritten set in
+				 * each buffers.  Also, the buffer head state
+				 * might be in BH_Uptodate too if the buffer
+				 * writeback procedure was fired, we have to
+				 * check it up as well.
+				 */

+				if (buffer_unwritten(bh) ||
+				    buffer_uptodate(bh)) {
+					/*
+					 * Found a data buffer and we are
+					 * searching data, great.
+					 */
+					if (type == DATA_OFF)
+						found = true;

+				} else {
+					/*
+					 * Nothing was found and we are
+					 * searching holes, great.

+					 */
+					if (type == HOLE_OFF)
+						found = true;
+				}
+				if (found) {
+					/*
+					 * Return if we found the desired
+					 * page offset.
+					 */
+					*offset = max_t(loff_t, coff, lastoff);

+					unlock_page(page);
+					goto out;
+				}
+				/*
+				 * We either searching data but nothing was
+				 * found, or searching hole but found a data
+				 * block buffer.  In either case, probably the
+				 * next block buffer is what we are desired,
+				 * so that we need to round up the current
+				 * offset to it.
+				 */
+				coff = round_up(lastoff + 1, bh->b_size);

				coff = lastoff + bh->b_size;
+				last++;

				last += bh->b_size;
				last = offset
				do {
					lastoff = last;
					....
					if (found)
						return lastoff
					...
					coff = lastoff + bh->b_size;
					last += bh->b_size
				} while()
				coff = offset
				do {
					....
					if (found)
						return coff
					...
					coff += bh->b_size
				} while()
+			} while ((bh = bh->b_this_page) != head);
+			unlock_page(page);
+		}
+
+		/*
+		 * If the number of returned pages less than our desired,
+		 * there should no more pages mapped, search done.
+		 */
+		if (nr_pages < want)
+			break;
+
+		index = pvec.pages[i - 1]->index + 1;
+		pagevec_release(&pvec);
+	} while (index < end);
+
+out:
+	pagevec_release(&pvec);

+	return found;
+}
+
  STATIC loff_t
  xfs_seek_data(
  	struct file		*file,

1.7.4.1
This message has been scanned for viruses and
dangerous content by MailScanner, and is
believed to be clean.

xfs: Introduce a new function to find the desired type of offset from page cache

Jeff Liu

Jeff Liu

Jeff Liu

Mark Tinguely

Jeff Liu

Dave Chinner

Jie Liu