[PATCH] mm: tracking shared dirty pages

Tracking of dirty pages in shared writeable mmap()s.

The idea is simple: write protect clean shared writeable pages, catch the
write-fault, make writeable and set dirty.  On page write-back clean all the
PTE dirty bits and write protect them once again.

The implementation is a tad harder, mainly because the default
backing_dev_info capabilities were too loosely maintained.  Hence it is not
enough to test the backing_dev_info for cap_account_dirty.

The current heuristic is as follows, a VMA is eligible when:
 - its shared writeable
    (vm_flags & (VM_WRITE|VM_SHARED)) == (VM_WRITE|VM_SHARED)
 - it is not a 'special' mapping
    (vm_flags & (VM_PFNMAP|VM_INSERTPAGE)) == 0
 - the backing_dev_info is cap_account_dirty
    mapping_cap_account_dirty(vma->vm_file->f_mapping)
 - f_op->mmap() didn't change the default page protection

Page from remap_pfn_range() are explicitly excluded because their COW
semantics are already horrid enough (see vm_normal_page() in do_wp_page()) and
because they don't have a backing store anyway.

mprotect() is taught about the new behaviour as well.  However it overrides
the last condition.

Cleaning the pages on write-back is done with page_mkclean() a new rmap call.
It can be called on any page, but is currently only implemented for mapped
pages, if the page is found the be of a VMA that accounts dirty pages it will
also wrprotect the PTE.

Finally, in fs/buffers.c:try_to_free_buffers(); remove clear_page_dirty() from
under ->private_lock.  This seems to be safe, since ->private_lock is used to
serialize access to the buffers, not the page itself.  This is needed because
clear_page_dirty() will call into page_mkclean() and would thereby violate
locking order.

[dhowells@redhat.com: Provide a page_mkclean() implementation for NOMMU]
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Hugh Dickins <hugh@veritas.com>
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

1 files changed, 8 insertions, 13 deletions

diff --git a/mm/mprotect.c b/mm/mprotect.c
index 638edabaff71..367b7f6c0637 100644
--- a/mm/mprotect.c
+++ b/mm/mprotect.c
@@ -123,8 +123,6 @@ mprotect_fixup(struct vm_area_struct *vma, struct vm_area_struct **pprev,
         unsigned long oldflags = vma->vm_flags;
         long nrpages = (end - start) >> PAGE_SHIFT;
         unsigned long charged = 0;
-        unsigned int mask;
-        pgprot_t newprot;
         pgoff_t pgoff;
         int error;
 
@@ -176,24 +174,21 @@ mprotect_fixup(struct vm_area_struct *vma, struct vm_area_struct **pprev,
         }
 
 success:
-        /* Don't make the VMA automatically writable if it's shared, but the
-         * backer wishes to know when pages are first written to */
-        mask = VM_READ|VM_WRITE|VM_EXEC|VM_SHARED;
-        if (vma->vm_ops && vma->vm_ops->page_mkwrite)
-                mask &= ~VM_SHARED;
-
-        newprot = protection_map[newflags & mask];
-
         /*
          * vm_flags and vm_page_prot are protected by the mmap_sem
          * held in write mode.
          */
         vma->vm_flags = newflags;
-        vma->vm_page_prot = newprot;
+        vma->vm_page_prot = protection_map[newflags &
+                (VM_READ|VM_WRITE|VM_EXEC|VM_SHARED)];
+        if (vma_wants_writenotify(vma))
+                vma->vm_page_prot = protection_map[newflags &
+                        (VM_READ|VM_WRITE|VM_EXEC)];
+
         if (is_vm_hugetlb_page(vma))
-                hugetlb_change_protection(vma, start, end, newprot);
+                hugetlb_change_protection(vma, start, end, vma->vm_page_prot);
         else
-                change_protection(vma, start, end, newprot);
+                change_protection(vma, start, end, vma->vm_page_prot);
         vm_stat_account(mm, oldflags, vma->vm_file, -nrpages);
         vm_stat_account(mm, newflags, vma->vm_file, nrpages);
         return 0;