linux-toradex.git/mm/truncate.c, branch v2.6.21-rc1

[PATCH] remove invalidate_inode_pages()

2007-02-11T18:51:31+00:00

Convert all calls to invalidate_inode_pages() into open-coded calls to
invalidate_mapping_pages().

Leave the invalidate_inode_pages() wrapper in place for now, marked as
deprecated.

Signed-off-by: Andrew Morton 
Signed-off-by: Linus Torvalds

[PATCH] Export invalidate_mapping_pages() to modules

2007-02-11T18:51:30+00:00

It makes no sense to me to export invalidate_inode_pages() and not
invalidate_mapping_pages() and I actually need invalidate_mapping_pages()
because of its range specification ability...

akpm: also remove the export of invalidate_inode_pages() by making it an
inlined wrapper.

Signed-off-by: Anton Altaparmakov 
Signed-off-by: Andrew Morton 
Signed-off-by: Linus Torvalds

[PATCH] MM: Remove [PATCH] invalidate_inode_pages2_range() debug

2007-01-26T21:51:00+00:00

NFS can handle the case where invalidate_inode_pages2_range() fails, so the
premise behind commit 8258d4a574d3a8c01f0ef68aa26b969398a0e140 is now gone.

Remove the WARN_ON_ONCE() which is causing users grief as we can see from
http://bugzilla.kernel.org/show_bug.cgi?id=7826

Signed-off-by: Trond Myklebust 
Signed-off-by: Andrew Morton 
Signed-off-by: Linus Torvalds

Resurrect 'try_to_free_buffers()' VM hackery

2007-01-26T20:47:06+00:00

It's not pretty, but it appears that ext3 with data=journal will clean
pages without ever actually telling the VM that they are clean.  This,
in turn, will result in the VM (and balance_dirty_pages() in particular)
to never realize that the pages got cleaned, and wait forever for an
event that already happened.

Technically, this seems to be a problem with ext3 itself, but it used to
be hidden by 'try_to_free_buffers()' noticing this situation on its own,
and just working around the filesystem problem.

This commit re-instates that hack, in order to avoid a regression for
the 2.6.20 release. This fixes bugzilla 7844:

	http://bugzilla.kernel.org/show_bug.cgi?id=7844

Peter Zijlstra points out that we should probably retain the debugging
code that this removes from cancel_dirty_page(), and I agree, but for
the imminent release we might as well just silence the warning too
(since it's not a new bug: anything that triggers that warning has been
around forever).

Acked-by: Randy Dunlap 
Acked-by: Jens Axboe 
Acked-by: Peter Zijlstra 
Cc: Andrew Morton 
Signed-off-by: Linus Torvalds

[PATCH] NFS: Fix race in nfs_release_page()

2007-01-12T02:18:21+00:00

    NFS: Fix race in nfs_release_page()

    invalidate_inode_pages2() may find the dirty bit has been set on a page
    owing to the fact that the page may still be mapped after it was locked.
    Only after the call to unmap_mapping_range() are we sure that the page
    can no longer be dirtied.
    In order to fix this, NFS has hooked the releasepage() method and tries
    to write the page out between the call to unmap_mapping_range() and the
    call to remove_mapping(). This, however leads to deadlocks in the page
    reclaim code, where the page may be locked without holding a reference
    to the inode or dentry.

    Fix is to add a new address_space_operation, launder_page(), which will
    attempt to write out a dirty page without releasing the page lock.

Signed-off-by: Trond Myklebust 

    Also, the bare SetPageDirty() can skew all sort of accounting leading to
    other nasties.

[akpm@osdl.org: cleanup]
Signed-off-by: Peter Zijlstra 
Cc: Trond Myklebust 
Signed-off-by: Andrew Morton 
Signed-off-by: Linus Torvalds

Clean up and export cancel_dirty_page() to modules

2006-12-23T17:25:04+00:00

Make cancel_dirty_page() act more like all the other dirty and writeback
accounting functions: test for "mapping" being NULL, and do the
NR_FILE_DIRY accounting purely based on mapping_cap_account_dirty()).

Also, add it to the exports, so that modular filesystems can use it.

Acked-by: Andrew Morton 
Signed-off-by: Linus Torvalds

[PATCH] truncate: dirty memory accounting fix

2006-12-22T16:55:45+00:00

Only (un)account for IO and page-dirtying for devices which have real backing
store (ie: not tmpfs or ramdisks).

Cc: "David S. Miller" 
Signed-off-by: Andrew Morton 
Signed-off-by: Linus Torvalds

[PATCH] truncate: clear page dirtiness before running try_to_free_buffers()

2006-12-21T19:17:26+00:00

truncate presently invalidates the dirty page's buffer_heads then shoots down
the page.  But try_to_free_buffers() will now bale out because the page is
dirty.

Net effect: the LRU gets filled with dirty pages which have invalidated
buffer_heads attached.  They have no ->mapping and hence cannot be cleaned.
The machine leaks memory at an enormous rate.

Fix this by cleaning the page before running try_to_free_buffers(), so
try_to_free_buffers() can do its work.

Also, remember to do dirty-page-acoounting in cancel_dirty_page() so the
machine won't wedge up trying to write non-existent dirty pages.

Probably still wrong, but now less so.

Signed-off-by: Andrew Morton 
Signed-off-by: Linus Torvalds

VM: Remove "clear_page_dirty()" and "test_clear_page_dirty()" functions

2006-12-21T17:19:57+00:00

They were horribly easy to mis-use because of their tempting naming, and
they also did way more than any users of them generally wanted them to
do.

A dirty page can become clean under two circumstances:

 (a) when we write it out.  We have "clear_page_dirty_for_io()" for
     this, and that function remains unchanged.

     In the "for IO" case it is not sufficient to just clear the dirty
     bit, you also have to mark the page as being under writeback etc.

 (b) when we actually remove a page due to it becoming inaccessible to
     users, notably because it was truncate()'d away or the file (or
     metadata) no longer exists, and we thus want to cancel any
     outstanding dirty state.

For the (b) case, we now introduce "cancel_dirty_page()", which only
touches the page state itself, and verifies that the page is not mapped
(since cancelling writes on a mapped page would be actively wrong as it
is still accessible to users).

Some filesystems need to be fixed up for this: CIFS, FUSE, JFS,
ReiserFS, XFS all use the old confusing functions, and will be fixed
separately in subsequent commits (with some of them just removing the
offending logic, and others using clear_page_dirty_for_io()).

This was confirmed by Martin Michlmayr to fix the apt database
corruption on ARM.

Cc: Martin Michlmayr 
Cc: Peter Zijlstra 
Cc: Hugh Dickins 
Cc: Nick Piggin 
Cc: Arjan van de Ven 
Cc: Andrei Popa 
Cc: Andrew Morton 
Cc: Dave Kleikamp 
Cc: Gordon Farquharson 
Cc: Martin Schwidefsky 
Cc: Trond Myklebust 
Signed-off-by: Linus Torvalds

[PATCH] io-accounting: write-cancel accounting

2006-12-10T17:55:41+00:00

Account for the number of byte writes which this process caused to not happen
after all.

Cc: Jay Lan 
Cc: Shailabh Nagar 
Cc: Balbir Singh 
Cc: Chris Sturtivant 
Cc: Tony Ernst 
Cc: Guillaume Thouvenin 
Cc: David Wright 
Signed-off-by: Andrew Morton 
Signed-off-by: Linus Torvalds