Merge branch 'for-3.20/bdi' of git://git.kernel.dk/linux-block

[cascardo/linux.git] / mm / vmscan.c

diff --git a/mm/vmscan.c b/mm/vmscan.c
index dcd90c8..224dd29 100644 (file)
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -91,6 +91,9 @@ struct scan_control {
        /* Can pages be swapped as part of reclaim? */
        unsigned int may_swap:1;
 
+       /* Can cgroups be reclaimed below their normal consumption range? */
+       unsigned int may_thrash:1;
+
        unsigned int hibernation_mode:1;
 
        /* One of the zones is ready for compaction */
@@ -497,7 +500,7 @@ static pageout_t pageout(struct page *page, struct address_space *mapping,
        }
        if (mapping->a_ops->writepage == NULL)
                return PAGE_ACTIVATE;
-       if (!may_write_to_queue(mapping->backing_dev_info, sc))
+       if (!may_write_to_queue(inode_to_bdi(mapping->host), sc))
                return PAGE_KEEP;
 
        if (clear_page_dirty_for_io(page)) {
@@ -876,7 +879,7 @@ static unsigned long shrink_page_list(struct list_head *page_list,
                 */
                mapping = page_mapping(page);
                if (((dirty || writeback) && mapping &&
-                    bdi_write_congested(mapping->backing_dev_info)) ||
+                    bdi_write_congested(inode_to_bdi(mapping->host))) ||
                    (writeback && PageReclaim(page)))
                        nr_congested++;
 
@@ -1903,8 +1906,12 @@ static void get_scan_count(struct lruvec *lruvec, int swappiness,
         * latencies, so it's better to scan a minimum amount there as
         * well.
         */
-       if (current_is_kswapd() && !zone_reclaimable(zone))
-               force_scan = true;
+       if (current_is_kswapd()) {
+               if (!zone_reclaimable(zone))
+                       force_scan = true;
+               if (!mem_cgroup_lruvec_online(lruvec))
+                       force_scan = true;
+       }
        if (!global_reclaim(sc))
                force_scan = true;
 
@@ -2290,6 +2297,12 @@ static bool shrink_zone(struct zone *zone, struct scan_control *sc,
                        struct lruvec *lruvec;
                        int swappiness;
 
+                       if (mem_cgroup_low(root, memcg)) {
+                               if (!sc->may_thrash)
+                                       continue;
+                               mem_cgroup_events(memcg, MEMCG_LOW, 1);
+                       }
+
                        lruvec = mem_cgroup_zone_lruvec(zone, memcg);
                        swappiness = mem_cgroup_swappiness(memcg);
 
@@ -2311,8 +2324,7 @@ static bool shrink_zone(struct zone *zone, struct scan_control *sc,
                                mem_cgroup_iter_break(root, memcg);
                                break;
                        }
-                       memcg = mem_cgroup_iter(root, memcg, &reclaim);
-               } while (memcg);
+               } while ((memcg = mem_cgroup_iter(root, memcg, &reclaim)));
 
                /*
                 * Shrink the slab caches in the same proportion that
@@ -2515,10 +2527,11 @@ static bool shrink_zones(struct zonelist *zonelist, struct scan_control *sc)
 static unsigned long do_try_to_free_pages(struct zonelist *zonelist,
                                          struct scan_control *sc)
 {
+       int initial_priority = sc->priority;
        unsigned long total_scanned = 0;
        unsigned long writeback_threshold;
        bool zones_reclaimable;
-
+retry:
        delayacct_freepages_start();
 
        if (global_reclaim(sc))
@@ -2568,6 +2581,13 @@ static unsigned long do_try_to_free_pages(struct zonelist *zonelist,
        if (sc->compaction_ready)
                return 1;
 
+       /* Untapped cgroup reserves?  Don't OOM, retry. */
+       if (!sc->may_thrash) {
+               sc->priority = initial_priority;
+               sc->may_thrash = 1;
+               goto retry;
+       }
+
        /* Any of the zones still reclaimable?  Don't OOM. */
        if (zones_reclaimable)
                return 1;
@@ -3175,7 +3195,7 @@ static unsigned long balance_pgdat(pg_data_t *pgdat, int order,
                 */
                if (waitqueue_active(&pgdat->pfmemalloc_wait) &&
                                pfmemalloc_watermark_ok(pgdat))
-                       wake_up(&pgdat->pfmemalloc_wait);
+                       wake_up_all(&pgdat->pfmemalloc_wait);
 
                /*
                 * Fragmentation may mean that the system cannot be rebalanced