2019-05-19 15:08:55 +03:00
// SPDX-License-Identifier: GPL-2.0-only
2005-04-17 02:20:36 +04:00
/*
* mm / truncate . c - code for taking down pages from address_spaces
*
* Copyright ( C ) 2002 , Linus Torvalds
*
2008-10-16 09:01:59 +04:00
* 10 Sep2002 Andrew Morton
2005-04-17 02:20:36 +04:00
* Initial version .
*/
# include <linux/kernel.h>
2007-10-17 10:29:23 +04:00
# include <linux/backing-dev.h>
2016-01-23 02:10:40 +03:00
# include <linux/dax.h>
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 11:04:11 +03:00
# include <linux/gfp.h>
2005-04-17 02:20:36 +04:00
# include <linux/mm.h>
2006-09-27 12:50:02 +04:00
# include <linux/swap.h>
2011-10-16 10:01:52 +04:00
# include <linux/export.h>
2005-04-17 02:20:36 +04:00
# include <linux/pagemap.h>
2007-05-09 13:35:07 +04:00
# include <linux/highmem.h>
2005-04-17 02:20:36 +04:00
# include <linux/pagevec.h>
2006-12-10 13:19:31 +03:00
# include <linux/task_io_accounting_ops.h>
2022-02-09 23:21:51 +03:00
# include <linux/buffer_head.h> /* grr. try_to_release_page */
2017-02-25 01:59:36 +03:00
# include <linux/shmem_fs.h>
vfs: fix data corruption when blocksize < pagesize for mmaped data
->page_mkwrite() is used by filesystems to allocate blocks under a page
which is becoming writeably mmapped in some process' address space. This
allows a filesystem to return a page fault if there is not enough space
available, user exceeds quota or similar problem happens, rather than
silently discarding data later when writepage is called.
However VFS fails to call ->page_mkwrite() in all the cases where
filesystems need it when blocksize < pagesize. For example when
blocksize = 1024, pagesize = 4096 the following is problematic:
ftruncate(fd, 0);
pwrite(fd, buf, 1024, 0);
map = mmap(NULL, 1024, PROT_WRITE, MAP_SHARED, fd, 0);
map[0] = 'a'; ----> page_mkwrite() for index 0 is called
ftruncate(fd, 10000); /* or even pwrite(fd, buf, 1, 10000) */
mremap(map, 1024, 10000, 0);
map[4095] = 'a'; ----> no page_mkwrite() called
At the moment ->page_mkwrite() is called, filesystem can allocate only
one block for the page because i_size == 1024. Otherwise it would create
blocks beyond i_size which is generally undesirable. But later at
->writepage() time, we also need to store data at offset 4095 but we
don't have block allocated for it.
This patch introduces a helper function filesystems can use to have
->page_mkwrite() called at all the necessary moments.
Signed-off-by: Jan Kara <jack@suse.cz>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
Cc: stable@vger.kernel.org
2014-10-02 05:49:18 +04:00
# include <linux/rmap.h>
2008-10-19 07:26:50 +04:00
# include "internal.h"
2005-04-17 02:20:36 +04:00
2017-11-16 04:37:44 +03:00
/*
* Regular page slots are stabilized by the page lock even without the tree
* itself locked . These unlocked entries need verification under the tree
* lock .
*/
static inline void __clear_shadow_entry ( struct address_space * mapping ,
pgoff_t index , void * entry )
2014-04-04 01:47:46 +04:00
{
2017-11-26 06:52:46 +03:00
XA_STATE ( xas , & mapping - > i_pages , index ) ;
mm: keep page cache radix tree nodes in check
Previously, page cache radix tree nodes were freed after reclaim emptied
out their page pointers. But now reclaim stores shadow entries in their
place, which are only reclaimed when the inodes themselves are
reclaimed. This is problematic for bigger files that are still in use
after they have a significant amount of their cache reclaimed, without
any of those pages actually refaulting. The shadow entries will just
sit there and waste memory. In the worst case, the shadow entries will
accumulate until the machine runs out of memory.
To get this under control, the VM will track radix tree nodes
exclusively containing shadow entries on a per-NUMA node list. Per-NUMA
rather than global because we expect the radix tree nodes themselves to
be allocated node-locally and we want to reduce cross-node references of
otherwise independent cache workloads. A simple shrinker will then
reclaim these nodes on memory pressure.
A few things need to be stored in the radix tree node to implement the
shadow node LRU and allow tree deletions coming from the list:
1. There is no index available that would describe the reverse path
from the node up to the tree root, which is needed to perform a
deletion. To solve this, encode in each node its offset inside the
parent. This can be stored in the unused upper bits of the same
member that stores the node's height at no extra space cost.
2. The number of shadow entries needs to be counted in addition to the
regular entries, to quickly detect when the node is ready to go to
the shadow node LRU list. The current entry count is an unsigned
int but the maximum number of entries is 64, so a shadow counter
can easily be stored in the unused upper bits.
3. Tree modification needs tree lock and tree root, which are located
in the address space, so store an address_space backpointer in the
node. The parent pointer of the node is in a union with the 2-word
rcu_head, so the backpointer comes at no extra cost as well.
4. The node needs to be linked to an LRU list, which requires a list
head inside the node. This does increase the size of the node, but
it does not change the number of objects that fit into a slab page.
[akpm@linux-foundation.org: export the right function]
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Reviewed-by: Rik van Riel <riel@redhat.com>
Reviewed-by: Minchan Kim <minchan@kernel.org>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Bob Liu <bob.liu@oracle.com>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Dave Chinner <david@fromorbit.com>
Cc: Greg Thelen <gthelen@google.com>
Cc: Hugh Dickins <hughd@google.com>
Cc: Jan Kara <jack@suse.cz>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Cc: Luigi Semenzato <semenzato@google.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Metin Doslu <metin@citusdata.com>
Cc: Michel Lespinasse <walken@google.com>
Cc: Ozgun Erdogan <ozgun@citusdata.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Roman Gushchin <klamm@yandex-team.ru>
Cc: Ryan Mallon <rmallon@gmail.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Vlastimil Babka <vbabka@suse.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-04-04 01:47:56 +04:00
2017-11-26 06:52:46 +03:00
xas_set_update ( & xas , workingset_update_node ) ;
if ( xas_load ( & xas ) ! = entry )
2017-11-16 04:37:44 +03:00
return ;
2017-11-26 06:52:46 +03:00
xas_store ( & xas , NULL ) ;
2017-11-16 04:37:44 +03:00
}
static void clear_shadow_entry ( struct address_space * mapping , pgoff_t index ,
void * entry )
{
vfs: keep inodes with page cache off the inode shrinker LRU
Historically (pre-2.5), the inode shrinker used to reclaim only empty
inodes and skip over those that still contained page cache. This caused
problems on highmem hosts: struct inode could put fill lowmem zones
before the cache was getting reclaimed in the highmem zones.
To address this, the inode shrinker started to strip page cache to
facilitate reclaiming lowmem. However, this comes with its own set of
problems: the shrinkers may drop actively used page cache just because
the inodes are not currently open or dirty - think working with a large
git tree. It further doesn't respect cgroup memory protection settings
and can cause priority inversions between containers.
Nowadays, the page cache also holds non-resident info for evicted cache
pages in order to detect refaults. We've come to rely heavily on this
data inside reclaim for protecting the cache workingset and driving swap
behavior. We also use it to quantify and report workload health through
psi. The latter in turn is used for fleet health monitoring, as well as
driving automated memory sizing of workloads and containers, proactive
reclaim and memory offloading schemes.
The consequences of dropping page cache prematurely is that we're seeing
subtle and not-so-subtle failures in all of the above-mentioned
scenarios, with the workload generally entering unexpected thrashing
states while losing the ability to reliably detect it.
To fix this on non-highmem systems at least, going back to rotating
inodes on the LRU isn't feasible. We've tried (commit a76cf1a474d7
("mm: don't reclaim inodes with many attached pages")) and failed
(commit 69056ee6a8a3 ("Revert "mm: don't reclaim inodes with many
attached pages"")).
The issue is mostly that shrinker pools attract pressure based on their
size, and when objects get skipped the shrinkers remember this as
deferred reclaim work. This accumulates excessive pressure on the
remaining inodes, and we can quickly eat into heavily used ones, or
dirty ones that require IO to reclaim, when there potentially is plenty
of cold, clean cache around still.
Instead, this patch keeps populated inodes off the inode LRU in the
first place - just like an open file or dirty state would. An otherwise
clean and unused inode then gets queued when the last cache entry
disappears. This solves the problem without reintroducing the reclaim
issues, and generally is a bit more scalable than having to wade through
potentially hundreds of thousands of busy inodes.
Locking is a bit tricky because the locks protecting the inode state
(i_lock) and the inode LRU (lru_list.lock) don't nest inside the
irq-safe page cache lock (i_pages.xa_lock). Page cache deletions are
serialized through i_lock, taken before the i_pages lock, to make sure
depopulated inodes are queued reliably. Additions may race with
deletions, but we'll check again in the shrinker. If additions race
with the shrinker itself, we're protected by the i_lock: if find_inode()
or iput() win, the shrinker will bail on the elevated i_count or
I_REFERENCED; if the shrinker wins and goes ahead with the inode, it
will set I_FREEING and inhibit further igets(), which will cause the
other side to create a new instance of the inode instead.
Link: https://lkml.kernel.org/r/20210614211904.14420-4-hannes@cmpxchg.org
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Cc: Roman Gushchin <guro@fb.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Dave Chinner <david@fromorbit.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-11-09 05:31:24 +03:00
spin_lock ( & mapping - > host - > i_lock ) ;
2018-04-11 02:36:56 +03:00
xa_lock_irq ( & mapping - > i_pages ) ;
2017-11-16 04:37:44 +03:00
__clear_shadow_entry ( mapping , index , entry ) ;
2018-04-11 02:36:56 +03:00
xa_unlock_irq ( & mapping - > i_pages ) ;
vfs: keep inodes with page cache off the inode shrinker LRU
Historically (pre-2.5), the inode shrinker used to reclaim only empty
inodes and skip over those that still contained page cache. This caused
problems on highmem hosts: struct inode could put fill lowmem zones
before the cache was getting reclaimed in the highmem zones.
To address this, the inode shrinker started to strip page cache to
facilitate reclaiming lowmem. However, this comes with its own set of
problems: the shrinkers may drop actively used page cache just because
the inodes are not currently open or dirty - think working with a large
git tree. It further doesn't respect cgroup memory protection settings
and can cause priority inversions between containers.
Nowadays, the page cache also holds non-resident info for evicted cache
pages in order to detect refaults. We've come to rely heavily on this
data inside reclaim for protecting the cache workingset and driving swap
behavior. We also use it to quantify and report workload health through
psi. The latter in turn is used for fleet health monitoring, as well as
driving automated memory sizing of workloads and containers, proactive
reclaim and memory offloading schemes.
The consequences of dropping page cache prematurely is that we're seeing
subtle and not-so-subtle failures in all of the above-mentioned
scenarios, with the workload generally entering unexpected thrashing
states while losing the ability to reliably detect it.
To fix this on non-highmem systems at least, going back to rotating
inodes on the LRU isn't feasible. We've tried (commit a76cf1a474d7
("mm: don't reclaim inodes with many attached pages")) and failed
(commit 69056ee6a8a3 ("Revert "mm: don't reclaim inodes with many
attached pages"")).
The issue is mostly that shrinker pools attract pressure based on their
size, and when objects get skipped the shrinkers remember this as
deferred reclaim work. This accumulates excessive pressure on the
remaining inodes, and we can quickly eat into heavily used ones, or
dirty ones that require IO to reclaim, when there potentially is plenty
of cold, clean cache around still.
Instead, this patch keeps populated inodes off the inode LRU in the
first place - just like an open file or dirty state would. An otherwise
clean and unused inode then gets queued when the last cache entry
disappears. This solves the problem without reintroducing the reclaim
issues, and generally is a bit more scalable than having to wade through
potentially hundreds of thousands of busy inodes.
Locking is a bit tricky because the locks protecting the inode state
(i_lock) and the inode LRU (lru_list.lock) don't nest inside the
irq-safe page cache lock (i_pages.xa_lock). Page cache deletions are
serialized through i_lock, taken before the i_pages lock, to make sure
depopulated inodes are queued reliably. Additions may race with
deletions, but we'll check again in the shrinker. If additions race
with the shrinker itself, we're protected by the i_lock: if find_inode()
or iput() win, the shrinker will bail on the elevated i_count or
I_REFERENCED; if the shrinker wins and goes ahead with the inode, it
will set I_FREEING and inhibit further igets(), which will cause the
other side to create a new instance of the inode instead.
Link: https://lkml.kernel.org/r/20210614211904.14420-4-hannes@cmpxchg.org
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Cc: Roman Gushchin <guro@fb.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Dave Chinner <david@fromorbit.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-11-09 05:31:24 +03:00
if ( mapping_shrinkable ( mapping ) )
inode_add_lru ( mapping - > host ) ;
spin_unlock ( & mapping - > host - > i_lock ) ;
2014-04-04 01:47:46 +04:00
}
2005-04-17 02:20:36 +04:00
2016-08-10 18:22:44 +03:00
/*
2017-11-16 04:37:44 +03:00
* Unconditionally remove exceptional entries . Usually called from truncate
2021-12-07 22:15:07 +03:00
* path . Note that the folio_batch may be altered by this function by removing
2021-12-07 22:28:49 +03:00
* exceptional entries similar to what folio_batch_remove_exceptionals ( ) does .
2016-08-10 18:22:44 +03:00
*/
2021-12-07 22:15:07 +03:00
static void truncate_folio_batch_exceptionals ( struct address_space * mapping ,
struct folio_batch * fbatch , pgoff_t * indices )
2016-08-10 18:22:44 +03:00
{
2017-11-16 04:37:44 +03:00
int i , j ;
2021-02-26 04:16:03 +03:00
bool dax ;
2017-11-16 04:37:44 +03:00
2016-08-10 18:22:44 +03:00
/* Handled by shmem itself */
if ( shmem_mapping ( mapping ) )
return ;
2021-12-07 22:15:07 +03:00
for ( j = 0 ; j < folio_batch_count ( fbatch ) ; j + + )
if ( xa_is_value ( fbatch - > folios [ j ] ) )
2017-11-16 04:37:44 +03:00
break ;
2021-12-07 22:15:07 +03:00
if ( j = = folio_batch_count ( fbatch ) )
2016-08-10 18:22:44 +03:00
return ;
2017-11-16 04:37:44 +03:00
dax = dax_mapping ( mapping ) ;
vfs: keep inodes with page cache off the inode shrinker LRU
Historically (pre-2.5), the inode shrinker used to reclaim only empty
inodes and skip over those that still contained page cache. This caused
problems on highmem hosts: struct inode could put fill lowmem zones
before the cache was getting reclaimed in the highmem zones.
To address this, the inode shrinker started to strip page cache to
facilitate reclaiming lowmem. However, this comes with its own set of
problems: the shrinkers may drop actively used page cache just because
the inodes are not currently open or dirty - think working with a large
git tree. It further doesn't respect cgroup memory protection settings
and can cause priority inversions between containers.
Nowadays, the page cache also holds non-resident info for evicted cache
pages in order to detect refaults. We've come to rely heavily on this
data inside reclaim for protecting the cache workingset and driving swap
behavior. We also use it to quantify and report workload health through
psi. The latter in turn is used for fleet health monitoring, as well as
driving automated memory sizing of workloads and containers, proactive
reclaim and memory offloading schemes.
The consequences of dropping page cache prematurely is that we're seeing
subtle and not-so-subtle failures in all of the above-mentioned
scenarios, with the workload generally entering unexpected thrashing
states while losing the ability to reliably detect it.
To fix this on non-highmem systems at least, going back to rotating
inodes on the LRU isn't feasible. We've tried (commit a76cf1a474d7
("mm: don't reclaim inodes with many attached pages")) and failed
(commit 69056ee6a8a3 ("Revert "mm: don't reclaim inodes with many
attached pages"")).
The issue is mostly that shrinker pools attract pressure based on their
size, and when objects get skipped the shrinkers remember this as
deferred reclaim work. This accumulates excessive pressure on the
remaining inodes, and we can quickly eat into heavily used ones, or
dirty ones that require IO to reclaim, when there potentially is plenty
of cold, clean cache around still.
Instead, this patch keeps populated inodes off the inode LRU in the
first place - just like an open file or dirty state would. An otherwise
clean and unused inode then gets queued when the last cache entry
disappears. This solves the problem without reintroducing the reclaim
issues, and generally is a bit more scalable than having to wade through
potentially hundreds of thousands of busy inodes.
Locking is a bit tricky because the locks protecting the inode state
(i_lock) and the inode LRU (lru_list.lock) don't nest inside the
irq-safe page cache lock (i_pages.xa_lock). Page cache deletions are
serialized through i_lock, taken before the i_pages lock, to make sure
depopulated inodes are queued reliably. Additions may race with
deletions, but we'll check again in the shrinker. If additions race
with the shrinker itself, we're protected by the i_lock: if find_inode()
or iput() win, the shrinker will bail on the elevated i_count or
I_REFERENCED; if the shrinker wins and goes ahead with the inode, it
will set I_FREEING and inhibit further igets(), which will cause the
other side to create a new instance of the inode instead.
Link: https://lkml.kernel.org/r/20210614211904.14420-4-hannes@cmpxchg.org
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Cc: Roman Gushchin <guro@fb.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Dave Chinner <david@fromorbit.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-11-09 05:31:24 +03:00
if ( ! dax ) {
spin_lock ( & mapping - > host - > i_lock ) ;
2018-04-11 02:36:56 +03:00
xa_lock_irq ( & mapping - > i_pages ) ;
vfs: keep inodes with page cache off the inode shrinker LRU
Historically (pre-2.5), the inode shrinker used to reclaim only empty
inodes and skip over those that still contained page cache. This caused
problems on highmem hosts: struct inode could put fill lowmem zones
before the cache was getting reclaimed in the highmem zones.
To address this, the inode shrinker started to strip page cache to
facilitate reclaiming lowmem. However, this comes with its own set of
problems: the shrinkers may drop actively used page cache just because
the inodes are not currently open or dirty - think working with a large
git tree. It further doesn't respect cgroup memory protection settings
and can cause priority inversions between containers.
Nowadays, the page cache also holds non-resident info for evicted cache
pages in order to detect refaults. We've come to rely heavily on this
data inside reclaim for protecting the cache workingset and driving swap
behavior. We also use it to quantify and report workload health through
psi. The latter in turn is used for fleet health monitoring, as well as
driving automated memory sizing of workloads and containers, proactive
reclaim and memory offloading schemes.
The consequences of dropping page cache prematurely is that we're seeing
subtle and not-so-subtle failures in all of the above-mentioned
scenarios, with the workload generally entering unexpected thrashing
states while losing the ability to reliably detect it.
To fix this on non-highmem systems at least, going back to rotating
inodes on the LRU isn't feasible. We've tried (commit a76cf1a474d7
("mm: don't reclaim inodes with many attached pages")) and failed
(commit 69056ee6a8a3 ("Revert "mm: don't reclaim inodes with many
attached pages"")).
The issue is mostly that shrinker pools attract pressure based on their
size, and when objects get skipped the shrinkers remember this as
deferred reclaim work. This accumulates excessive pressure on the
remaining inodes, and we can quickly eat into heavily used ones, or
dirty ones that require IO to reclaim, when there potentially is plenty
of cold, clean cache around still.
Instead, this patch keeps populated inodes off the inode LRU in the
first place - just like an open file or dirty state would. An otherwise
clean and unused inode then gets queued when the last cache entry
disappears. This solves the problem without reintroducing the reclaim
issues, and generally is a bit more scalable than having to wade through
potentially hundreds of thousands of busy inodes.
Locking is a bit tricky because the locks protecting the inode state
(i_lock) and the inode LRU (lru_list.lock) don't nest inside the
irq-safe page cache lock (i_pages.xa_lock). Page cache deletions are
serialized through i_lock, taken before the i_pages lock, to make sure
depopulated inodes are queued reliably. Additions may race with
deletions, but we'll check again in the shrinker. If additions race
with the shrinker itself, we're protected by the i_lock: if find_inode()
or iput() win, the shrinker will bail on the elevated i_count or
I_REFERENCED; if the shrinker wins and goes ahead with the inode, it
will set I_FREEING and inhibit further igets(), which will cause the
other side to create a new instance of the inode instead.
Link: https://lkml.kernel.org/r/20210614211904.14420-4-hannes@cmpxchg.org
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Cc: Roman Gushchin <guro@fb.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Dave Chinner <david@fromorbit.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-11-09 05:31:24 +03:00
}
2017-11-16 04:37:44 +03:00
2021-12-07 22:15:07 +03:00
for ( i = j ; i < folio_batch_count ( fbatch ) ; i + + ) {
struct folio * folio = fbatch - > folios [ i ] ;
2017-11-16 04:37:44 +03:00
pgoff_t index = indices [ i ] ;
2021-12-07 22:15:07 +03:00
if ( ! xa_is_value ( folio ) ) {
fbatch - > folios [ j + + ] = folio ;
2017-11-16 04:37:44 +03:00
continue ;
}
if ( unlikely ( dax ) ) {
dax_delete_mapping_entry ( mapping , index ) ;
continue ;
}
2021-12-07 22:15:07 +03:00
__clear_shadow_entry ( mapping , index , folio ) ;
2016-08-10 18:22:44 +03:00
}
2017-11-16 04:37:44 +03:00
vfs: keep inodes with page cache off the inode shrinker LRU
Historically (pre-2.5), the inode shrinker used to reclaim only empty
inodes and skip over those that still contained page cache. This caused
problems on highmem hosts: struct inode could put fill lowmem zones
before the cache was getting reclaimed in the highmem zones.
To address this, the inode shrinker started to strip page cache to
facilitate reclaiming lowmem. However, this comes with its own set of
problems: the shrinkers may drop actively used page cache just because
the inodes are not currently open or dirty - think working with a large
git tree. It further doesn't respect cgroup memory protection settings
and can cause priority inversions between containers.
Nowadays, the page cache also holds non-resident info for evicted cache
pages in order to detect refaults. We've come to rely heavily on this
data inside reclaim for protecting the cache workingset and driving swap
behavior. We also use it to quantify and report workload health through
psi. The latter in turn is used for fleet health monitoring, as well as
driving automated memory sizing of workloads and containers, proactive
reclaim and memory offloading schemes.
The consequences of dropping page cache prematurely is that we're seeing
subtle and not-so-subtle failures in all of the above-mentioned
scenarios, with the workload generally entering unexpected thrashing
states while losing the ability to reliably detect it.
To fix this on non-highmem systems at least, going back to rotating
inodes on the LRU isn't feasible. We've tried (commit a76cf1a474d7
("mm: don't reclaim inodes with many attached pages")) and failed
(commit 69056ee6a8a3 ("Revert "mm: don't reclaim inodes with many
attached pages"")).
The issue is mostly that shrinker pools attract pressure based on their
size, and when objects get skipped the shrinkers remember this as
deferred reclaim work. This accumulates excessive pressure on the
remaining inodes, and we can quickly eat into heavily used ones, or
dirty ones that require IO to reclaim, when there potentially is plenty
of cold, clean cache around still.
Instead, this patch keeps populated inodes off the inode LRU in the
first place - just like an open file or dirty state would. An otherwise
clean and unused inode then gets queued when the last cache entry
disappears. This solves the problem without reintroducing the reclaim
issues, and generally is a bit more scalable than having to wade through
potentially hundreds of thousands of busy inodes.
Locking is a bit tricky because the locks protecting the inode state
(i_lock) and the inode LRU (lru_list.lock) don't nest inside the
irq-safe page cache lock (i_pages.xa_lock). Page cache deletions are
serialized through i_lock, taken before the i_pages lock, to make sure
depopulated inodes are queued reliably. Additions may race with
deletions, but we'll check again in the shrinker. If additions race
with the shrinker itself, we're protected by the i_lock: if find_inode()
or iput() win, the shrinker will bail on the elevated i_count or
I_REFERENCED; if the shrinker wins and goes ahead with the inode, it
will set I_FREEING and inhibit further igets(), which will cause the
other side to create a new instance of the inode instead.
Link: https://lkml.kernel.org/r/20210614211904.14420-4-hannes@cmpxchg.org
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Cc: Roman Gushchin <guro@fb.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Dave Chinner <david@fromorbit.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-11-09 05:31:24 +03:00
if ( ! dax ) {
2018-04-11 02:36:56 +03:00
xa_unlock_irq ( & mapping - > i_pages ) ;
vfs: keep inodes with page cache off the inode shrinker LRU
Historically (pre-2.5), the inode shrinker used to reclaim only empty
inodes and skip over those that still contained page cache. This caused
problems on highmem hosts: struct inode could put fill lowmem zones
before the cache was getting reclaimed in the highmem zones.
To address this, the inode shrinker started to strip page cache to
facilitate reclaiming lowmem. However, this comes with its own set of
problems: the shrinkers may drop actively used page cache just because
the inodes are not currently open or dirty - think working with a large
git tree. It further doesn't respect cgroup memory protection settings
and can cause priority inversions between containers.
Nowadays, the page cache also holds non-resident info for evicted cache
pages in order to detect refaults. We've come to rely heavily on this
data inside reclaim for protecting the cache workingset and driving swap
behavior. We also use it to quantify and report workload health through
psi. The latter in turn is used for fleet health monitoring, as well as
driving automated memory sizing of workloads and containers, proactive
reclaim and memory offloading schemes.
The consequences of dropping page cache prematurely is that we're seeing
subtle and not-so-subtle failures in all of the above-mentioned
scenarios, with the workload generally entering unexpected thrashing
states while losing the ability to reliably detect it.
To fix this on non-highmem systems at least, going back to rotating
inodes on the LRU isn't feasible. We've tried (commit a76cf1a474d7
("mm: don't reclaim inodes with many attached pages")) and failed
(commit 69056ee6a8a3 ("Revert "mm: don't reclaim inodes with many
attached pages"")).
The issue is mostly that shrinker pools attract pressure based on their
size, and when objects get skipped the shrinkers remember this as
deferred reclaim work. This accumulates excessive pressure on the
remaining inodes, and we can quickly eat into heavily used ones, or
dirty ones that require IO to reclaim, when there potentially is plenty
of cold, clean cache around still.
Instead, this patch keeps populated inodes off the inode LRU in the
first place - just like an open file or dirty state would. An otherwise
clean and unused inode then gets queued when the last cache entry
disappears. This solves the problem without reintroducing the reclaim
issues, and generally is a bit more scalable than having to wade through
potentially hundreds of thousands of busy inodes.
Locking is a bit tricky because the locks protecting the inode state
(i_lock) and the inode LRU (lru_list.lock) don't nest inside the
irq-safe page cache lock (i_pages.xa_lock). Page cache deletions are
serialized through i_lock, taken before the i_pages lock, to make sure
depopulated inodes are queued reliably. Additions may race with
deletions, but we'll check again in the shrinker. If additions race
with the shrinker itself, we're protected by the i_lock: if find_inode()
or iput() win, the shrinker will bail on the elevated i_count or
I_REFERENCED; if the shrinker wins and goes ahead with the inode, it
will set I_FREEING and inhibit further igets(), which will cause the
other side to create a new instance of the inode instead.
Link: https://lkml.kernel.org/r/20210614211904.14420-4-hannes@cmpxchg.org
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Cc: Roman Gushchin <guro@fb.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Dave Chinner <david@fromorbit.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-11-09 05:31:24 +03:00
if ( mapping_shrinkable ( mapping ) )
inode_add_lru ( mapping - > host ) ;
spin_unlock ( & mapping - > host - > i_lock ) ;
}
2021-12-07 22:15:07 +03:00
fbatch - > nr = j ;
2020-09-02 06:17:50 +03:00
}
2016-08-10 18:22:44 +03:00
/*
* Invalidate exceptional entry if easily possible . This handles exceptional
2017-05-13 01:46:47 +03:00
* entries for invalidate_inode_pages ( ) .
2016-08-10 18:22:44 +03:00
*/
static int invalidate_exceptional_entry ( struct address_space * mapping ,
pgoff_t index , void * entry )
{
2017-05-13 01:46:47 +03:00
/* Handled by shmem itself, or for DAX we do nothing. */
if ( shmem_mapping ( mapping ) | | dax_mapping ( mapping ) )
2016-08-10 18:22:44 +03:00
return 1 ;
clear_shadow_entry ( mapping , index , entry ) ;
return 1 ;
}
/*
* Invalidate exceptional entry if clean . This handles exceptional entries for
* invalidate_inode_pages2 ( ) so for DAX it evicts only clean entries .
*/
static int invalidate_exceptional_entry2 ( struct address_space * mapping ,
pgoff_t index , void * entry )
{
/* Handled by shmem itself */
if ( shmem_mapping ( mapping ) )
return 1 ;
if ( dax_mapping ( mapping ) )
return dax_invalidate_mapping_entry_sync ( mapping , index ) ;
clear_shadow_entry ( mapping , index , entry ) ;
return 1 ;
}
2006-08-29 22:05:54 +04:00
/**
2022-02-09 23:21:28 +03:00
* folio_invalidate - Invalidate part or all of a folio .
* @ folio : The folio which is affected .
2013-05-22 07:17:23 +04:00
* @ offset : start of the range to invalidate
* @ length : length of the range to invalidate
2006-08-29 22:05:54 +04:00
*
2022-02-09 23:21:28 +03:00
* folio_invalidate ( ) is called when all or part of the folio has become
2006-08-29 22:05:54 +04:00
* invalidated by a truncate operation .
*
2022-02-09 23:21:28 +03:00
* folio_invalidate ( ) does not have to release all buffers , but it must
2006-08-29 22:05:54 +04:00
* ensure that no dirty buffer is left outside @ offset and that no I / O
* is underway against any of the blocks which are outside the truncation
* point . Because the caller is about to free ( and possibly reuse ) those
* blocks on - disk .
*/
2022-02-09 23:21:28 +03:00
void folio_invalidate ( struct folio * folio , size_t offset , size_t length )
2006-08-29 22:05:54 +04:00
{
2022-02-09 23:21:32 +03:00
const struct address_space_operations * aops = folio - > mapping - > a_ops ;
2013-05-22 07:17:23 +04:00
2022-02-09 23:21:51 +03:00
if ( aops - > invalidate_folio )
2022-02-09 23:21:32 +03:00
aops - > invalidate_folio ( folio , offset , length ) ;
2006-08-29 22:05:54 +04:00
}
2022-02-09 23:21:28 +03:00
EXPORT_SYMBOL_GPL ( folio_invalidate ) ;
2006-08-29 22:05:54 +04:00
2005-04-17 02:20:36 +04:00
/*
* If truncate cannot remove the fs - private metadata from the page , the page
2008-02-05 09:29:33 +03:00
* becomes orphaned . It will be left on the LRU and may even be mapped into
2007-07-19 12:46:59 +04:00
* user pagetables if we ' re racing with filemap_fault ( ) .
2005-04-17 02:20:36 +04:00
*
2020-10-16 06:05:50 +03:00
* We need to bail out if page - > mapping is no longer equal to the original
2005-04-17 02:20:36 +04:00
* mapping . This happens a ) when the VM reclaimed the page while we waited on
2007-02-10 12:45:39 +03:00
* its lock , b ) when a concurrent invalidate_mapping_pages got there first and
2005-04-17 02:20:36 +04:00
* c ) when tmpfs swizzles a page between a tmpfs inode and swapper_space .
*/
2021-11-26 21:58:10 +03:00
static void truncate_cleanup_folio ( struct folio * folio )
2005-04-17 02:20:36 +04:00
{
2021-11-26 21:58:10 +03:00
if ( folio_mapped ( folio ) )
2021-11-28 22:53:35 +03:00
unmap_mapping_folio ( folio ) ;
2005-04-17 02:20:36 +04:00
2021-11-26 21:58:10 +03:00
if ( folio_has_private ( folio ) )
2022-02-09 23:21:28 +03:00
folio_invalidate ( folio , 0 , folio_size ( folio ) ) ;
2005-04-17 02:20:36 +04:00
2015-04-15 01:45:27 +03:00
/*
* Some filesystems seem to re - dirty the page even after
* the VM has canceled the dirty bit ( eg ext3 journaling ) .
* Hence dirty accounting check is placed after invalidation .
*/
2021-11-26 21:58:10 +03:00
folio_cancel_dirty ( folio ) ;
folio_clear_mappedtodisk ( folio ) ;
2005-04-17 02:20:36 +04:00
}
2021-12-03 00:01:55 +03:00
int truncate_inode_folio ( struct address_space * mapping , struct folio * folio )
2009-09-16 13:50:12 +04:00
{
2021-12-03 00:01:55 +03:00
if ( folio - > mapping ! = mapping )
2017-11-16 04:37:15 +03:00
return - EIO ;
2021-11-26 21:58:10 +03:00
truncate_cleanup_folio ( folio ) ;
filemap_remove_folio ( folio ) ;
2017-11-16 04:37:15 +03:00
return 0 ;
2009-09-16 13:50:12 +04:00
}
2020-05-28 00:59:22 +03:00
/*
* Handle partial folios . The folio may be entirely within the
* range if a split has raced with us . If not , we zero the part of the
* folio that ' s within the [ start , end ] range , and then split the folio if
* it ' s large . split_page_range ( ) will discard pages which now lie beyond
* i_size , and we rely on the caller to discard pages which lie within a
* newly created hole .
*
* Returns false if splitting failed so the caller can avoid
* discarding the entire folio which is stubbornly unsplit .
*/
bool truncate_inode_partial_folio ( struct folio * folio , loff_t start , loff_t end )
{
loff_t pos = folio_pos ( folio ) ;
unsigned int offset , length ;
if ( pos < start )
offset = start - pos ;
else
offset = 0 ;
length = folio_size ( folio ) ;
if ( pos + length < = ( u64 ) end )
length = length - offset ;
else
length = end + 1 - pos - offset ;
folio_wait_writeback ( folio ) ;
if ( length = = folio_size ( folio ) ) {
truncate_inode_folio ( folio - > mapping , folio ) ;
return true ;
}
/*
* We may be zeroing pages we ' re about to discard , but it avoids
* doing a complex calculation here , and then doing the zeroing
* anyway if the page split fails .
*/
folio_zero_range ( folio , offset , length ) ;
if ( folio_has_private ( folio ) )
2022-02-09 23:21:28 +03:00
folio_invalidate ( folio , offset , length ) ;
2020-05-28 00:59:22 +03:00
if ( ! folio_test_large ( folio ) )
return true ;
2022-09-02 22:46:00 +03:00
if ( split_folio ( folio ) = = 0 )
2020-05-28 00:59:22 +03:00
return true ;
if ( folio_test_dirty ( folio ) )
return false ;
truncate_inode_folio ( folio - > mapping , folio ) ;
return true ;
}
2009-09-16 13:50:13 +04:00
/*
* Used to get rid of pages on hardware memory corruption .
*/
int generic_error_remove_page ( struct address_space * mapping , struct page * page )
{
2021-12-03 00:01:55 +03:00
VM_BUG_ON_PAGE ( PageTail ( page ) , page ) ;
2009-09-16 13:50:13 +04:00
if ( ! mapping )
return - EINVAL ;
/*
* Only punch for normal data pages for now .
* Handling other types like directories would need more auditing .
*/
if ( ! S_ISREG ( mapping - > host - > i_mode ) )
return - EIO ;
2021-12-03 00:01:55 +03:00
return truncate_inode_folio ( mapping , page_folio ( page ) ) ;
2009-09-16 13:50:13 +04:00
}
EXPORT_SYMBOL ( generic_error_remove_page ) ;
2022-02-13 23:22:28 +03:00
static long mapping_evict_folio ( struct address_space * mapping ,
struct folio * folio )
2009-09-16 13:50:13 +04:00
{
2022-02-13 01:39:10 +03:00
if ( folio_test_dirty ( folio ) | | folio_test_writeback ( folio ) )
2009-09-16 13:50:13 +04:00
return 0 ;
2022-02-13 01:43:16 +03:00
/* The refcount will be elevated if any page in the folio is mapped */
if ( folio_ref_count ( folio ) >
folio_nr_pages ( folio ) + folio_has_private ( folio ) + 1 )
2009-09-16 13:50:13 +04:00
return 0 ;
2022-02-13 01:39:10 +03:00
if ( folio_has_private ( folio ) & & ! filemap_release_folio ( folio , 0 ) )
2022-02-12 23:27:42 +03:00
return 0 ;
2022-02-13 06:48:55 +03:00
return remove_mapping ( mapping , folio ) ;
2009-09-16 13:50:13 +04:00
}
2022-02-13 23:22:28 +03:00
/**
* invalidate_inode_page ( ) - Remove an unused page from the pagecache .
* @ page : The page to remove .
*
* Safely invalidate one page from its pagecache mapping .
* It only drops clean , unused pages .
*
* Context : Page must be locked .
* Return : The number of pages successfully removed .
*/
long invalidate_inode_page ( struct page * page )
{
struct folio * folio = page_folio ( page ) ;
struct address_space * mapping = folio_mapping ( folio ) ;
/* The page may have been truncated before it was locked */
if ( ! mapping )
return 0 ;
return mapping_evict_folio ( mapping , folio ) ;
}
2005-04-17 02:20:36 +04:00
/**
2012-02-21 06:57:20 +04:00
* truncate_inode_pages_range - truncate range of pages specified by start & end byte offsets
2005-04-17 02:20:36 +04:00
* @ mapping : mapping to truncate
* @ lstart : offset from which to truncate
2013-05-28 07:32:35 +04:00
* @ lend : offset to which to truncate ( inclusive )
2005-04-17 02:20:36 +04:00
*
2006-01-06 11:10:36 +03:00
* Truncate the page cache , removing the pages that are between
2013-05-28 07:32:35 +04:00
* specified offsets ( and zeroing out partial pages
* if lstart or lend + 1 is not page aligned ) .
2005-04-17 02:20:36 +04:00
*
* Truncate takes two passes - the first pass is nonblocking . It will not
* block on page locks and it will not block on writeback . The second pass
* will wait . This is to prevent as much IO as possible in the affected region .
* The first pass will remove most pages , so the search cost of the second pass
* is low .
*
* We pass down the cache - hot hint to the page freeing code . Even if the
* mapping is large , it is probably the case that the final pages are the most
* recently touched , and freeing happens in ascending file offset order .
2013-05-28 07:32:35 +04:00
*
2022-02-09 23:21:51 +03:00
* Note that since - > invalidate_folio ( ) accepts range to invalidate
2013-05-28 07:32:35 +04:00
* truncate_inode_pages_range is able to handle cases where lend + 1 is not
* page aligned properly .
2005-04-17 02:20:36 +04:00
*/
2006-01-06 11:10:36 +03:00
void truncate_inode_pages_range ( struct address_space * mapping ,
loff_t lstart , loff_t lend )
2005-04-17 02:20:36 +04:00
{
2013-05-28 07:32:35 +04:00
pgoff_t start ; /* inclusive */
pgoff_t end ; /* exclusive */
2020-09-02 06:17:50 +03:00
struct folio_batch fbatch ;
2014-04-04 01:47:46 +04:00
pgoff_t indices [ PAGEVEC_SIZE ] ;
2013-05-28 07:32:35 +04:00
pgoff_t index ;
int i ;
2020-05-28 00:59:22 +03:00
struct folio * folio ;
bool same_folio ;
2005-04-17 02:20:36 +04:00
2021-05-05 04:32:45 +03:00
if ( mapping_empty ( mapping ) )
2022-01-22 09:14:34 +03:00
return ;
2005-04-17 02:20:36 +04:00
2013-05-28 07:32:35 +04:00
/*
* ' start ' and ' end ' always covers the range of pages to be fully
* truncated . Partial pages are covered with ' partial_start ' at the
* start of the range and ' partial_end ' at the end of the range .
* Note that ' end ' is exclusive while ' lend ' is inclusive .
*/
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 15:29:47 +03:00
start = ( lstart + PAGE_SIZE - 1 ) > > PAGE_SHIFT ;
2013-05-28 07:32:35 +04:00
if ( lend = = - 1 )
/*
* lend = = - 1 indicates end - of - file so we have to set ' end '
* to the highest possible pgoff_t and since the type is
* unsigned we ' re using - 1.
*/
end = - 1 ;
else
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 15:29:47 +03:00
end = ( lend + 1 ) > > PAGE_SHIFT ;
2006-01-06 11:10:36 +03:00
2021-12-07 22:15:07 +03:00
folio_batch_init ( & fbatch ) ;
2011-07-26 04:12:25 +04:00
index = start ;
2022-10-17 19:17:59 +03:00
while ( index < end & & find_lock_entries ( mapping , & index , end - 1 ,
2021-12-07 22:15:07 +03:00
& fbatch , indices ) ) {
truncate_folio_batch_exceptionals ( mapping , & fbatch , indices ) ;
for ( i = 0 ; i < folio_batch_count ( & fbatch ) ; i + + )
truncate_cleanup_folio ( fbatch . folios [ i ] ) ;
delete_from_page_cache_batch ( mapping , & fbatch ) ;
for ( i = 0 ; i < folio_batch_count ( & fbatch ) ; i + + )
folio_unlock ( fbatch . folios [ i ] ) ;
folio_batch_release ( & fbatch ) ;
2005-04-17 02:20:36 +04:00
cond_resched ( ) ;
}
2021-02-26 04:15:56 +03:00
2020-05-28 00:59:22 +03:00
same_folio = ( lstart > > PAGE_SHIFT ) = = ( lend > > PAGE_SHIFT ) ;
folio = __filemap_get_folio ( mapping , lstart > > PAGE_SHIFT , FGP_LOCK , 0 ) ;
if ( folio ) {
same_folio = lend < folio_pos ( folio ) + folio_size ( folio ) ;
if ( ! truncate_inode_partial_folio ( folio , lstart , lend ) ) {
start = folio - > index + folio_nr_pages ( folio ) ;
if ( same_folio )
end = folio - > index ;
2005-04-17 02:20:36 +04:00
}
2020-05-28 00:59:22 +03:00
folio_unlock ( folio ) ;
folio_put ( folio ) ;
folio = NULL ;
2005-04-17 02:20:36 +04:00
}
2020-05-28 00:59:22 +03:00
if ( ! same_folio )
folio = __filemap_get_folio ( mapping , lend > > PAGE_SHIFT ,
FGP_LOCK , 0 ) ;
if ( folio ) {
if ( ! truncate_inode_partial_folio ( folio , lstart , lend ) )
end = folio - > index ;
folio_unlock ( folio ) ;
folio_put ( folio ) ;
2013-05-28 07:32:35 +04:00
}
2005-04-17 02:20:36 +04:00
2011-07-26 04:12:25 +04:00
index = start ;
2020-05-28 00:59:22 +03:00
while ( index < end ) {
2005-04-17 02:20:36 +04:00
cond_resched ( ) ;
2022-10-17 19:18:00 +03:00
if ( ! find_get_entries ( mapping , & index , end - 1 , & fbatch ,
2021-02-26 04:16:07 +03:00
indices ) ) {
2014-07-24 01:00:15 +04:00
/* If all gone from start onwards, we're done */
2011-07-26 04:12:25 +04:00
if ( index = = start )
2005-04-17 02:20:36 +04:00
break ;
2014-07-24 01:00:15 +04:00
/* Otherwise restart to make sure all gone */
2011-07-26 04:12:25 +04:00
index = start ;
2005-04-17 02:20:36 +04:00
continue ;
}
2017-11-16 04:37:44 +03:00
2020-09-02 06:17:50 +03:00
for ( i = 0 ; i < folio_batch_count ( & fbatch ) ; i + + ) {
struct folio * folio = fbatch . folios [ i ] ;
2005-04-17 02:20:36 +04:00
2011-07-26 04:12:25 +04:00
/* We rely upon deletion not changing page->index */
2020-09-02 06:17:50 +03:00
if ( xa_is_value ( folio ) )
2014-04-04 01:47:46 +04:00
continue ;
2021-12-03 00:01:55 +03:00
folio_lock ( folio ) ;
2022-10-17 19:18:00 +03:00
VM_BUG_ON_FOLIO ( ! folio_contains ( folio , indices [ i ] ) , folio ) ;
2021-12-03 00:01:55 +03:00
folio_wait_writeback ( folio ) ;
truncate_inode_folio ( mapping , folio ) ;
folio_unlock ( folio ) ;
2005-04-17 02:20:36 +04:00
}
2020-09-02 06:17:50 +03:00
truncate_folio_batch_exceptionals ( mapping , & fbatch , indices ) ;
folio_batch_release ( & fbatch ) ;
2005-04-17 02:20:36 +04:00
}
}
2006-01-06 11:10:36 +03:00
EXPORT_SYMBOL ( truncate_inode_pages_range ) ;
2005-04-17 02:20:36 +04:00
2006-01-06 11:10:36 +03:00
/**
* truncate_inode_pages - truncate * all * the pages from an offset
* @ mapping : mapping to truncate
* @ lstart : offset from which to truncate
*
2021-01-28 21:19:45 +03:00
* Called under ( and serialised by ) inode - > i_rwsem and
* mapping - > invalidate_lock .
2011-06-28 03:18:10 +04:00
*
* Note : When this function returns , there can be a page in the process of
2022-06-29 03:41:40 +03:00
* deletion ( inside __filemap_remove_folio ( ) ) in the specified range . Thus
2011-06-28 03:18:10 +04:00
* mapping - > nrpages can be non - zero when this function returns even after
* truncation of the whole mapping .
2006-01-06 11:10:36 +03:00
*/
void truncate_inode_pages ( struct address_space * mapping , loff_t lstart )
{
truncate_inode_pages_range ( mapping , lstart , ( loff_t ) - 1 ) ;
}
2005-04-17 02:20:36 +04:00
EXPORT_SYMBOL ( truncate_inode_pages ) ;
2014-04-04 01:47:49 +04:00
/**
* truncate_inode_pages_final - truncate * all * pages before inode dies
* @ mapping : mapping to truncate
*
2021-04-12 16:50:21 +03:00
* Called under ( and serialized by ) inode - > i_rwsem .
2014-04-04 01:47:49 +04:00
*
* Filesystems have to use this in the . evict_inode path to inform the
* VM that this is the final truncate and the inode is going away .
*/
void truncate_inode_pages_final ( struct address_space * mapping )
{
/*
* Page reclaim can not participate in regular inode lifetime
* management ( can ' t call iput ( ) ) and thus can race with the
* inode teardown . Tell it when the address space is exiting ,
* so that it does not install eviction information after the
* final truncate has begun .
*/
mapping_set_exiting ( mapping ) ;
2021-05-05 04:32:45 +03:00
if ( ! mapping_empty ( mapping ) ) {
2014-04-04 01:47:49 +04:00
/*
* As truncation uses a lockless tree lookup , cycle
* the tree lock to make sure any ongoing tree
* modification that does not see AS_EXITING is
* completed before starting the final truncate .
*/
2018-04-11 02:36:56 +03:00
xa_lock_irq ( & mapping - > i_pages ) ;
xa_unlock_irq ( & mapping - > i_pages ) ;
2014-04-04 01:47:49 +04:00
}
2018-12-01 01:09:00 +03:00
truncate_inode_pages ( mapping , 0 ) ;
2014-04-04 01:47:49 +04:00
}
EXPORT_SYMBOL ( truncate_inode_pages_final ) ;
2022-02-14 01:22:10 +03:00
/**
* invalidate_mapping_pagevec - Invalidate all the unlocked pages of one inode
* @ mapping : the address_space which holds the pages to invalidate
* @ start : the offset ' from ' which to invalidate
* @ end : the offset ' to ' which to invalidate ( inclusive )
* @ nr_pagevec : invalidate failed page number for caller
*
* This helper is similar to invalidate_mapping_pages ( ) , except that it accounts
* for pages that are likely on a pagevec and counts them in @ nr_pagevec , which
* will be used by the caller .
*/
unsigned long invalidate_mapping_pagevec ( struct address_space * mapping ,
mm, fadvise: improve the expensive remote LRU cache draining after FADV_DONTNEED
Our users reported that there're some random latency spikes when their RT
process is running. Finally we found that latency spike is caused by
FADV_DONTNEED. Which may call lru_add_drain_all() to drain LRU cache on
remote CPUs, and then waits the per-cpu work to complete. The wait time
is uncertain, which may be tens millisecond.
That behavior is unreasonable, because this process is bound to a specific
CPU and the file is only accessed by itself, IOW, there should be no
pagecache pages on a per-cpu pagevec of a remote CPU. That unreasonable
behavior is partially caused by the wrong comparation of the number of
invalidated pages and the number of the target. For example,
if (count < (end_index - start_index + 1))
The count above is how many pages were invalidated in the local CPU, and
(end_index - start_index + 1) is how many pages should be invalidated.
The usage of (end_index - start_index + 1) is incorrect, because they are
virtual addresses, which may not mapped to pages. Besides that, there may
be holes between start and end. So we'd better check whether there are
still pages on per-cpu pagevec after drain the local cpu, and then decide
whether or not to call lru_add_drain_all().
After I applied it with a hotfix to our production environment, most of
the lru_add_drain_all() can be avoided.
Suggested-by: Mel Gorman <mgorman@suse.de>
Signed-off-by: Yafang Shao <laoar.shao@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Acked-by: Mel Gorman <mgorman@suse.de>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Link: https://lkml.kernel.org/r/20200923133318.14373-1-laoar.shao@gmail.com
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2020-10-14 02:51:47 +03:00
pgoff_t start , pgoff_t end , unsigned long * nr_pagevec )
2005-04-17 02:20:36 +04:00
{
2014-04-04 01:47:46 +04:00
pgoff_t indices [ PAGEVEC_SIZE ] ;
2021-12-07 22:15:07 +03:00
struct folio_batch fbatch ;
2011-07-26 04:12:25 +04:00
pgoff_t index = start ;
2011-03-23 02:32:52 +03:00
unsigned long ret ;
unsigned long count = 0 ;
2005-04-17 02:20:36 +04:00
int i ;
2021-12-07 22:15:07 +03:00
folio_batch_init ( & fbatch ) ;
2022-10-17 19:17:59 +03:00
while ( find_lock_entries ( mapping , & index , end , & fbatch , indices ) ) {
2021-12-07 22:15:07 +03:00
for ( i = 0 ; i < folio_batch_count ( & fbatch ) ; i + + ) {
2022-02-14 00:38:07 +03:00
struct folio * folio = fbatch . folios [ i ] ;
2006-06-23 13:05:48 +04:00
2022-02-14 00:38:07 +03:00
/* We rely upon deletion not changing folio->index */
2006-06-23 13:05:48 +04:00
2022-02-14 00:38:07 +03:00
if ( xa_is_value ( folio ) ) {
2021-09-03 00:53:24 +03:00
count + = invalidate_exceptional_entry ( mapping ,
2022-10-17 19:17:59 +03:00
indices [ i ] , folio ) ;
2014-04-04 01:47:46 +04:00
continue ;
}
2016-07-27 01:26:07 +03:00
2022-02-14 00:38:07 +03:00
ret = mapping_evict_folio ( mapping , folio ) ;
folio_unlock ( folio ) ;
2011-03-23 02:32:52 +03:00
/*
2022-02-14 00:38:07 +03:00
* Invalidation is a hint that the folio is no longer
2011-03-23 02:32:52 +03:00
* of interest and try to speed up its reclaim .
*/
mm, fadvise: improve the expensive remote LRU cache draining after FADV_DONTNEED
Our users reported that there're some random latency spikes when their RT
process is running. Finally we found that latency spike is caused by
FADV_DONTNEED. Which may call lru_add_drain_all() to drain LRU cache on
remote CPUs, and then waits the per-cpu work to complete. The wait time
is uncertain, which may be tens millisecond.
That behavior is unreasonable, because this process is bound to a specific
CPU and the file is only accessed by itself, IOW, there should be no
pagecache pages on a per-cpu pagevec of a remote CPU. That unreasonable
behavior is partially caused by the wrong comparation of the number of
invalidated pages and the number of the target. For example,
if (count < (end_index - start_index + 1))
The count above is how many pages were invalidated in the local CPU, and
(end_index - start_index + 1) is how many pages should be invalidated.
The usage of (end_index - start_index + 1) is incorrect, because they are
virtual addresses, which may not mapped to pages. Besides that, there may
be holes between start and end. So we'd better check whether there are
still pages on per-cpu pagevec after drain the local cpu, and then decide
whether or not to call lru_add_drain_all().
After I applied it with a hotfix to our production environment, most of
the lru_add_drain_all() can be avoided.
Suggested-by: Mel Gorman <mgorman@suse.de>
Signed-off-by: Yafang Shao <laoar.shao@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Acked-by: Mel Gorman <mgorman@suse.de>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Link: https://lkml.kernel.org/r/20200923133318.14373-1-laoar.shao@gmail.com
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2020-10-14 02:51:47 +03:00
if ( ! ret ) {
2022-02-14 00:40:24 +03:00
deactivate_file_folio ( folio ) ;
mm, fadvise: improve the expensive remote LRU cache draining after FADV_DONTNEED
Our users reported that there're some random latency spikes when their RT
process is running. Finally we found that latency spike is caused by
FADV_DONTNEED. Which may call lru_add_drain_all() to drain LRU cache on
remote CPUs, and then waits the per-cpu work to complete. The wait time
is uncertain, which may be tens millisecond.
That behavior is unreasonable, because this process is bound to a specific
CPU and the file is only accessed by itself, IOW, there should be no
pagecache pages on a per-cpu pagevec of a remote CPU. That unreasonable
behavior is partially caused by the wrong comparation of the number of
invalidated pages and the number of the target. For example,
if (count < (end_index - start_index + 1))
The count above is how many pages were invalidated in the local CPU, and
(end_index - start_index + 1) is how many pages should be invalidated.
The usage of (end_index - start_index + 1) is incorrect, because they are
virtual addresses, which may not mapped to pages. Besides that, there may
be holes between start and end. So we'd better check whether there are
still pages on per-cpu pagevec after drain the local cpu, and then decide
whether or not to call lru_add_drain_all().
After I applied it with a hotfix to our production environment, most of
the lru_add_drain_all() can be avoided.
Suggested-by: Mel Gorman <mgorman@suse.de>
Signed-off-by: Yafang Shao <laoar.shao@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Acked-by: Mel Gorman <mgorman@suse.de>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Link: https://lkml.kernel.org/r/20200923133318.14373-1-laoar.shao@gmail.com
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2020-10-14 02:51:47 +03:00
/* It is likely on the pagevec of a remote CPU */
if ( nr_pagevec )
( * nr_pagevec ) + + ;
}
2011-03-23 02:32:52 +03:00
count + = ret ;
2005-04-17 02:20:36 +04:00
}
2021-12-07 22:15:07 +03:00
folio_batch_remove_exceptionals ( & fbatch ) ;
folio_batch_release ( & fbatch ) ;
2009-06-17 02:32:59 +04:00
cond_resched ( ) ;
2005-04-17 02:20:36 +04:00
}
2011-03-23 02:32:52 +03:00
return count ;
2005-04-17 02:20:36 +04:00
}
mm, fadvise: improve the expensive remote LRU cache draining after FADV_DONTNEED
Our users reported that there're some random latency spikes when their RT
process is running. Finally we found that latency spike is caused by
FADV_DONTNEED. Which may call lru_add_drain_all() to drain LRU cache on
remote CPUs, and then waits the per-cpu work to complete. The wait time
is uncertain, which may be tens millisecond.
That behavior is unreasonable, because this process is bound to a specific
CPU and the file is only accessed by itself, IOW, there should be no
pagecache pages on a per-cpu pagevec of a remote CPU. That unreasonable
behavior is partially caused by the wrong comparation of the number of
invalidated pages and the number of the target. For example,
if (count < (end_index - start_index + 1))
The count above is how many pages were invalidated in the local CPU, and
(end_index - start_index + 1) is how many pages should be invalidated.
The usage of (end_index - start_index + 1) is incorrect, because they are
virtual addresses, which may not mapped to pages. Besides that, there may
be holes between start and end. So we'd better check whether there are
still pages on per-cpu pagevec after drain the local cpu, and then decide
whether or not to call lru_add_drain_all().
After I applied it with a hotfix to our production environment, most of
the lru_add_drain_all() can be avoided.
Suggested-by: Mel Gorman <mgorman@suse.de>
Signed-off-by: Yafang Shao <laoar.shao@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Acked-by: Mel Gorman <mgorman@suse.de>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Link: https://lkml.kernel.org/r/20200923133318.14373-1-laoar.shao@gmail.com
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2020-10-14 02:51:47 +03:00
/**
2021-09-03 00:53:24 +03:00
* invalidate_mapping_pages - Invalidate all clean , unlocked cache of one inode
* @ mapping : the address_space which holds the cache to invalidate
mm, fadvise: improve the expensive remote LRU cache draining after FADV_DONTNEED
Our users reported that there're some random latency spikes when their RT
process is running. Finally we found that latency spike is caused by
FADV_DONTNEED. Which may call lru_add_drain_all() to drain LRU cache on
remote CPUs, and then waits the per-cpu work to complete. The wait time
is uncertain, which may be tens millisecond.
That behavior is unreasonable, because this process is bound to a specific
CPU and the file is only accessed by itself, IOW, there should be no
pagecache pages on a per-cpu pagevec of a remote CPU. That unreasonable
behavior is partially caused by the wrong comparation of the number of
invalidated pages and the number of the target. For example,
if (count < (end_index - start_index + 1))
The count above is how many pages were invalidated in the local CPU, and
(end_index - start_index + 1) is how many pages should be invalidated.
The usage of (end_index - start_index + 1) is incorrect, because they are
virtual addresses, which may not mapped to pages. Besides that, there may
be holes between start and end. So we'd better check whether there are
still pages on per-cpu pagevec after drain the local cpu, and then decide
whether or not to call lru_add_drain_all().
After I applied it with a hotfix to our production environment, most of
the lru_add_drain_all() can be avoided.
Suggested-by: Mel Gorman <mgorman@suse.de>
Signed-off-by: Yafang Shao <laoar.shao@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Acked-by: Mel Gorman <mgorman@suse.de>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Link: https://lkml.kernel.org/r/20200923133318.14373-1-laoar.shao@gmail.com
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2020-10-14 02:51:47 +03:00
* @ start : the offset ' from ' which to invalidate
* @ end : the offset ' to ' which to invalidate ( inclusive )
*
2021-09-03 00:53:24 +03:00
* This function removes pages that are clean , unmapped and unlocked ,
* as well as shadow entries . It will not block on IO activity .
mm, fadvise: improve the expensive remote LRU cache draining after FADV_DONTNEED
Our users reported that there're some random latency spikes when their RT
process is running. Finally we found that latency spike is caused by
FADV_DONTNEED. Which may call lru_add_drain_all() to drain LRU cache on
remote CPUs, and then waits the per-cpu work to complete. The wait time
is uncertain, which may be tens millisecond.
That behavior is unreasonable, because this process is bound to a specific
CPU and the file is only accessed by itself, IOW, there should be no
pagecache pages on a per-cpu pagevec of a remote CPU. That unreasonable
behavior is partially caused by the wrong comparation of the number of
invalidated pages and the number of the target. For example,
if (count < (end_index - start_index + 1))
The count above is how many pages were invalidated in the local CPU, and
(end_index - start_index + 1) is how many pages should be invalidated.
The usage of (end_index - start_index + 1) is incorrect, because they are
virtual addresses, which may not mapped to pages. Besides that, there may
be holes between start and end. So we'd better check whether there are
still pages on per-cpu pagevec after drain the local cpu, and then decide
whether or not to call lru_add_drain_all().
After I applied it with a hotfix to our production environment, most of
the lru_add_drain_all() can be avoided.
Suggested-by: Mel Gorman <mgorman@suse.de>
Signed-off-by: Yafang Shao <laoar.shao@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Acked-by: Mel Gorman <mgorman@suse.de>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Link: https://lkml.kernel.org/r/20200923133318.14373-1-laoar.shao@gmail.com
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2020-10-14 02:51:47 +03:00
*
2021-09-03 00:53:24 +03:00
* If you want to remove all the pages of one inode , regardless of
* their use and writeback state , use truncate_inode_pages ( ) .
mm, fadvise: improve the expensive remote LRU cache draining after FADV_DONTNEED
Our users reported that there're some random latency spikes when their RT
process is running. Finally we found that latency spike is caused by
FADV_DONTNEED. Which may call lru_add_drain_all() to drain LRU cache on
remote CPUs, and then waits the per-cpu work to complete. The wait time
is uncertain, which may be tens millisecond.
That behavior is unreasonable, because this process is bound to a specific
CPU and the file is only accessed by itself, IOW, there should be no
pagecache pages on a per-cpu pagevec of a remote CPU. That unreasonable
behavior is partially caused by the wrong comparation of the number of
invalidated pages and the number of the target. For example,
if (count < (end_index - start_index + 1))
The count above is how many pages were invalidated in the local CPU, and
(end_index - start_index + 1) is how many pages should be invalidated.
The usage of (end_index - start_index + 1) is incorrect, because they are
virtual addresses, which may not mapped to pages. Besides that, there may
be holes between start and end. So we'd better check whether there are
still pages on per-cpu pagevec after drain the local cpu, and then decide
whether or not to call lru_add_drain_all().
After I applied it with a hotfix to our production environment, most of
the lru_add_drain_all() can be avoided.
Suggested-by: Mel Gorman <mgorman@suse.de>
Signed-off-by: Yafang Shao <laoar.shao@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Acked-by: Mel Gorman <mgorman@suse.de>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Link: https://lkml.kernel.org/r/20200923133318.14373-1-laoar.shao@gmail.com
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2020-10-14 02:51:47 +03:00
*
2021-09-03 00:53:24 +03:00
* Return : the number of the cache entries that were invalidated
mm, fadvise: improve the expensive remote LRU cache draining after FADV_DONTNEED
Our users reported that there're some random latency spikes when their RT
process is running. Finally we found that latency spike is caused by
FADV_DONTNEED. Which may call lru_add_drain_all() to drain LRU cache on
remote CPUs, and then waits the per-cpu work to complete. The wait time
is uncertain, which may be tens millisecond.
That behavior is unreasonable, because this process is bound to a specific
CPU and the file is only accessed by itself, IOW, there should be no
pagecache pages on a per-cpu pagevec of a remote CPU. That unreasonable
behavior is partially caused by the wrong comparation of the number of
invalidated pages and the number of the target. For example,
if (count < (end_index - start_index + 1))
The count above is how many pages were invalidated in the local CPU, and
(end_index - start_index + 1) is how many pages should be invalidated.
The usage of (end_index - start_index + 1) is incorrect, because they are
virtual addresses, which may not mapped to pages. Besides that, there may
be holes between start and end. So we'd better check whether there are
still pages on per-cpu pagevec after drain the local cpu, and then decide
whether or not to call lru_add_drain_all().
After I applied it with a hotfix to our production environment, most of
the lru_add_drain_all() can be avoided.
Suggested-by: Mel Gorman <mgorman@suse.de>
Signed-off-by: Yafang Shao <laoar.shao@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Acked-by: Mel Gorman <mgorman@suse.de>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Link: https://lkml.kernel.org/r/20200923133318.14373-1-laoar.shao@gmail.com
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2020-10-14 02:51:47 +03:00
*/
unsigned long invalidate_mapping_pages ( struct address_space * mapping ,
pgoff_t start , pgoff_t end )
{
2022-02-14 01:22:10 +03:00
return invalidate_mapping_pagevec ( mapping , start , end , NULL ) ;
mm, fadvise: improve the expensive remote LRU cache draining after FADV_DONTNEED
Our users reported that there're some random latency spikes when their RT
process is running. Finally we found that latency spike is caused by
FADV_DONTNEED. Which may call lru_add_drain_all() to drain LRU cache on
remote CPUs, and then waits the per-cpu work to complete. The wait time
is uncertain, which may be tens millisecond.
That behavior is unreasonable, because this process is bound to a specific
CPU and the file is only accessed by itself, IOW, there should be no
pagecache pages on a per-cpu pagevec of a remote CPU. That unreasonable
behavior is partially caused by the wrong comparation of the number of
invalidated pages and the number of the target. For example,
if (count < (end_index - start_index + 1))
The count above is how many pages were invalidated in the local CPU, and
(end_index - start_index + 1) is how many pages should be invalidated.
The usage of (end_index - start_index + 1) is incorrect, because they are
virtual addresses, which may not mapped to pages. Besides that, there may
be holes between start and end. So we'd better check whether there are
still pages on per-cpu pagevec after drain the local cpu, and then decide
whether or not to call lru_add_drain_all().
After I applied it with a hotfix to our production environment, most of
the lru_add_drain_all() can be avoided.
Suggested-by: Mel Gorman <mgorman@suse.de>
Signed-off-by: Yafang Shao <laoar.shao@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Acked-by: Mel Gorman <mgorman@suse.de>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Link: https://lkml.kernel.org/r/20200923133318.14373-1-laoar.shao@gmail.com
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2020-10-14 02:51:47 +03:00
}
2007-02-10 12:45:38 +03:00
EXPORT_SYMBOL ( invalidate_mapping_pages ) ;
2005-04-17 02:20:36 +04:00
2006-10-01 10:29:29 +04:00
/*
2022-02-12 23:27:42 +03:00
* This is like invalidate_inode_page ( ) , except it ignores the page ' s
2006-10-01 10:29:29 +04:00
* refcount . We do this because invalidate_inode_pages2 ( ) needs stronger
* invalidation guarantees , and cannot afford to leave pages behind because
2007-07-16 10:38:09 +04:00
* shrink_page_list ( ) has a temp ref on them , or because they ' re transiently
2022-11-01 20:53:26 +03:00
* sitting in the folio_add_lru ( ) pagevecs .
2006-10-01 10:29:29 +04:00
*/
2021-07-28 22:52:34 +03:00
static int invalidate_complete_folio2 ( struct address_space * mapping ,
struct folio * folio )
2006-10-01 10:29:29 +04:00
{
2021-07-28 22:52:34 +03:00
if ( folio - > mapping ! = mapping )
2006-10-01 10:29:29 +04:00
return 0 ;
2021-07-28 22:52:34 +03:00
if ( folio_has_private ( folio ) & &
! filemap_release_folio ( folio , GFP_KERNEL ) )
2006-10-01 10:29:29 +04:00
return 0 ;
vfs: keep inodes with page cache off the inode shrinker LRU
Historically (pre-2.5), the inode shrinker used to reclaim only empty
inodes and skip over those that still contained page cache. This caused
problems on highmem hosts: struct inode could put fill lowmem zones
before the cache was getting reclaimed in the highmem zones.
To address this, the inode shrinker started to strip page cache to
facilitate reclaiming lowmem. However, this comes with its own set of
problems: the shrinkers may drop actively used page cache just because
the inodes are not currently open or dirty - think working with a large
git tree. It further doesn't respect cgroup memory protection settings
and can cause priority inversions between containers.
Nowadays, the page cache also holds non-resident info for evicted cache
pages in order to detect refaults. We've come to rely heavily on this
data inside reclaim for protecting the cache workingset and driving swap
behavior. We also use it to quantify and report workload health through
psi. The latter in turn is used for fleet health monitoring, as well as
driving automated memory sizing of workloads and containers, proactive
reclaim and memory offloading schemes.
The consequences of dropping page cache prematurely is that we're seeing
subtle and not-so-subtle failures in all of the above-mentioned
scenarios, with the workload generally entering unexpected thrashing
states while losing the ability to reliably detect it.
To fix this on non-highmem systems at least, going back to rotating
inodes on the LRU isn't feasible. We've tried (commit a76cf1a474d7
("mm: don't reclaim inodes with many attached pages")) and failed
(commit 69056ee6a8a3 ("Revert "mm: don't reclaim inodes with many
attached pages"")).
The issue is mostly that shrinker pools attract pressure based on their
size, and when objects get skipped the shrinkers remember this as
deferred reclaim work. This accumulates excessive pressure on the
remaining inodes, and we can quickly eat into heavily used ones, or
dirty ones that require IO to reclaim, when there potentially is plenty
of cold, clean cache around still.
Instead, this patch keeps populated inodes off the inode LRU in the
first place - just like an open file or dirty state would. An otherwise
clean and unused inode then gets queued when the last cache entry
disappears. This solves the problem without reintroducing the reclaim
issues, and generally is a bit more scalable than having to wade through
potentially hundreds of thousands of busy inodes.
Locking is a bit tricky because the locks protecting the inode state
(i_lock) and the inode LRU (lru_list.lock) don't nest inside the
irq-safe page cache lock (i_pages.xa_lock). Page cache deletions are
serialized through i_lock, taken before the i_pages lock, to make sure
depopulated inodes are queued reliably. Additions may race with
deletions, but we'll check again in the shrinker. If additions race
with the shrinker itself, we're protected by the i_lock: if find_inode()
or iput() win, the shrinker will bail on the elevated i_count or
I_REFERENCED; if the shrinker wins and goes ahead with the inode, it
will set I_FREEING and inhibit further igets(), which will cause the
other side to create a new instance of the inode instead.
Link: https://lkml.kernel.org/r/20210614211904.14420-4-hannes@cmpxchg.org
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Cc: Roman Gushchin <guro@fb.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Dave Chinner <david@fromorbit.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-11-09 05:31:24 +03:00
spin_lock ( & mapping - > host - > i_lock ) ;
2021-09-03 00:53:18 +03:00
xa_lock_irq ( & mapping - > i_pages ) ;
2021-07-28 22:52:34 +03:00
if ( folio_test_dirty ( folio ) )
2006-10-01 10:29:29 +04:00
goto failed ;
2021-07-28 22:52:34 +03:00
BUG_ON ( folio_has_private ( folio ) ) ;
__filemap_remove_folio ( folio , NULL ) ;
2021-09-03 00:53:18 +03:00
xa_unlock_irq ( & mapping - > i_pages ) ;
vfs: keep inodes with page cache off the inode shrinker LRU
Historically (pre-2.5), the inode shrinker used to reclaim only empty
inodes and skip over those that still contained page cache. This caused
problems on highmem hosts: struct inode could put fill lowmem zones
before the cache was getting reclaimed in the highmem zones.
To address this, the inode shrinker started to strip page cache to
facilitate reclaiming lowmem. However, this comes with its own set of
problems: the shrinkers may drop actively used page cache just because
the inodes are not currently open or dirty - think working with a large
git tree. It further doesn't respect cgroup memory protection settings
and can cause priority inversions between containers.
Nowadays, the page cache also holds non-resident info for evicted cache
pages in order to detect refaults. We've come to rely heavily on this
data inside reclaim for protecting the cache workingset and driving swap
behavior. We also use it to quantify and report workload health through
psi. The latter in turn is used for fleet health monitoring, as well as
driving automated memory sizing of workloads and containers, proactive
reclaim and memory offloading schemes.
The consequences of dropping page cache prematurely is that we're seeing
subtle and not-so-subtle failures in all of the above-mentioned
scenarios, with the workload generally entering unexpected thrashing
states while losing the ability to reliably detect it.
To fix this on non-highmem systems at least, going back to rotating
inodes on the LRU isn't feasible. We've tried (commit a76cf1a474d7
("mm: don't reclaim inodes with many attached pages")) and failed
(commit 69056ee6a8a3 ("Revert "mm: don't reclaim inodes with many
attached pages"")).
The issue is mostly that shrinker pools attract pressure based on their
size, and when objects get skipped the shrinkers remember this as
deferred reclaim work. This accumulates excessive pressure on the
remaining inodes, and we can quickly eat into heavily used ones, or
dirty ones that require IO to reclaim, when there potentially is plenty
of cold, clean cache around still.
Instead, this patch keeps populated inodes off the inode LRU in the
first place - just like an open file or dirty state would. An otherwise
clean and unused inode then gets queued when the last cache entry
disappears. This solves the problem without reintroducing the reclaim
issues, and generally is a bit more scalable than having to wade through
potentially hundreds of thousands of busy inodes.
Locking is a bit tricky because the locks protecting the inode state
(i_lock) and the inode LRU (lru_list.lock) don't nest inside the
irq-safe page cache lock (i_pages.xa_lock). Page cache deletions are
serialized through i_lock, taken before the i_pages lock, to make sure
depopulated inodes are queued reliably. Additions may race with
deletions, but we'll check again in the shrinker. If additions race
with the shrinker itself, we're protected by the i_lock: if find_inode()
or iput() win, the shrinker will bail on the elevated i_count or
I_REFERENCED; if the shrinker wins and goes ahead with the inode, it
will set I_FREEING and inhibit further igets(), which will cause the
other side to create a new instance of the inode instead.
Link: https://lkml.kernel.org/r/20210614211904.14420-4-hannes@cmpxchg.org
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Cc: Roman Gushchin <guro@fb.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Dave Chinner <david@fromorbit.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-11-09 05:31:24 +03:00
if ( mapping_shrinkable ( mapping ) )
inode_add_lru ( mapping - > host ) ;
spin_unlock ( & mapping - > host - > i_lock ) ;
2010-12-01 21:35:19 +03:00
2021-07-28 22:52:34 +03:00
filemap_free_folio ( mapping , folio ) ;
2006-10-01 10:29:29 +04:00
return 1 ;
failed :
2021-09-03 00:53:18 +03:00
xa_unlock_irq ( & mapping - > i_pages ) ;
vfs: keep inodes with page cache off the inode shrinker LRU
Historically (pre-2.5), the inode shrinker used to reclaim only empty
inodes and skip over those that still contained page cache. This caused
problems on highmem hosts: struct inode could put fill lowmem zones
before the cache was getting reclaimed in the highmem zones.
To address this, the inode shrinker started to strip page cache to
facilitate reclaiming lowmem. However, this comes with its own set of
problems: the shrinkers may drop actively used page cache just because
the inodes are not currently open or dirty - think working with a large
git tree. It further doesn't respect cgroup memory protection settings
and can cause priority inversions between containers.
Nowadays, the page cache also holds non-resident info for evicted cache
pages in order to detect refaults. We've come to rely heavily on this
data inside reclaim for protecting the cache workingset and driving swap
behavior. We also use it to quantify and report workload health through
psi. The latter in turn is used for fleet health monitoring, as well as
driving automated memory sizing of workloads and containers, proactive
reclaim and memory offloading schemes.
The consequences of dropping page cache prematurely is that we're seeing
subtle and not-so-subtle failures in all of the above-mentioned
scenarios, with the workload generally entering unexpected thrashing
states while losing the ability to reliably detect it.
To fix this on non-highmem systems at least, going back to rotating
inodes on the LRU isn't feasible. We've tried (commit a76cf1a474d7
("mm: don't reclaim inodes with many attached pages")) and failed
(commit 69056ee6a8a3 ("Revert "mm: don't reclaim inodes with many
attached pages"")).
The issue is mostly that shrinker pools attract pressure based on their
size, and when objects get skipped the shrinkers remember this as
deferred reclaim work. This accumulates excessive pressure on the
remaining inodes, and we can quickly eat into heavily used ones, or
dirty ones that require IO to reclaim, when there potentially is plenty
of cold, clean cache around still.
Instead, this patch keeps populated inodes off the inode LRU in the
first place - just like an open file or dirty state would. An otherwise
clean and unused inode then gets queued when the last cache entry
disappears. This solves the problem without reintroducing the reclaim
issues, and generally is a bit more scalable than having to wade through
potentially hundreds of thousands of busy inodes.
Locking is a bit tricky because the locks protecting the inode state
(i_lock) and the inode LRU (lru_list.lock) don't nest inside the
irq-safe page cache lock (i_pages.xa_lock). Page cache deletions are
serialized through i_lock, taken before the i_pages lock, to make sure
depopulated inodes are queued reliably. Additions may race with
deletions, but we'll check again in the shrinker. If additions race
with the shrinker itself, we're protected by the i_lock: if find_inode()
or iput() win, the shrinker will bail on the elevated i_count or
I_REFERENCED; if the shrinker wins and goes ahead with the inode, it
will set I_FREEING and inhibit further igets(), which will cause the
other side to create a new instance of the inode instead.
Link: https://lkml.kernel.org/r/20210614211904.14420-4-hannes@cmpxchg.org
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Cc: Roman Gushchin <guro@fb.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Dave Chinner <david@fromorbit.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-11-09 05:31:24 +03:00
spin_unlock ( & mapping - > host - > i_lock ) ;
2006-10-01 10:29:29 +04:00
return 0 ;
}
2022-02-09 23:21:52 +03:00
static int folio_launder ( struct address_space * mapping , struct folio * folio )
2007-01-11 10:15:39 +03:00
{
2021-05-20 15:17:44 +03:00
if ( ! folio_test_dirty ( folio ) )
2007-01-11 10:15:39 +03:00
return 0 ;
2022-02-09 23:21:52 +03:00
if ( folio - > mapping ! = mapping | | mapping - > a_ops - > launder_folio = = NULL )
2007-01-11 10:15:39 +03:00
return 0 ;
2022-02-09 23:21:52 +03:00
return mapping - > a_ops - > launder_folio ( folio ) ;
2007-01-11 10:15:39 +03:00
}
2005-04-17 02:20:36 +04:00
/**
* invalidate_inode_pages2_range - remove range of pages from an address_space
2005-05-01 19:59:26 +04:00
* @ mapping : the address_space
2005-04-17 02:20:36 +04:00
* @ start : the page offset ' from ' which to invalidate
* @ end : the page offset ' to ' which to invalidate ( inclusive )
*
* Any pages which are found to be mapped into pagetables are unmapped prior to
* invalidation .
*
2019-03-06 02:48:42 +03:00
* Return : - EBUSY if any pages could not be invalidated .
2005-04-17 02:20:36 +04:00
*/
int invalidate_inode_pages2_range ( struct address_space * mapping ,
pgoff_t start , pgoff_t end )
{
2014-04-04 01:47:46 +04:00
pgoff_t indices [ PAGEVEC_SIZE ] ;
2020-09-02 06:17:50 +03:00
struct folio_batch fbatch ;
2011-07-26 04:12:25 +04:00
pgoff_t index ;
2005-04-17 02:20:36 +04:00
int i ;
int ret = 0 ;
2008-04-28 13:12:08 +04:00
int ret2 = 0 ;
2005-04-17 02:20:36 +04:00
int did_range_unmap = 0 ;
2021-05-05 04:32:45 +03:00
if ( mapping_empty ( mapping ) )
2022-01-22 09:14:34 +03:00
return 0 ;
2017-05-04 00:56:06 +03:00
2020-09-02 06:17:50 +03:00
folio_batch_init ( & fbatch ) ;
2011-07-26 04:12:25 +04:00
index = start ;
2022-10-17 19:18:00 +03:00
while ( find_get_entries ( mapping , & index , end , & fbatch , indices ) ) {
2020-09-02 06:17:50 +03:00
for ( i = 0 ; i < folio_batch_count ( & fbatch ) ; i + + ) {
struct folio * folio = fbatch . folios [ i ] ;
2011-07-26 04:12:25 +04:00
2021-12-03 07:25:01 +03:00
/* We rely upon deletion not changing folio->index */
2005-04-17 02:20:36 +04:00
2020-09-02 06:17:50 +03:00
if ( xa_is_value ( folio ) ) {
2016-08-10 18:22:44 +03:00
if ( ! invalidate_exceptional_entry2 ( mapping ,
2022-10-17 19:18:00 +03:00
indices [ i ] , folio ) )
2016-08-10 18:22:44 +03:00
ret = - EBUSY ;
2014-04-04 01:47:46 +04:00
continue ;
}
2021-12-03 07:25:01 +03:00
if ( ! did_range_unmap & & folio_mapped ( folio ) ) {
mm/thp: unmap_mapping_page() to fix THP truncate_cleanup_page()
There is a race between THP unmapping and truncation, when truncate sees
pmd_none() and skips the entry, after munmap's zap_huge_pmd() cleared
it, but before its page_remove_rmap() gets to decrement
compound_mapcount: generating false "BUG: Bad page cache" reports that
the page is still mapped when deleted. This commit fixes that, but not
in the way I hoped.
The first attempt used try_to_unmap(page, TTU_SYNC|TTU_IGNORE_MLOCK)
instead of unmap_mapping_range() in truncate_cleanup_page(): it has
often been an annoyance that we usually call unmap_mapping_range() with
no pages locked, but there apply it to a single locked page.
try_to_unmap() looks more suitable for a single locked page.
However, try_to_unmap_one() contains a VM_BUG_ON_PAGE(!pvmw.pte,page):
it is used to insert THP migration entries, but not used to unmap THPs.
Copy zap_huge_pmd() and add THP handling now? Perhaps, but their TLB
needs are different, I'm too ignorant of the DAX cases, and couldn't
decide how far to go for anon+swap. Set that aside.
The second attempt took a different tack: make no change in truncate.c,
but modify zap_huge_pmd() to insert an invalidated huge pmd instead of
clearing it initially, then pmd_clear() between page_remove_rmap() and
unlocking at the end. Nice. But powerpc blows that approach out of the
water, with its serialize_against_pte_lookup(), and interesting pgtable
usage. It would need serious help to get working on powerpc (with a
minor optimization issue on s390 too). Set that aside.
Just add an "if (page_mapped(page)) synchronize_rcu();" or other such
delay, after unmapping in truncate_cleanup_page()? Perhaps, but though
that's likely to reduce or eliminate the number of incidents, it would
give less assurance of whether we had identified the problem correctly.
This successful iteration introduces "unmap_mapping_page(page)" instead
of try_to_unmap(), and goes the usual unmap_mapping_range_tree() route,
with an addition to details. Then zap_pmd_range() watches for this
case, and does spin_unlock(pmd_lock) if so - just like
page_vma_mapped_walk() now does in the PVMW_SYNC case. Not pretty, but
safe.
Note that unmap_mapping_page() is doing a VM_BUG_ON(!PageLocked) to
assert its interface; but currently that's only used to make sure that
page->mapping is stable, and zap_pmd_range() doesn't care if the page is
locked or not. Along these lines, in invalidate_inode_pages2_range()
move the initial unmap_mapping_range() out from under page lock, before
then calling unmap_mapping_page() under page lock if still mapped.
Link: https://lkml.kernel.org/r/a2a4a148-cdd8-942c-4ef8-51b77f643dbe@google.com
Fixes: fc127da085c2 ("truncate: handle file thp")
Signed-off-by: Hugh Dickins <hughd@google.com>
Acked-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Reviewed-by: Yang Shi <shy828301@gmail.com>
Cc: Alistair Popple <apopple@nvidia.com>
Cc: Jan Kara <jack@suse.cz>
Cc: Jue Wang <juew@google.com>
Cc: "Matthew Wilcox (Oracle)" <willy@infradead.org>
Cc: Miaohe Lin <linmiaohe@huawei.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Naoya Horiguchi <naoya.horiguchi@nec.com>
Cc: Oscar Salvador <osalvador@suse.de>
Cc: Peter Xu <peterx@redhat.com>
Cc: Ralph Campbell <rcampbell@nvidia.com>
Cc: Shakeel Butt <shakeelb@google.com>
Cc: Wang Yugui <wangyugui@e16-tech.com>
Cc: Zi Yan <ziy@nvidia.com>
Cc: <stable@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-06-16 04:24:03 +03:00
/*
2021-12-03 07:25:01 +03:00
* If folio is mapped , before taking its lock ,
mm/thp: unmap_mapping_page() to fix THP truncate_cleanup_page()
There is a race between THP unmapping and truncation, when truncate sees
pmd_none() and skips the entry, after munmap's zap_huge_pmd() cleared
it, but before its page_remove_rmap() gets to decrement
compound_mapcount: generating false "BUG: Bad page cache" reports that
the page is still mapped when deleted. This commit fixes that, but not
in the way I hoped.
The first attempt used try_to_unmap(page, TTU_SYNC|TTU_IGNORE_MLOCK)
instead of unmap_mapping_range() in truncate_cleanup_page(): it has
often been an annoyance that we usually call unmap_mapping_range() with
no pages locked, but there apply it to a single locked page.
try_to_unmap() looks more suitable for a single locked page.
However, try_to_unmap_one() contains a VM_BUG_ON_PAGE(!pvmw.pte,page):
it is used to insert THP migration entries, but not used to unmap THPs.
Copy zap_huge_pmd() and add THP handling now? Perhaps, but their TLB
needs are different, I'm too ignorant of the DAX cases, and couldn't
decide how far to go for anon+swap. Set that aside.
The second attempt took a different tack: make no change in truncate.c,
but modify zap_huge_pmd() to insert an invalidated huge pmd instead of
clearing it initially, then pmd_clear() between page_remove_rmap() and
unlocking at the end. Nice. But powerpc blows that approach out of the
water, with its serialize_against_pte_lookup(), and interesting pgtable
usage. It would need serious help to get working on powerpc (with a
minor optimization issue on s390 too). Set that aside.
Just add an "if (page_mapped(page)) synchronize_rcu();" or other such
delay, after unmapping in truncate_cleanup_page()? Perhaps, but though
that's likely to reduce or eliminate the number of incidents, it would
give less assurance of whether we had identified the problem correctly.
This successful iteration introduces "unmap_mapping_page(page)" instead
of try_to_unmap(), and goes the usual unmap_mapping_range_tree() route,
with an addition to details. Then zap_pmd_range() watches for this
case, and does spin_unlock(pmd_lock) if so - just like
page_vma_mapped_walk() now does in the PVMW_SYNC case. Not pretty, but
safe.
Note that unmap_mapping_page() is doing a VM_BUG_ON(!PageLocked) to
assert its interface; but currently that's only used to make sure that
page->mapping is stable, and zap_pmd_range() doesn't care if the page is
locked or not. Along these lines, in invalidate_inode_pages2_range()
move the initial unmap_mapping_range() out from under page lock, before
then calling unmap_mapping_page() under page lock if still mapped.
Link: https://lkml.kernel.org/r/a2a4a148-cdd8-942c-4ef8-51b77f643dbe@google.com
Fixes: fc127da085c2 ("truncate: handle file thp")
Signed-off-by: Hugh Dickins <hughd@google.com>
Acked-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Reviewed-by: Yang Shi <shy828301@gmail.com>
Cc: Alistair Popple <apopple@nvidia.com>
Cc: Jan Kara <jack@suse.cz>
Cc: Jue Wang <juew@google.com>
Cc: "Matthew Wilcox (Oracle)" <willy@infradead.org>
Cc: Miaohe Lin <linmiaohe@huawei.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Naoya Horiguchi <naoya.horiguchi@nec.com>
Cc: Oscar Salvador <osalvador@suse.de>
Cc: Peter Xu <peterx@redhat.com>
Cc: Ralph Campbell <rcampbell@nvidia.com>
Cc: Shakeel Butt <shakeelb@google.com>
Cc: Wang Yugui <wangyugui@e16-tech.com>
Cc: Zi Yan <ziy@nvidia.com>
Cc: <stable@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-06-16 04:24:03 +03:00
* zap the rest of the file in one hit .
*/
2022-10-17 19:18:00 +03:00
unmap_mapping_pages ( mapping , indices [ i ] ,
( 1 + end - indices [ i ] ) , false ) ;
mm/thp: unmap_mapping_page() to fix THP truncate_cleanup_page()
There is a race between THP unmapping and truncation, when truncate sees
pmd_none() and skips the entry, after munmap's zap_huge_pmd() cleared
it, but before its page_remove_rmap() gets to decrement
compound_mapcount: generating false "BUG: Bad page cache" reports that
the page is still mapped when deleted. This commit fixes that, but not
in the way I hoped.
The first attempt used try_to_unmap(page, TTU_SYNC|TTU_IGNORE_MLOCK)
instead of unmap_mapping_range() in truncate_cleanup_page(): it has
often been an annoyance that we usually call unmap_mapping_range() with
no pages locked, but there apply it to a single locked page.
try_to_unmap() looks more suitable for a single locked page.
However, try_to_unmap_one() contains a VM_BUG_ON_PAGE(!pvmw.pte,page):
it is used to insert THP migration entries, but not used to unmap THPs.
Copy zap_huge_pmd() and add THP handling now? Perhaps, but their TLB
needs are different, I'm too ignorant of the DAX cases, and couldn't
decide how far to go for anon+swap. Set that aside.
The second attempt took a different tack: make no change in truncate.c,
but modify zap_huge_pmd() to insert an invalidated huge pmd instead of
clearing it initially, then pmd_clear() between page_remove_rmap() and
unlocking at the end. Nice. But powerpc blows that approach out of the
water, with its serialize_against_pte_lookup(), and interesting pgtable
usage. It would need serious help to get working on powerpc (with a
minor optimization issue on s390 too). Set that aside.
Just add an "if (page_mapped(page)) synchronize_rcu();" or other such
delay, after unmapping in truncate_cleanup_page()? Perhaps, but though
that's likely to reduce or eliminate the number of incidents, it would
give less assurance of whether we had identified the problem correctly.
This successful iteration introduces "unmap_mapping_page(page)" instead
of try_to_unmap(), and goes the usual unmap_mapping_range_tree() route,
with an addition to details. Then zap_pmd_range() watches for this
case, and does spin_unlock(pmd_lock) if so - just like
page_vma_mapped_walk() now does in the PVMW_SYNC case. Not pretty, but
safe.
Note that unmap_mapping_page() is doing a VM_BUG_ON(!PageLocked) to
assert its interface; but currently that's only used to make sure that
page->mapping is stable, and zap_pmd_range() doesn't care if the page is
locked or not. Along these lines, in invalidate_inode_pages2_range()
move the initial unmap_mapping_range() out from under page lock, before
then calling unmap_mapping_page() under page lock if still mapped.
Link: https://lkml.kernel.org/r/a2a4a148-cdd8-942c-4ef8-51b77f643dbe@google.com
Fixes: fc127da085c2 ("truncate: handle file thp")
Signed-off-by: Hugh Dickins <hughd@google.com>
Acked-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Reviewed-by: Yang Shi <shy828301@gmail.com>
Cc: Alistair Popple <apopple@nvidia.com>
Cc: Jan Kara <jack@suse.cz>
Cc: Jue Wang <juew@google.com>
Cc: "Matthew Wilcox (Oracle)" <willy@infradead.org>
Cc: Miaohe Lin <linmiaohe@huawei.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Naoya Horiguchi <naoya.horiguchi@nec.com>
Cc: Oscar Salvador <osalvador@suse.de>
Cc: Peter Xu <peterx@redhat.com>
Cc: Ralph Campbell <rcampbell@nvidia.com>
Cc: Shakeel Butt <shakeelb@google.com>
Cc: Wang Yugui <wangyugui@e16-tech.com>
Cc: Zi Yan <ziy@nvidia.com>
Cc: <stable@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-06-16 04:24:03 +03:00
did_range_unmap = 1 ;
}
2021-12-03 07:25:01 +03:00
folio_lock ( folio ) ;
2022-10-17 19:18:00 +03:00
VM_BUG_ON_FOLIO ( ! folio_contains ( folio , indices [ i ] ) , folio ) ;
2021-12-03 07:25:01 +03:00
if ( folio - > mapping ! = mapping ) {
folio_unlock ( folio ) ;
2005-04-17 02:20:36 +04:00
continue ;
}
2021-12-03 07:25:01 +03:00
folio_wait_writeback ( folio ) ;
mm/thp: unmap_mapping_page() to fix THP truncate_cleanup_page()
There is a race between THP unmapping and truncation, when truncate sees
pmd_none() and skips the entry, after munmap's zap_huge_pmd() cleared
it, but before its page_remove_rmap() gets to decrement
compound_mapcount: generating false "BUG: Bad page cache" reports that
the page is still mapped when deleted. This commit fixes that, but not
in the way I hoped.
The first attempt used try_to_unmap(page, TTU_SYNC|TTU_IGNORE_MLOCK)
instead of unmap_mapping_range() in truncate_cleanup_page(): it has
often been an annoyance that we usually call unmap_mapping_range() with
no pages locked, but there apply it to a single locked page.
try_to_unmap() looks more suitable for a single locked page.
However, try_to_unmap_one() contains a VM_BUG_ON_PAGE(!pvmw.pte,page):
it is used to insert THP migration entries, but not used to unmap THPs.
Copy zap_huge_pmd() and add THP handling now? Perhaps, but their TLB
needs are different, I'm too ignorant of the DAX cases, and couldn't
decide how far to go for anon+swap. Set that aside.
The second attempt took a different tack: make no change in truncate.c,
but modify zap_huge_pmd() to insert an invalidated huge pmd instead of
clearing it initially, then pmd_clear() between page_remove_rmap() and
unlocking at the end. Nice. But powerpc blows that approach out of the
water, with its serialize_against_pte_lookup(), and interesting pgtable
usage. It would need serious help to get working on powerpc (with a
minor optimization issue on s390 too). Set that aside.
Just add an "if (page_mapped(page)) synchronize_rcu();" or other such
delay, after unmapping in truncate_cleanup_page()? Perhaps, but though
that's likely to reduce or eliminate the number of incidents, it would
give less assurance of whether we had identified the problem correctly.
This successful iteration introduces "unmap_mapping_page(page)" instead
of try_to_unmap(), and goes the usual unmap_mapping_range_tree() route,
with an addition to details. Then zap_pmd_range() watches for this
case, and does spin_unlock(pmd_lock) if so - just like
page_vma_mapped_walk() now does in the PVMW_SYNC case. Not pretty, but
safe.
Note that unmap_mapping_page() is doing a VM_BUG_ON(!PageLocked) to
assert its interface; but currently that's only used to make sure that
page->mapping is stable, and zap_pmd_range() doesn't care if the page is
locked or not. Along these lines, in invalidate_inode_pages2_range()
move the initial unmap_mapping_range() out from under page lock, before
then calling unmap_mapping_page() under page lock if still mapped.
Link: https://lkml.kernel.org/r/a2a4a148-cdd8-942c-4ef8-51b77f643dbe@google.com
Fixes: fc127da085c2 ("truncate: handle file thp")
Signed-off-by: Hugh Dickins <hughd@google.com>
Acked-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Reviewed-by: Yang Shi <shy828301@gmail.com>
Cc: Alistair Popple <apopple@nvidia.com>
Cc: Jan Kara <jack@suse.cz>
Cc: Jue Wang <juew@google.com>
Cc: "Matthew Wilcox (Oracle)" <willy@infradead.org>
Cc: Miaohe Lin <linmiaohe@huawei.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Naoya Horiguchi <naoya.horiguchi@nec.com>
Cc: Oscar Salvador <osalvador@suse.de>
Cc: Peter Xu <peterx@redhat.com>
Cc: Ralph Campbell <rcampbell@nvidia.com>
Cc: Shakeel Butt <shakeelb@google.com>
Cc: Wang Yugui <wangyugui@e16-tech.com>
Cc: Zi Yan <ziy@nvidia.com>
Cc: <stable@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-06-16 04:24:03 +03:00
2021-12-03 07:25:01 +03:00
if ( folio_mapped ( folio ) )
unmap_mapping_folio ( folio ) ;
BUG_ON ( folio_mapped ( folio ) ) ;
mm/thp: unmap_mapping_page() to fix THP truncate_cleanup_page()
There is a race between THP unmapping and truncation, when truncate sees
pmd_none() and skips the entry, after munmap's zap_huge_pmd() cleared
it, but before its page_remove_rmap() gets to decrement
compound_mapcount: generating false "BUG: Bad page cache" reports that
the page is still mapped when deleted. This commit fixes that, but not
in the way I hoped.
The first attempt used try_to_unmap(page, TTU_SYNC|TTU_IGNORE_MLOCK)
instead of unmap_mapping_range() in truncate_cleanup_page(): it has
often been an annoyance that we usually call unmap_mapping_range() with
no pages locked, but there apply it to a single locked page.
try_to_unmap() looks more suitable for a single locked page.
However, try_to_unmap_one() contains a VM_BUG_ON_PAGE(!pvmw.pte,page):
it is used to insert THP migration entries, but not used to unmap THPs.
Copy zap_huge_pmd() and add THP handling now? Perhaps, but their TLB
needs are different, I'm too ignorant of the DAX cases, and couldn't
decide how far to go for anon+swap. Set that aside.
The second attempt took a different tack: make no change in truncate.c,
but modify zap_huge_pmd() to insert an invalidated huge pmd instead of
clearing it initially, then pmd_clear() between page_remove_rmap() and
unlocking at the end. Nice. But powerpc blows that approach out of the
water, with its serialize_against_pte_lookup(), and interesting pgtable
usage. It would need serious help to get working on powerpc (with a
minor optimization issue on s390 too). Set that aside.
Just add an "if (page_mapped(page)) synchronize_rcu();" or other such
delay, after unmapping in truncate_cleanup_page()? Perhaps, but though
that's likely to reduce or eliminate the number of incidents, it would
give less assurance of whether we had identified the problem correctly.
This successful iteration introduces "unmap_mapping_page(page)" instead
of try_to_unmap(), and goes the usual unmap_mapping_range_tree() route,
with an addition to details. Then zap_pmd_range() watches for this
case, and does spin_unlock(pmd_lock) if so - just like
page_vma_mapped_walk() now does in the PVMW_SYNC case. Not pretty, but
safe.
Note that unmap_mapping_page() is doing a VM_BUG_ON(!PageLocked) to
assert its interface; but currently that's only used to make sure that
page->mapping is stable, and zap_pmd_range() doesn't care if the page is
locked or not. Along these lines, in invalidate_inode_pages2_range()
move the initial unmap_mapping_range() out from under page lock, before
then calling unmap_mapping_page() under page lock if still mapped.
Link: https://lkml.kernel.org/r/a2a4a148-cdd8-942c-4ef8-51b77f643dbe@google.com
Fixes: fc127da085c2 ("truncate: handle file thp")
Signed-off-by: Hugh Dickins <hughd@google.com>
Acked-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Reviewed-by: Yang Shi <shy828301@gmail.com>
Cc: Alistair Popple <apopple@nvidia.com>
Cc: Jan Kara <jack@suse.cz>
Cc: Jue Wang <juew@google.com>
Cc: "Matthew Wilcox (Oracle)" <willy@infradead.org>
Cc: Miaohe Lin <linmiaohe@huawei.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Naoya Horiguchi <naoya.horiguchi@nec.com>
Cc: Oscar Salvador <osalvador@suse.de>
Cc: Peter Xu <peterx@redhat.com>
Cc: Ralph Campbell <rcampbell@nvidia.com>
Cc: Shakeel Butt <shakeelb@google.com>
Cc: Wang Yugui <wangyugui@e16-tech.com>
Cc: Zi Yan <ziy@nvidia.com>
Cc: <stable@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-06-16 04:24:03 +03:00
2022-02-09 23:21:52 +03:00
ret2 = folio_launder ( mapping , folio ) ;
2008-04-28 13:12:08 +04:00
if ( ret2 = = 0 ) {
2021-07-28 22:52:34 +03:00
if ( ! invalidate_complete_folio2 ( mapping , folio ) )
2008-09-03 01:35:40 +04:00
ret2 = - EBUSY ;
2008-04-28 13:12:08 +04:00
}
if ( ret2 < 0 )
ret = ret2 ;
2021-12-03 07:25:01 +03:00
folio_unlock ( folio ) ;
2005-04-17 02:20:36 +04:00
}
2020-09-02 06:17:50 +03:00
folio_batch_remove_exceptionals ( & fbatch ) ;
folio_batch_release ( & fbatch ) ;
2005-04-17 02:20:36 +04:00
cond_resched ( ) ;
}
2017-05-13 01:46:50 +03:00
/*
2017-11-26 06:52:46 +03:00
* For DAX we invalidate page tables after invalidating page cache . We
2017-05-13 01:46:50 +03:00
* could invalidate page tables while invalidating each entry however
* that would be expensive . And doing range unmapping before doesn ' t
2017-11-26 06:52:46 +03:00
* work as we have no cheap way to find whether page cache entry didn ' t
2017-05-13 01:46:50 +03:00
* get remapped later .
*/
if ( dax_mapping ( mapping ) ) {
2018-02-01 03:17:36 +03:00
unmap_mapping_pages ( mapping , start , end - start + 1 , false ) ;
2017-05-13 01:46:50 +03:00
}
2005-04-17 02:20:36 +04:00
return ret ;
}
EXPORT_SYMBOL_GPL ( invalidate_inode_pages2_range ) ;
/**
* invalidate_inode_pages2 - remove all pages from an address_space
2005-05-01 19:59:26 +04:00
* @ mapping : the address_space
2005-04-17 02:20:36 +04:00
*
* Any pages which are found to be mapped into pagetables are unmapped prior to
* invalidation .
*
2019-03-06 02:48:42 +03:00
* Return : - EBUSY if any pages could not be invalidated .
2005-04-17 02:20:36 +04:00
*/
int invalidate_inode_pages2 ( struct address_space * mapping )
{
return invalidate_inode_pages2_range ( mapping , 0 , - 1 ) ;
}
EXPORT_SYMBOL_GPL ( invalidate_inode_pages2 ) ;
2009-08-20 20:35:05 +04:00
/**
* truncate_pagecache - unmap and remove pagecache that has been truncated
* @ inode : inode
2011-07-26 04:12:24 +04:00
* @ newsize : new file size
2009-08-20 20:35:05 +04:00
*
* inode ' s new i_size must already be written before truncate_pagecache
* is called .
*
* This function should typically be called before the filesystem
* releases resources associated with the freed range ( eg . deallocates
* blocks ) . This way , pagecache will always stay logically coherent
* with on - disk format , and the filesystem would not have to deal with
* situations such as writepage being called for a page that has already
* had its underlying blocks deallocated .
*/
2013-09-13 02:13:56 +04:00
void truncate_pagecache ( struct inode * inode , loff_t newsize )
2009-08-20 20:35:05 +04:00
{
2010-01-13 15:14:09 +03:00
struct address_space * mapping = inode - > i_mapping ;
2011-07-26 04:12:24 +04:00
loff_t holebegin = round_up ( newsize , PAGE_SIZE ) ;
2010-01-13 15:14:09 +03:00
/*
* unmap_mapping_range is called twice , first simply for
* efficiency so that truncate_inode_pages does fewer
* single - page unmaps . However after this first call , and
* before truncate_inode_pages finishes , it is possible for
* private pages to be COWed , which remain after
* truncate_inode_pages finishes , hence the second
* unmap_mapping_range call must be made for correctness .
*/
2011-07-26 04:12:24 +04:00
unmap_mapping_range ( mapping , holebegin , 0 , 1 ) ;
truncate_inode_pages ( mapping , newsize ) ;
unmap_mapping_range ( mapping , holebegin , 0 , 1 ) ;
2009-08-20 20:35:05 +04:00
}
EXPORT_SYMBOL ( truncate_pagecache ) ;
2010-06-04 13:30:04 +04:00
/**
* truncate_setsize - update inode and pagecache for a new file size
* @ inode : inode
* @ newsize : new file size
*
2011-01-21 01:44:26 +03:00
* truncate_setsize updates i_size and performs pagecache truncation ( if
* necessary ) to @ newsize . It will be typically be called from the filesystem ' s
* setattr function when ATTR_SIZE is passed in .
2010-06-04 13:30:04 +04:00
*
2014-11-07 00:29:25 +03:00
* Must be called with a lock serializing truncates and writes ( generally
2021-04-12 16:50:21 +03:00
* i_rwsem but e . g . xfs uses a different lock ) and before all filesystem
2014-11-07 00:29:25 +03:00
* specific block truncation has been performed .
2010-06-04 13:30:04 +04:00
*/
void truncate_setsize ( struct inode * inode , loff_t newsize )
{
vfs: fix data corruption when blocksize < pagesize for mmaped data
->page_mkwrite() is used by filesystems to allocate blocks under a page
which is becoming writeably mmapped in some process' address space. This
allows a filesystem to return a page fault if there is not enough space
available, user exceeds quota or similar problem happens, rather than
silently discarding data later when writepage is called.
However VFS fails to call ->page_mkwrite() in all the cases where
filesystems need it when blocksize < pagesize. For example when
blocksize = 1024, pagesize = 4096 the following is problematic:
ftruncate(fd, 0);
pwrite(fd, buf, 1024, 0);
map = mmap(NULL, 1024, PROT_WRITE, MAP_SHARED, fd, 0);
map[0] = 'a'; ----> page_mkwrite() for index 0 is called
ftruncate(fd, 10000); /* or even pwrite(fd, buf, 1, 10000) */
mremap(map, 1024, 10000, 0);
map[4095] = 'a'; ----> no page_mkwrite() called
At the moment ->page_mkwrite() is called, filesystem can allocate only
one block for the page because i_size == 1024. Otherwise it would create
blocks beyond i_size which is generally undesirable. But later at
->writepage() time, we also need to store data at offset 4095 but we
don't have block allocated for it.
This patch introduces a helper function filesystems can use to have
->page_mkwrite() called at all the necessary moments.
Signed-off-by: Jan Kara <jack@suse.cz>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
Cc: stable@vger.kernel.org
2014-10-02 05:49:18 +04:00
loff_t oldsize = inode - > i_size ;
2010-06-04 13:30:04 +04:00
i_size_write ( inode , newsize ) ;
vfs: fix data corruption when blocksize < pagesize for mmaped data
->page_mkwrite() is used by filesystems to allocate blocks under a page
which is becoming writeably mmapped in some process' address space. This
allows a filesystem to return a page fault if there is not enough space
available, user exceeds quota or similar problem happens, rather than
silently discarding data later when writepage is called.
However VFS fails to call ->page_mkwrite() in all the cases where
filesystems need it when blocksize < pagesize. For example when
blocksize = 1024, pagesize = 4096 the following is problematic:
ftruncate(fd, 0);
pwrite(fd, buf, 1024, 0);
map = mmap(NULL, 1024, PROT_WRITE, MAP_SHARED, fd, 0);
map[0] = 'a'; ----> page_mkwrite() for index 0 is called
ftruncate(fd, 10000); /* or even pwrite(fd, buf, 1, 10000) */
mremap(map, 1024, 10000, 0);
map[4095] = 'a'; ----> no page_mkwrite() called
At the moment ->page_mkwrite() is called, filesystem can allocate only
one block for the page because i_size == 1024. Otherwise it would create
blocks beyond i_size which is generally undesirable. But later at
->writepage() time, we also need to store data at offset 4095 but we
don't have block allocated for it.
This patch introduces a helper function filesystems can use to have
->page_mkwrite() called at all the necessary moments.
Signed-off-by: Jan Kara <jack@suse.cz>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
Cc: stable@vger.kernel.org
2014-10-02 05:49:18 +04:00
if ( newsize > oldsize )
pagecache_isize_extended ( inode , oldsize , newsize ) ;
2013-09-13 02:13:56 +04:00
truncate_pagecache ( inode , newsize ) ;
2010-06-04 13:30:04 +04:00
}
EXPORT_SYMBOL ( truncate_setsize ) ;
vfs: fix data corruption when blocksize < pagesize for mmaped data
->page_mkwrite() is used by filesystems to allocate blocks under a page
which is becoming writeably mmapped in some process' address space. This
allows a filesystem to return a page fault if there is not enough space
available, user exceeds quota or similar problem happens, rather than
silently discarding data later when writepage is called.
However VFS fails to call ->page_mkwrite() in all the cases where
filesystems need it when blocksize < pagesize. For example when
blocksize = 1024, pagesize = 4096 the following is problematic:
ftruncate(fd, 0);
pwrite(fd, buf, 1024, 0);
map = mmap(NULL, 1024, PROT_WRITE, MAP_SHARED, fd, 0);
map[0] = 'a'; ----> page_mkwrite() for index 0 is called
ftruncate(fd, 10000); /* or even pwrite(fd, buf, 1, 10000) */
mremap(map, 1024, 10000, 0);
map[4095] = 'a'; ----> no page_mkwrite() called
At the moment ->page_mkwrite() is called, filesystem can allocate only
one block for the page because i_size == 1024. Otherwise it would create
blocks beyond i_size which is generally undesirable. But later at
->writepage() time, we also need to store data at offset 4095 but we
don't have block allocated for it.
This patch introduces a helper function filesystems can use to have
->page_mkwrite() called at all the necessary moments.
Signed-off-by: Jan Kara <jack@suse.cz>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
Cc: stable@vger.kernel.org
2014-10-02 05:49:18 +04:00
/**
* pagecache_isize_extended - update pagecache after extension of i_size
* @ inode : inode for which i_size was extended
* @ from : original inode size
* @ to : new inode size
*
* Handle extension of inode size either caused by extending truncate or by
* write starting after current i_size . We mark the page straddling current
* i_size RO so that page_mkwrite ( ) is called on the nearest write access to
* the page . This way filesystem can be sure that page_mkwrite ( ) is called on
* the page before user writes to the page via mmap after the i_size has been
* changed .
*
* The function must be called after i_size is updated so that page fault
* coming after we unlock the page will already see the new i_size .
2021-04-12 16:50:21 +03:00
* The function must be called while we still hold i_rwsem - this not only
vfs: fix data corruption when blocksize < pagesize for mmaped data
->page_mkwrite() is used by filesystems to allocate blocks under a page
which is becoming writeably mmapped in some process' address space. This
allows a filesystem to return a page fault if there is not enough space
available, user exceeds quota or similar problem happens, rather than
silently discarding data later when writepage is called.
However VFS fails to call ->page_mkwrite() in all the cases where
filesystems need it when blocksize < pagesize. For example when
blocksize = 1024, pagesize = 4096 the following is problematic:
ftruncate(fd, 0);
pwrite(fd, buf, 1024, 0);
map = mmap(NULL, 1024, PROT_WRITE, MAP_SHARED, fd, 0);
map[0] = 'a'; ----> page_mkwrite() for index 0 is called
ftruncate(fd, 10000); /* or even pwrite(fd, buf, 1, 10000) */
mremap(map, 1024, 10000, 0);
map[4095] = 'a'; ----> no page_mkwrite() called
At the moment ->page_mkwrite() is called, filesystem can allocate only
one block for the page because i_size == 1024. Otherwise it would create
blocks beyond i_size which is generally undesirable. But later at
->writepage() time, we also need to store data at offset 4095 but we
don't have block allocated for it.
This patch introduces a helper function filesystems can use to have
->page_mkwrite() called at all the necessary moments.
Signed-off-by: Jan Kara <jack@suse.cz>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
Cc: stable@vger.kernel.org
2014-10-02 05:49:18 +04:00
* makes sure i_size is stable but also that userspace cannot observe new
* i_size value before we are prepared to store mmap writes at new inode size .
*/
void pagecache_isize_extended ( struct inode * inode , loff_t from , loff_t to )
{
2017-02-28 01:28:32 +03:00
int bsize = i_blocksize ( inode ) ;
vfs: fix data corruption when blocksize < pagesize for mmaped data
->page_mkwrite() is used by filesystems to allocate blocks under a page
which is becoming writeably mmapped in some process' address space. This
allows a filesystem to return a page fault if there is not enough space
available, user exceeds quota or similar problem happens, rather than
silently discarding data later when writepage is called.
However VFS fails to call ->page_mkwrite() in all the cases where
filesystems need it when blocksize < pagesize. For example when
blocksize = 1024, pagesize = 4096 the following is problematic:
ftruncate(fd, 0);
pwrite(fd, buf, 1024, 0);
map = mmap(NULL, 1024, PROT_WRITE, MAP_SHARED, fd, 0);
map[0] = 'a'; ----> page_mkwrite() for index 0 is called
ftruncate(fd, 10000); /* or even pwrite(fd, buf, 1, 10000) */
mremap(map, 1024, 10000, 0);
map[4095] = 'a'; ----> no page_mkwrite() called
At the moment ->page_mkwrite() is called, filesystem can allocate only
one block for the page because i_size == 1024. Otherwise it would create
blocks beyond i_size which is generally undesirable. But later at
->writepage() time, we also need to store data at offset 4095 but we
don't have block allocated for it.
This patch introduces a helper function filesystems can use to have
->page_mkwrite() called at all the necessary moments.
Signed-off-by: Jan Kara <jack@suse.cz>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
Cc: stable@vger.kernel.org
2014-10-02 05:49:18 +04:00
loff_t rounded_from ;
struct page * page ;
pgoff_t index ;
WARN_ON ( to > inode - > i_size ) ;
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 15:29:47 +03:00
if ( from > = to | | bsize = = PAGE_SIZE )
vfs: fix data corruption when blocksize < pagesize for mmaped data
->page_mkwrite() is used by filesystems to allocate blocks under a page
which is becoming writeably mmapped in some process' address space. This
allows a filesystem to return a page fault if there is not enough space
available, user exceeds quota or similar problem happens, rather than
silently discarding data later when writepage is called.
However VFS fails to call ->page_mkwrite() in all the cases where
filesystems need it when blocksize < pagesize. For example when
blocksize = 1024, pagesize = 4096 the following is problematic:
ftruncate(fd, 0);
pwrite(fd, buf, 1024, 0);
map = mmap(NULL, 1024, PROT_WRITE, MAP_SHARED, fd, 0);
map[0] = 'a'; ----> page_mkwrite() for index 0 is called
ftruncate(fd, 10000); /* or even pwrite(fd, buf, 1, 10000) */
mremap(map, 1024, 10000, 0);
map[4095] = 'a'; ----> no page_mkwrite() called
At the moment ->page_mkwrite() is called, filesystem can allocate only
one block for the page because i_size == 1024. Otherwise it would create
blocks beyond i_size which is generally undesirable. But later at
->writepage() time, we also need to store data at offset 4095 but we
don't have block allocated for it.
This patch introduces a helper function filesystems can use to have
->page_mkwrite() called at all the necessary moments.
Signed-off-by: Jan Kara <jack@suse.cz>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
Cc: stable@vger.kernel.org
2014-10-02 05:49:18 +04:00
return ;
/* Page straddling @from will not have any hole block created? */
rounded_from = round_up ( from , bsize ) ;
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 15:29:47 +03:00
if ( to < = rounded_from | | ! ( rounded_from & ( PAGE_SIZE - 1 ) ) )
vfs: fix data corruption when blocksize < pagesize for mmaped data
->page_mkwrite() is used by filesystems to allocate blocks under a page
which is becoming writeably mmapped in some process' address space. This
allows a filesystem to return a page fault if there is not enough space
available, user exceeds quota or similar problem happens, rather than
silently discarding data later when writepage is called.
However VFS fails to call ->page_mkwrite() in all the cases where
filesystems need it when blocksize < pagesize. For example when
blocksize = 1024, pagesize = 4096 the following is problematic:
ftruncate(fd, 0);
pwrite(fd, buf, 1024, 0);
map = mmap(NULL, 1024, PROT_WRITE, MAP_SHARED, fd, 0);
map[0] = 'a'; ----> page_mkwrite() for index 0 is called
ftruncate(fd, 10000); /* or even pwrite(fd, buf, 1, 10000) */
mremap(map, 1024, 10000, 0);
map[4095] = 'a'; ----> no page_mkwrite() called
At the moment ->page_mkwrite() is called, filesystem can allocate only
one block for the page because i_size == 1024. Otherwise it would create
blocks beyond i_size which is generally undesirable. But later at
->writepage() time, we also need to store data at offset 4095 but we
don't have block allocated for it.
This patch introduces a helper function filesystems can use to have
->page_mkwrite() called at all the necessary moments.
Signed-off-by: Jan Kara <jack@suse.cz>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
Cc: stable@vger.kernel.org
2014-10-02 05:49:18 +04:00
return ;
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 15:29:47 +03:00
index = from > > PAGE_SHIFT ;
vfs: fix data corruption when blocksize < pagesize for mmaped data
->page_mkwrite() is used by filesystems to allocate blocks under a page
which is becoming writeably mmapped in some process' address space. This
allows a filesystem to return a page fault if there is not enough space
available, user exceeds quota or similar problem happens, rather than
silently discarding data later when writepage is called.
However VFS fails to call ->page_mkwrite() in all the cases where
filesystems need it when blocksize < pagesize. For example when
blocksize = 1024, pagesize = 4096 the following is problematic:
ftruncate(fd, 0);
pwrite(fd, buf, 1024, 0);
map = mmap(NULL, 1024, PROT_WRITE, MAP_SHARED, fd, 0);
map[0] = 'a'; ----> page_mkwrite() for index 0 is called
ftruncate(fd, 10000); /* or even pwrite(fd, buf, 1, 10000) */
mremap(map, 1024, 10000, 0);
map[4095] = 'a'; ----> no page_mkwrite() called
At the moment ->page_mkwrite() is called, filesystem can allocate only
one block for the page because i_size == 1024. Otherwise it would create
blocks beyond i_size which is generally undesirable. But later at
->writepage() time, we also need to store data at offset 4095 but we
don't have block allocated for it.
This patch introduces a helper function filesystems can use to have
->page_mkwrite() called at all the necessary moments.
Signed-off-by: Jan Kara <jack@suse.cz>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
Cc: stable@vger.kernel.org
2014-10-02 05:49:18 +04:00
page = find_lock_page ( inode - > i_mapping , index ) ;
/* Page not cached? Nothing to do */
if ( ! page )
return ;
/*
* See clear_page_dirty_for_io ( ) for details why set_page_dirty ( )
* is needed .
*/
if ( page_mkclean ( page ) )
set_page_dirty ( page ) ;
unlock_page ( page ) ;
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 15:29:47 +03:00
put_page ( page ) ;
vfs: fix data corruption when blocksize < pagesize for mmaped data
->page_mkwrite() is used by filesystems to allocate blocks under a page
which is becoming writeably mmapped in some process' address space. This
allows a filesystem to return a page fault if there is not enough space
available, user exceeds quota or similar problem happens, rather than
silently discarding data later when writepage is called.
However VFS fails to call ->page_mkwrite() in all the cases where
filesystems need it when blocksize < pagesize. For example when
blocksize = 1024, pagesize = 4096 the following is problematic:
ftruncate(fd, 0);
pwrite(fd, buf, 1024, 0);
map = mmap(NULL, 1024, PROT_WRITE, MAP_SHARED, fd, 0);
map[0] = 'a'; ----> page_mkwrite() for index 0 is called
ftruncate(fd, 10000); /* or even pwrite(fd, buf, 1, 10000) */
mremap(map, 1024, 10000, 0);
map[4095] = 'a'; ----> no page_mkwrite() called
At the moment ->page_mkwrite() is called, filesystem can allocate only
one block for the page because i_size == 1024. Otherwise it would create
blocks beyond i_size which is generally undesirable. But later at
->writepage() time, we also need to store data at offset 4095 but we
don't have block allocated for it.
This patch introduces a helper function filesystems can use to have
->page_mkwrite() called at all the necessary moments.
Signed-off-by: Jan Kara <jack@suse.cz>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
Cc: stable@vger.kernel.org
2014-10-02 05:49:18 +04:00
}
EXPORT_SYMBOL ( pagecache_isize_extended ) ;
2012-03-29 01:42:40 +04:00
/**
* truncate_pagecache_range - unmap and remove pagecache that is hole - punched
* @ inode : inode
* @ lstart : offset of beginning of hole
* @ lend : offset of last byte of hole
*
* This function should typically be called before the filesystem
* releases resources associated with the freed range ( eg . deallocates
* blocks ) . This way , pagecache will always stay logically coherent
* with on - disk format , and the filesystem would not have to deal with
* situations such as writepage being called for a page that has already
* had its underlying blocks deallocated .
*/
void truncate_pagecache_range ( struct inode * inode , loff_t lstart , loff_t lend )
{
struct address_space * mapping = inode - > i_mapping ;
loff_t unmap_start = round_up ( lstart , PAGE_SIZE ) ;
loff_t unmap_end = round_down ( 1 + lend , PAGE_SIZE ) - 1 ;
/*
* This rounding is currently just for example : unmap_mapping_range
* expands its hole outwards , whereas we want it to contract the hole
* inwards . However , existing callers of truncate_pagecache_range are
2013-05-28 07:32:35 +04:00
* doing their own page rounding first . Note that unmap_mapping_range
* allows holelen 0 for all , and we allow lend - 1 for end of file .
2012-03-29 01:42:40 +04:00
*/
/*
* Unlike in truncate_pagecache , unmap_mapping_range is called only
* once ( before truncating pagecache ) , and without " even_cows " flag :
* hole - punching should not remove private COWed pages from the hole .
*/
if ( ( u64 ) unmap_end > ( u64 ) unmap_start )
unmap_mapping_range ( mapping , unmap_start ,
1 + unmap_end - unmap_start , 0 ) ;
truncate_inode_pages_range ( mapping , lstart , lend ) ;
}
EXPORT_SYMBOL ( truncate_pagecache_range ) ;