Initially, find_lock_entries() was being passed in the start offset as a
value. That left the calculation of the offset to the callers. This led
to complexity in the callers trying to keep track of the index.
Now find_lock_entires() takes in a pointer to the start offset and
updates the value to be directly after the last entry found. If no entry is
found, the offset is not changed. This gets rid of multiple hacky
calculations that kept track of the start offset.
Signed-off-by: Vishal Moola (Oracle) <[email protected]>
---
mm/filemap.c | 17 ++++++++++++++---
mm/internal.h | 2 +-
mm/shmem.c | 8 ++------
mm/truncate.c | 12 ++++--------
4 files changed, 21 insertions(+), 18 deletions(-)
diff --git a/mm/filemap.c b/mm/filemap.c
index 08341616ae7a..e95500b07ee9 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -2084,17 +2084,19 @@ unsigned find_get_entries(struct address_space *mapping, pgoff_t start,
* locked or folios under writeback.
*
* Return: The number of entries which were found.
+ * Also updates @start to be positioned after the last found entry
*/
-unsigned find_lock_entries(struct address_space *mapping, pgoff_t start,
+unsigned find_lock_entries(struct address_space *mapping, pgoff_t *start,
pgoff_t end, struct folio_batch *fbatch, pgoff_t *indices)
{
- XA_STATE(xas, &mapping->i_pages, start);
+ XA_STATE(xas, &mapping->i_pages, *start);
+ unsigned long nr;
struct folio *folio;
rcu_read_lock();
while ((folio = find_get_entry(&xas, end, XA_PRESENT))) {
if (!xa_is_value(folio)) {
- if (folio->index < start)
+ if (folio->index < *start)
goto put;
if (folio->index + folio_nr_pages(folio) - 1 > end)
goto put;
@@ -2116,7 +2118,16 @@ unsigned find_lock_entries(struct address_space *mapping, pgoff_t start,
folio_put(folio);
}
rcu_read_unlock();
+ nr = folio_batch_count(fbatch);
+
+ if (nr) {
+ folio = fbatch->folios[nr - 1];
+ nr = folio_nr_pages(folio);
+ if (folio_test_hugetlb(folio))
+ nr = 1;
+ *start = folio->index + nr;
+ }
return folio_batch_count(fbatch);
}
diff --git a/mm/internal.h b/mm/internal.h
index 6b7ef495b56d..c504ac7267e0 100644
--- a/mm/internal.h
+++ b/mm/internal.h
@@ -106,7 +106,7 @@ static inline void force_page_cache_readahead(struct address_space *mapping,
force_page_cache_ra(&ractl, nr_to_read);
}
-unsigned find_lock_entries(struct address_space *mapping, pgoff_t start,
+unsigned find_lock_entries(struct address_space *mapping, pgoff_t *start,
pgoff_t end, struct folio_batch *fbatch, pgoff_t *indices);
unsigned find_get_entries(struct address_space *mapping, pgoff_t start,
pgoff_t end, struct folio_batch *fbatch, pgoff_t *indices);
diff --git a/mm/shmem.c b/mm/shmem.c
index 86214d48dd09..ab4f6dfcf6bb 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -922,21 +922,18 @@ static void shmem_undo_range(struct inode *inode, loff_t lstart, loff_t lend,
folio_batch_init(&fbatch);
index = start;
- while (index < end && find_lock_entries(mapping, index, end - 1,
+ while (index < end && find_lock_entries(mapping, &index, end - 1,
&fbatch, indices)) {
for (i = 0; i < folio_batch_count(&fbatch); i++) {
folio = fbatch.folios[i];
- index = indices[i];
-
if (xa_is_value(folio)) {
if (unfalloc)
continue;
nr_swaps_freed += !shmem_free_swap(mapping,
- index, folio);
+ folio->index, folio);
continue;
}
- index += folio_nr_pages(folio) - 1;
if (!unfalloc || !folio_test_uptodate(folio))
truncate_inode_folio(mapping, folio);
@@ -945,7 +942,6 @@ static void shmem_undo_range(struct inode *inode, loff_t lstart, loff_t lend,
folio_batch_remove_exceptionals(&fbatch);
folio_batch_release(&fbatch);
cond_resched();
- index++;
}
same_folio = (lstart >> PAGE_SHIFT) == (lend >> PAGE_SHIFT);
diff --git a/mm/truncate.c b/mm/truncate.c
index c0be77e5c008..b0bd63b2359f 100644
--- a/mm/truncate.c
+++ b/mm/truncate.c
@@ -361,9 +361,8 @@ void truncate_inode_pages_range(struct address_space *mapping,
folio_batch_init(&fbatch);
index = start;
- while (index < end && find_lock_entries(mapping, index, end - 1,
+ while (index < end && find_lock_entries(mapping, &index, end - 1,
&fbatch, indices)) {
- index = indices[folio_batch_count(&fbatch) - 1] + 1;
truncate_folio_batch_exceptionals(mapping, &fbatch, indices);
for (i = 0; i < folio_batch_count(&fbatch); i++)
truncate_cleanup_folio(fbatch.folios[i]);
@@ -510,20 +509,18 @@ unsigned long invalidate_mapping_pagevec(struct address_space *mapping,
int i;
folio_batch_init(&fbatch);
- while (find_lock_entries(mapping, index, end, &fbatch, indices)) {
+ while (find_lock_entries(mapping, &index, end, &fbatch, indices)) {
for (i = 0; i < folio_batch_count(&fbatch); i++) {
struct folio *folio = fbatch.folios[i];
/* We rely upon deletion not changing folio->index */
- index = indices[i];
if (xa_is_value(folio)) {
count += invalidate_exceptional_entry(mapping,
- index,
- folio);
+ folio->index,
+ folio);
continue;
}
- index += folio_nr_pages(folio) - 1;
ret = mapping_evict_folio(mapping, folio);
folio_unlock(folio);
@@ -542,7 +539,6 @@ unsigned long invalidate_mapping_pagevec(struct address_space *mapping,
folio_batch_remove_exceptionals(&fbatch);
folio_batch_release(&fbatch);
cond_resched();
- index++;
}
return count;
}
--
2.36.1
On Tue, Oct 11, 2022 at 02:56:31PM -0700, Vishal Moola (Oracle) wrote:
> @@ -2116,7 +2118,16 @@ unsigned find_lock_entries(struct address_space *mapping, pgoff_t start,
> folio_put(folio);
> }
> rcu_read_unlock();
> + nr = folio_batch_count(fbatch);
> +
> + if (nr) {
> + folio = fbatch->folios[nr - 1];
> + nr = folio_nr_pages(folio);
>
> + if (folio_test_hugetlb(folio))
> + nr = 1;
> + *start = folio->index + nr;
> + }
Hmm ... this is going to go wrong if the folio is actually a shadow
entry, isn't it?
> +++ b/mm/shmem.c
> @@ -922,21 +922,18 @@ static void shmem_undo_range(struct inode *inode, loff_t lstart, loff_t lend,
>
> folio_batch_init(&fbatch);
> index = start;
> - while (index < end && find_lock_entries(mapping, index, end - 1,
> + while (index < end && find_lock_entries(mapping, &index, end - 1,
> &fbatch, indices)) {
> for (i = 0; i < folio_batch_count(&fbatch); i++) {
> folio = fbatch.folios[i];
>
> - index = indices[i];
> -
> if (xa_is_value(folio)) {
> if (unfalloc)
> continue;
> nr_swaps_freed += !shmem_free_swap(mapping,
> - index, folio);
> + folio->index, folio);
We know this is a value entry, so we definitely can't look at
folio->index. This should probably be:
+ indices[i], folio);
> @@ -510,20 +509,18 @@ unsigned long invalidate_mapping_pagevec(struct address_space *mapping,
> int i;
>
> folio_batch_init(&fbatch);
> - while (find_lock_entries(mapping, index, end, &fbatch, indices)) {
> + while (find_lock_entries(mapping, &index, end, &fbatch, indices)) {
> for (i = 0; i < folio_batch_count(&fbatch); i++) {
> struct folio *folio = fbatch.folios[i];
>
> /* We rely upon deletion not changing folio->index */
> - index = indices[i];
>
> if (xa_is_value(folio)) {
> count += invalidate_exceptional_entry(mapping,
> - index,
> - folio);
> + folio->index,
> + folio);
Same here. I'd fix the indent while you're at it to get more on that
second line and not need a third line.
On Tue, Oct 11, 2022 at 7:10 PM Matthew Wilcox <[email protected]> wrote:
>
> On Tue, Oct 11, 2022 at 02:56:31PM -0700, Vishal Moola (Oracle) wrote:
> > @@ -2116,7 +2118,16 @@ unsigned find_lock_entries(struct address_space *mapping, pgoff_t start,
> > folio_put(folio);
> > }
> > rcu_read_unlock();
> > + nr = folio_batch_count(fbatch);
> > +
> > + if (nr) {
> > + folio = fbatch->folios[nr - 1];
> > + nr = folio_nr_pages(folio);
> >
> > + if (folio_test_hugetlb(folio))
> > + nr = 1;
> > + *start = folio->index + nr;
> > + }
>
> Hmm ... this is going to go wrong if the folio is actually a shadow
> entry, isn't it?
You're right! I missed that.
> > +++ b/mm/shmem.c
> > @@ -922,21 +922,18 @@ static void shmem_undo_range(struct inode *inode, loff_t lstart, loff_t lend,
> >
> > folio_batch_init(&fbatch);
> > index = start;
> > - while (index < end && find_lock_entries(mapping, index, end - 1,
> > + while (index < end && find_lock_entries(mapping, &index, end - 1,
> > &fbatch, indices)) {
> > for (i = 0; i < folio_batch_count(&fbatch); i++) {
> > folio = fbatch.folios[i];
> >
> > - index = indices[i];
> > -
> > if (xa_is_value(folio)) {
> > if (unfalloc)
> > continue;
> > nr_swaps_freed += !shmem_free_swap(mapping,
> > - index, folio);
> > + folio->index, folio);
>
> We know this is a value entry, so we definitely can't look at
> folio->index. This should probably be:
>
> + indices[i], folio);
>
> > @@ -510,20 +509,18 @@ unsigned long invalidate_mapping_pagevec(struct address_space *mapping,
> > int i;
> >
> > folio_batch_init(&fbatch);
> > - while (find_lock_entries(mapping, index, end, &fbatch, indices)) {
> > + while (find_lock_entries(mapping, &index, end, &fbatch, indices)) {
> > for (i = 0; i < folio_batch_count(&fbatch); i++) {
> > struct folio *folio = fbatch.folios[i];
> >
> > /* We rely upon deletion not changing folio->index */
> > - index = indices[i];
> >
> > if (xa_is_value(folio)) {
> > count += invalidate_exceptional_entry(mapping,
> > - index,
> > - folio);
> > + folio->index,
> > + folio);
>
> Same here. I'd fix the indent while you're at it to get more on that
> second line and not need a third line.
>
Turns out I had misunderstood what a value entry was. I now understand
why we do in fact need the indices array. I'll fix the first 2 patches and
drop the last 2.