mm: memcontrol: rewrite charge API

These patches rework memcg charge lifetime to integrate more naturally
with the lifetime of user pages.  This drastically simplifies the code and
reduces charging and uncharging overhead.  The most expensive part of
charging and uncharging is the page_cgroup bit spinlock, which is removed
entirely after this series.

Here are the top-10 profile entries of a stress test that reads a 128G
sparse file on a freshly booted box, without even a dedicated cgroup (i.e.
 executing in the root memcg).  Before:

    15.36%              cat  [kernel.kallsyms]   [k] copy_user_generic_string
    13.31%              cat  [kernel.kallsyms]   [k] memset
    11.48%              cat  [kernel.kallsyms]   [k] do_mpage_readpage
     4.23%              cat  [kernel.kallsyms]   [k] get_page_from_freelist
     2.38%              cat  [kernel.kallsyms]   [k] put_page
     2.32%              cat  [kernel.kallsyms]   [k] __mem_cgroup_commit_charge
     2.18%          kswapd0  [kernel.kallsyms]   [k] __mem_cgroup_uncharge_common
     1.92%          kswapd0  [kernel.kallsyms]   [k] shrink_page_list
     1.86%              cat  [kernel.kallsyms]   [k] __radix_tree_lookup
     1.62%              cat  [kernel.kallsyms]   [k] __pagevec_lru_add_fn

After:

    15.67%           cat  [kernel.kallsyms]   [k] copy_user_generic_string
    13.48%           cat  [kernel.kallsyms]   [k] memset
    11.42%           cat  [kernel.kallsyms]   [k] do_mpage_readpage
     3.98%           cat  [kernel.kallsyms]   [k] get_page_from_freelist
     2.46%           cat  [kernel.kallsyms]   [k] put_page
     2.13%       kswapd0  [kernel.kallsyms]   [k] shrink_page_list
     1.88%           cat  [kernel.kallsyms]   [k] __radix_tree_lookup
     1.67%           cat  [kernel.kallsyms]   [k] __pagevec_lru_add_fn
     1.39%       kswapd0  [kernel.kallsyms]   [k] free_pcppages_bulk
     1.30%           cat  [kernel.kallsyms]   [k] kfree

As you can see, the memcg footprint has shrunk quite a bit.

   text    data     bss     dec     hex filename
  37970    9892     400   48262    bc86 mm/memcontrol.o.old
  35239    9892     400   45531    b1db mm/memcontrol.o

This patch (of 4):

The memcg charge API charges pages before they are rmapped - i.e.  have an
actual "type" - and so every callsite needs its own set of charge and
uncharge functions to know what type is being operated on.  Worse,
uncharge has to happen from a context that is still type-specific, rather
than at the end of the page's lifetime with exclusive access, and so
requires a lot of synchronization.

Rewrite the charge API to provide a generic set of try_charge(),
commit_charge() and cancel_charge() transaction operations, much like
what's currently done for swap-in:

  mem_cgroup_try_charge() attempts to reserve a charge, reclaiming
  pages from the memcg if necessary.

  mem_cgroup_commit_charge() commits the page to the charge once it
  has a valid page->mapping and PageAnon() reliably tells the type.

  mem_cgroup_cancel_charge() aborts the transaction.

This reduces the charge API and enables subsequent patches to
drastically simplify uncharging.

As pages need to be committed after rmap is established but before they
are added to the LRU, page_add_new_anon_rmap() must stop doing LRU
additions again.  Revive lru_cache_add_active_or_unevictable().

[hughd@google.com: fix shmem_unuse]
[hughd@google.com: Add comments on the private use of -EAGAIN]
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Acked-by: Michal Hocko <mhocko@suse.cz>
Cc: Tejun Heo <tj@kernel.org>
Cc: Vladimir Davydov <vdavydov@parallels.com>
Signed-off-by: Hugh Dickins <hughd@google.com>
Cc: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 23 insertions, 14 deletions

diff --git a/mm/shmem.c b/mm/shmem.c
index 302d1cf7ad07..1f1a8085538b 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -621,7 +621,7 @@ static int shmem_unuse_inode(struct shmem_inode_info *info,
         radswap = swp_to_radix_entry(swap);
         index = radix_tree_locate_item(&mapping->page_tree, radswap);
         if (index == -1)
-                return 0;
+                return -EAGAIN; /* tell shmem_unuse we found nothing */
 
         /*
          * Move _head_ to start search for next from here.
@@ -680,7 +680,6 @@ static int shmem_unuse_inode(struct shmem_inode_info *info,
                         spin_unlock(&info->lock);
                         swap_free(swap);
                 }
-                error = 1;      /* not an error, but entry was found */
         }
         return error;
 }
@@ -692,7 +691,7 @@ int shmem_unuse(swp_entry_t swap, struct page *page)
 {
         struct list_head *this, *next;
         struct shmem_inode_info *info;
-        int found = 0;
+        struct mem_cgroup *memcg;
         int error = 0;
 
         /*
@@ -707,26 +706,32 @@ int shmem_unuse(swp_entry_t swap, struct page *page)
          * the shmem_swaplist_mutex which might hold up shmem_writepage().
          * Charged back to the user (not to caller) when swap account is used.
          */
-        error = mem_cgroup_charge_file(page, current->mm, GFP_KERNEL);
+        error = mem_cgroup_try_charge(page, current->mm, GFP_KERNEL, &memcg);
         if (error)
                 goto out;
         /* No radix_tree_preload: swap entry keeps a place for page in tree */
+        error = -EAGAIN;
 
         mutex_lock(&shmem_swaplist_mutex);
         list_for_each_safe(this, next, &shmem_swaplist) {
                 info = list_entry(this, struct shmem_inode_info, swaplist);
                 if (info->swapped)
-                        found = shmem_unuse_inode(info, swap, &page);
+                        error = shmem_unuse_inode(info, swap, &page);
                 else
                         list_del_init(&info->swaplist);
                 cond_resched();
-                if (found)
+                if (error != -EAGAIN)
                         break;
+                /* found nothing in this: move on to search the next */
         }
         mutex_unlock(&shmem_swaplist_mutex);
 
-        if (found < 0)
-                error = found;
+        if (error) {
+                if (error != -ENOMEM)
+                        error = 0;
+                mem_cgroup_cancel_charge(page, memcg);
+        } else
+                mem_cgroup_commit_charge(page, memcg, true);
 out:
         unlock_page(page);
         page_cache_release(page);
@@ -1030,6 +1035,7 @@ static int shmem_getpage_gfp(struct inode *inode, pgoff_t index,
         struct address_space *mapping = inode->i_mapping;
         struct shmem_inode_info *info;
         struct shmem_sb_info *sbinfo;
+        struct mem_cgroup *memcg;
         struct page *page;
         swp_entry_t swap;
         int error;
@@ -1108,8 +1114,7 @@ repeat:
                                 goto failed;
                 }
 
-                error = mem_cgroup_charge_file(page, current->mm,
-                                                gfp & GFP_RECLAIM_MASK);
+                error = mem_cgroup_try_charge(page, current->mm, gfp, &memcg);
                 if (!error) {
                         error = shmem_add_to_page_cache(page, mapping, index,
                                                 swp_to_radix_entry(swap));
@@ -1125,12 +1130,16 @@ repeat:
                          * Reset swap.val? No, leave it so "failed" goes back to
                          * "repeat": reading a hole and writing should succeed.
                          */
-                        if (error)
+                        if (error) {
+                                mem_cgroup_cancel_charge(page, memcg);
                                 delete_from_swap_cache(page);
+                        }
                 }
                 if (error)
                         goto failed;
 
+                mem_cgroup_commit_charge(page, memcg, true);
+
                 spin_lock(&info->lock);
                 info->swapped--;
                 shmem_recalc_inode(inode);
@@ -1168,8 +1177,7 @@ repeat:
                 if (sgp == SGP_WRITE)
                         __SetPageReferenced(page);
 
-                error = mem_cgroup_charge_file(page, current->mm,
-                                                gfp & GFP_RECLAIM_MASK);
+                error = mem_cgroup_try_charge(page, current->mm, gfp, &memcg);
                 if (error)
                         goto decused;
                 error = radix_tree_maybe_preload(gfp & GFP_RECLAIM_MASK);
@@ -1179,9 +1187,10 @@ repeat:
                         radix_tree_preload_end();
                 }
                 if (error) {
-                        mem_cgroup_uncharge_cache_page(page);
+                        mem_cgroup_cancel_charge(page, memcg);
                         goto decused;
                 }
+                mem_cgroup_commit_charge(page, memcg, false);
                 lru_cache_add_anon(page);
 
                 spin_lock(&info->lock);