upgrade to fedora-2.6.12-1.1398.FC4 + vserver 2.0.rc7

[linux-2.6.git] / mm / page-writeback.c

diff --git a/mm/page-writeback.c b/mm/page-writeback.c
index a226c7c..613b99a 100644 (file)
--- a/mm/page-writeback.c
+++ b/mm/page-writeback.c
@@ -133,17 +133,29 @@ static void get_writeback_state(struct writeback_state *wbs)
  * clamping level.
  */
 static void
-get_dirty_limits(struct writeback_state *wbs, long *pbackground, long *pdirty)
+get_dirty_limits(struct writeback_state *wbs, long *pbackground, long *pdirty,
+               struct address_space *mapping)
 {
        int background_ratio;           /* Percentages */
        int dirty_ratio;
        int unmapped_ratio;
        long background;
        long dirty;
+       unsigned long available_memory = total_pages;
        struct task_struct *tsk;
 
        get_writeback_state(wbs);
 
+#ifdef CONFIG_HIGHMEM
+       /*
+        * If this mapping can only allocate from low memory,
+        * we exclude high memory from our count.
+        */
+       if (mapping && !(mapping_gfp_mask(mapping) & __GFP_HIGHMEM))
+               available_memory -= totalhigh_pages;
+#endif
+
+
        unmapped_ratio = 100 - (wbs->nr_mapped * 100) / total_pages;
 
        dirty_ratio = vm_dirty_ratio;
@@ -157,8 +169,8 @@ get_dirty_limits(struct writeback_state *wbs, long *pbackground, long *pdirty)
        if (background_ratio >= dirty_ratio)
                background_ratio = dirty_ratio / 2;
 
-       background = (background_ratio * total_pages) / 100;
-       dirty = (dirty_ratio * total_pages) / 100;
+       background = (background_ratio * available_memory) / 100;
+       dirty = (dirty_ratio * available_memory) / 100;
        tsk = current;
        if (tsk->flags & PF_LESS_THROTTLE || rt_task(tsk)) {
                background += background / 4;
@@ -194,7 +206,8 @@ static void balance_dirty_pages(struct address_space *mapping)
                        .nr_to_write    = write_chunk,
                };
 
-               get_dirty_limits(&wbs, &background_thresh, &dirty_thresh);
+               get_dirty_limits(&wbs, &background_thresh,
+                                       &dirty_thresh, mapping);
                nr_reclaimable = wbs.nr_dirty + wbs.nr_unstable;
                if (nr_reclaimable + wbs.nr_writeback <= dirty_thresh)
                        break;
@@ -210,7 +223,7 @@ static void balance_dirty_pages(struct address_space *mapping)
                if (nr_reclaimable) {
                        writeback_inodes(&wbc);
                        get_dirty_limits(&wbs, &background_thresh,
-                                       &dirty_thresh);
+                                       &dirty_thresh, mapping);
                        nr_reclaimable = wbs.nr_dirty + wbs.nr_unstable;
                        if (nr_reclaimable + wbs.nr_writeback <= dirty_thresh)
                                break;
@@ -242,7 +255,7 @@ static void balance_dirty_pages(struct address_space *mapping)
 
 /**
  * balance_dirty_pages_ratelimited - balance dirty memory state
- * @mapping - address_space which was dirtied
+ * @mapping: address_space which was dirtied
  *
  * Processes which are dirtying memory should call in here once for each page
  * which was newly dirtied.  The function will periodically check the system's
@@ -283,7 +296,7 @@ void throttle_vm_writeout(void)
        long dirty_thresh;
 
         for ( ; ; ) {
-               get_dirty_limits(&wbs, &background_thresh, &dirty_thresh);
+               get_dirty_limits(&wbs, &background_thresh, &dirty_thresh, NULL);
 
                 /*
                  * Boost the allowable dirty threshold a bit for page
@@ -318,7 +331,7 @@ static void background_writeout(unsigned long _min_pages)
                long background_thresh;
                long dirty_thresh;
 
-               get_dirty_limits(&wbs, &background_thresh, &dirty_thresh);
+               get_dirty_limits(&wbs, &background_thresh, &dirty_thresh, NULL);
                if (wbs.nr_dirty + wbs.nr_unstable < background_thresh
                                && min_pages <= 0)
                        break;
@@ -549,8 +562,8 @@ int do_writepages(struct address_space *mapping, struct writeback_control *wbc)
 /**
  * write_one_page - write out a single page and optionally wait on I/O
  *
- * @page - the page to write
- * @wait - if true, wait on writeout
+ * @page: the page to write
+ * @wait: if true, wait on writeout
  *
  * The page must be locked by the caller and will be unlocked upon return.
  *
@@ -610,16 +623,16 @@ int __set_page_dirty_nobuffers(struct page *page)
                struct address_space *mapping2;
 
                if (mapping) {
-                       spin_lock_irq(&mapping->tree_lock);
+                       write_lock_irq(&mapping->tree_lock);
                        mapping2 = page_mapping(page);
                        if (mapping2) { /* Race with truncate? */
                                BUG_ON(mapping2 != mapping);
-                               if (!mapping->backing_dev_info->memory_backed)
+                               if (mapping_cap_account_dirty(mapping))
                                        inc_page_state(nr_dirty);
                                radix_tree_tag_set(&mapping->page_tree,
                                        page_index(page), PAGECACHE_TAG_DIRTY);
                        }
-                       spin_unlock_irq(&mapping->tree_lock);
+                       write_unlock_irq(&mapping->tree_lock);
                        if (mapping->host) {
                                /* !PageAnon && !swapper_space */
                                __mark_inode_dirty(mapping->host,
@@ -694,17 +707,17 @@ int test_clear_page_dirty(struct page *page)
        unsigned long flags;
 
        if (mapping) {
-               spin_lock_irqsave(&mapping->tree_lock, flags);
+               write_lock_irqsave(&mapping->tree_lock, flags);
                if (TestClearPageDirty(page)) {
                        radix_tree_tag_clear(&mapping->page_tree,
                                                page_index(page),
                                                PAGECACHE_TAG_DIRTY);
-                       spin_unlock_irqrestore(&mapping->tree_lock, flags);
-                       if (!mapping->backing_dev_info->memory_backed)
+                       write_unlock_irqrestore(&mapping->tree_lock, flags);
+                       if (mapping_cap_account_dirty(mapping))
                                dec_page_state(nr_dirty);
                        return 1;
                }
-               spin_unlock_irqrestore(&mapping->tree_lock, flags);
+               write_unlock_irqrestore(&mapping->tree_lock, flags);
                return 0;
        }
        return TestClearPageDirty(page);
@@ -731,7 +744,7 @@ int clear_page_dirty_for_io(struct page *page)
 
        if (mapping) {
                if (TestClearPageDirty(page)) {
-                       if (!mapping->backing_dev_info->memory_backed)
+                       if (mapping_cap_account_dirty(mapping))
                                dec_page_state(nr_dirty);
                        return 1;
                }
@@ -741,30 +754,6 @@ int clear_page_dirty_for_io(struct page *page)
 }
 EXPORT_SYMBOL(clear_page_dirty_for_io);
 
-/*
- * Clear a page's dirty flag while ignoring dirty memory accounting
- */
-int __clear_page_dirty(struct page *page)
-{
-       struct address_space *mapping = page_mapping(page);
-
-       if (mapping) {
-               unsigned long flags;
-
-               spin_lock_irqsave(&mapping->tree_lock, flags);
-               if (TestClearPageDirty(page)) {
-                       radix_tree_tag_clear(&mapping->page_tree,
-                                               page_index(page),
-                                               PAGECACHE_TAG_DIRTY);
-                       spin_unlock_irqrestore(&mapping->tree_lock, flags);
-                       return 1;
-               }
-               spin_unlock_irqrestore(&mapping->tree_lock, flags);
-               return 0;
-       }
-       return TestClearPageDirty(page);
-}
-
 int test_clear_page_writeback(struct page *page)
 {
        struct address_space *mapping = page_mapping(page);
@@ -773,13 +762,13 @@ int test_clear_page_writeback(struct page *page)
        if (mapping) {
                unsigned long flags;
 
-               spin_lock_irqsave(&mapping->tree_lock, flags);
+               write_lock_irqsave(&mapping->tree_lock, flags);
                ret = TestClearPageWriteback(page);
                if (ret)
                        radix_tree_tag_clear(&mapping->page_tree,
                                                page_index(page),
                                                PAGECACHE_TAG_WRITEBACK);
-               spin_unlock_irqrestore(&mapping->tree_lock, flags);
+               write_unlock_irqrestore(&mapping->tree_lock, flags);
        } else {
                ret = TestClearPageWriteback(page);
        }
@@ -794,7 +783,7 @@ int test_set_page_writeback(struct page *page)
        if (mapping) {
                unsigned long flags;
 
-               spin_lock_irqsave(&mapping->tree_lock, flags);
+               write_lock_irqsave(&mapping->tree_lock, flags);
                ret = TestSetPageWriteback(page);
                if (!ret)
                        radix_tree_tag_set(&mapping->page_tree,
@@ -804,7 +793,7 @@ int test_set_page_writeback(struct page *page)
                        radix_tree_tag_clear(&mapping->page_tree,
                                                page_index(page),
                                                PAGECACHE_TAG_DIRTY);
-               spin_unlock_irqrestore(&mapping->tree_lock, flags);
+               write_unlock_irqrestore(&mapping->tree_lock, flags);
        } else {
                ret = TestSetPageWriteback(page);
        }
@@ -822,9 +811,9 @@ int mapping_tagged(struct address_space *mapping, int tag)
        unsigned long flags;
        int ret;
 
-       spin_lock_irqsave(&mapping->tree_lock, flags);
+       read_lock_irqsave(&mapping->tree_lock, flags);
        ret = radix_tree_tagged(&mapping->page_tree, tag);
-       spin_unlock_irqrestore(&mapping->tree_lock, flags);
+       read_unlock_irqrestore(&mapping->tree_lock, flags);
        return ret;
 }
 EXPORT_SYMBOL(mapping_tagged);