Merge branch 'cgroup-rmdir-updates' into cgroup/for-3.8
[~shefty/rdma-dev.git] / mm / memcontrol.c
index 7acf43bf04a270cf2bf90f342c66142d1c5cf675..08adaaae6fcc524589217c880634aadcc637f8c8 100644 (file)
@@ -2337,7 +2337,6 @@ static int __mem_cgroup_try_charge(struct mm_struct *mm,
 again:
        if (*ptr) { /* css should be a valid one */
                memcg = *ptr;
-               VM_BUG_ON(css_is_removed(&memcg->css));
                if (mem_cgroup_is_root(memcg))
                        goto done;
                if (nr_pages == 1 && consume_stock(memcg))
@@ -2477,9 +2476,9 @@ static void __mem_cgroup_cancel_local_charge(struct mem_cgroup *memcg,
 
 /*
  * A helper function to get mem_cgroup from ID. must be called under
- * rcu_read_lock(). The caller must check css_is_removed() or some if
- * it's concern. (dropping refcnt from swap can be called against removed
- * memcg.)
+ * rcu_read_lock().  The caller is responsible for calling css_tryget if
+ * the mem_cgroup is used for charging. (dropping refcnt from swap can be
+ * called against removed memcg.)
  */
 static struct mem_cgroup *mem_cgroup_lookup(unsigned short id)
 {
@@ -2676,13 +2675,6 @@ static int mem_cgroup_move_account(struct page *page,
        /* caller should have done css_get */
        pc->mem_cgroup = to;
        mem_cgroup_charge_statistics(to, anon, nr_pages);
-       /*
-        * We charges against "to" which may not have any tasks. Then, "to"
-        * can be under rmdir(). But in current implementation, caller of
-        * this function is just force_empty() and move charge, so it's
-        * guaranteed that "to" is never removed. So, we don't check rmdir
-        * status here.
-        */
        move_unlock_mem_cgroup(from, &flags);
        ret = 0;
 unlock:
@@ -2696,10 +2688,27 @@ out:
        return ret;
 }
 
-/*
- * move charges to its parent.
+/**
+ * mem_cgroup_move_parent - moves page to the parent group
+ * @page: the page to move
+ * @pc: page_cgroup of the page
+ * @child: page's cgroup
+ *
+ * move charges to its parent or the root cgroup if the group has no
+ * parent (aka use_hierarchy==0).
+ * Although this might fail (get_page_unless_zero, isolate_lru_page or
+ * mem_cgroup_move_account fails) the failure is always temporary and
+ * it signals a race with a page removal/uncharge or migration. In the
+ * first case the page is on the way out and it will vanish from the LRU
+ * on the next attempt and the call should be retried later.
+ * Isolation from the LRU fails only if page has been isolated from
+ * the LRU since we looked at it and that usually means either global
+ * reclaim or migration going on. The page will either get back to the
+ * LRU or vanish.
+ * Finaly mem_cgroup_move_account fails only if the page got uncharged
+ * (!PageCgroupUsed) or moved to a different group. The page will
+ * disappear in the next attempt.
  */
-
 static int mem_cgroup_move_parent(struct page *page,
                                  struct page_cgroup *pc,
                                  struct mem_cgroup *child)
@@ -2709,9 +2718,7 @@ static int mem_cgroup_move_parent(struct page *page,
        unsigned long uninitialized_var(flags);
        int ret;
 
-       /* Is ROOT ? */
-       if (mem_cgroup_is_root(child))
-               return -EINVAL;
+       VM_BUG_ON(mem_cgroup_is_root(child));
 
        ret = -EBUSY;
        if (!get_page_unless_zero(page))
@@ -2728,8 +2735,10 @@ static int mem_cgroup_move_parent(struct page *page,
        if (!parent)
                parent = root_mem_cgroup;
 
-       if (nr_pages > 1)
+       if (nr_pages > 1) {
+               VM_BUG_ON(!PageTransHuge(page));
                flags = compound_lock_irqsave(page);
+       }
 
        ret = mem_cgroup_move_account(page, nr_pages,
                                pc, child, parent);
@@ -2871,7 +2880,6 @@ __mem_cgroup_commit_charge_swapin(struct page *page, struct mem_cgroup *memcg,
                return;
        if (!memcg)
                return;
-       cgroup_exclude_rmdir(&memcg->css);
 
        __mem_cgroup_commit_charge(memcg, page, 1, ctype, true);
        /*
@@ -2885,12 +2893,6 @@ __mem_cgroup_commit_charge_swapin(struct page *page, struct mem_cgroup *memcg,
                swp_entry_t ent = {.val = page_private(page)};
                mem_cgroup_uncharge_swap(ent);
        }
-       /*
-        * At swapin, we may charge account against cgroup which has no tasks.
-        * So, rmdir()->pre_destroy() can be called while we do this charge.
-        * In that case, we need to call pre_destroy() again. check it here.
-        */
-       cgroup_release_and_wakeup_rmdir(&memcg->css);
 }
 
 void mem_cgroup_commit_charge_swapin(struct page *page,
@@ -3338,8 +3340,7 @@ void mem_cgroup_end_migration(struct mem_cgroup *memcg,
 
        if (!memcg)
                return;
-       /* blocks rmdir() */
-       cgroup_exclude_rmdir(&memcg->css);
+
        if (!migration_ok) {
                used = oldpage;
                unused = newpage;
@@ -3373,13 +3374,6 @@ void mem_cgroup_end_migration(struct mem_cgroup *memcg,
         */
        if (anon)
                mem_cgroup_uncharge_page(used);
-       /*
-        * At migration, we may charge account against cgroup which has no
-        * tasks.
-        * So, rmdir()->pre_destroy() can be called while we do this charge.
-        * In that case, we need to call pre_destroy() again. check it here.
-        */
-       cgroup_release_and_wakeup_rmdir(&memcg->css);
 }
 
 /*
@@ -3679,17 +3673,22 @@ unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
        return nr_reclaimed;
 }
 
-/*
+/**
+ * mem_cgroup_force_empty_list - clears LRU of a group
+ * @memcg: group to clear
+ * @node: NUMA node
+ * @zid: zone id
+ * @lru: lru to to clear
+ *
  * Traverse a specified page_cgroup list and try to drop them all.  This doesn't
- * reclaim the pages page themselves - it just removes the page_cgroups.
- * Returns true if some page_cgroups were not freed, indicating that the caller
- * must retry this operation.
+ * reclaim the pages page themselves - pages are moved to the parent (or root)
+ * group.
  */
-static bool mem_cgroup_force_empty_list(struct mem_cgroup *memcg,
+static void mem_cgroup_force_empty_list(struct mem_cgroup *memcg,
                                int node, int zid, enum lru_list lru)
 {
        struct mem_cgroup_per_zone *mz;
-       unsigned long flags, loop;
+       unsigned long flags;
        struct list_head *list;
        struct page *busy;
        struct zone *zone;
@@ -3698,11 +3697,8 @@ static bool mem_cgroup_force_empty_list(struct mem_cgroup *memcg,
        mz = mem_cgroup_zoneinfo(memcg, node, zid);
        list = &mz->lruvec.lists[lru];
 
-       loop = mz->lru_size[lru];
-       /* give some margin against EBUSY etc...*/
-       loop += 256;
        busy = NULL;
-       while (loop--) {
+       do {
                struct page_cgroup *pc;
                struct page *page;
 
@@ -3728,76 +3724,72 @@ static bool mem_cgroup_force_empty_list(struct mem_cgroup *memcg,
                        cond_resched();
                } else
                        busy = NULL;
-       }
-       return !list_empty(list);
+       } while (!list_empty(list));
 }
 
 /*
- * make mem_cgroup's charge to be 0 if there is no task.
+ * make mem_cgroup's charge to be 0 if there is no task by moving
+ * all the charges and pages to the parent.
  * This enables deleting this mem_cgroup.
+ *
+ * Caller is responsible for holding css reference on the memcg.
  */
-static int mem_cgroup_force_empty(struct mem_cgroup *memcg, bool free_all)
+static void mem_cgroup_reparent_charges(struct mem_cgroup *memcg)
 {
-       int ret;
-       int node, zid, shrink;
-       int nr_retries = MEM_CGROUP_RECLAIM_RETRIES;
-       struct cgroup *cgrp = memcg->css.cgroup;
-
-       css_get(&memcg->css);
+       int node, zid;
 
-       shrink = 0;
-       /* should free all ? */
-       if (free_all)
-               goto try_to_free;
-move_account:
        do {
-               ret = -EBUSY;
-               if (cgroup_task_count(cgrp) || !list_empty(&cgrp->children))
-                       goto out;
                /* This is for making all *used* pages to be on LRU. */
                lru_add_drain_all();
                drain_all_stock_sync(memcg);
-               ret = 0;
                mem_cgroup_start_move(memcg);
                for_each_node_state(node, N_HIGH_MEMORY) {
-                       for (zid = 0; !ret && zid < MAX_NR_ZONES; zid++) {
+                       for (zid = 0; zid < MAX_NR_ZONES; zid++) {
                                enum lru_list lru;
                                for_each_lru(lru) {
-                                       ret = mem_cgroup_force_empty_list(memcg,
+                                       mem_cgroup_force_empty_list(memcg,
                                                        node, zid, lru);
-                                       if (ret)
-                                               break;
                                }
                        }
-                       if (ret)
-                               break;
                }
                mem_cgroup_end_move(memcg);
                memcg_oom_recover(memcg);
                cond_resched();
-       /* "ret" should also be checked to ensure all lists are empty. */
-       } while (res_counter_read_u64(&memcg->res, RES_USAGE) > 0 || ret);
-out:
-       css_put(&memcg->css);
-       return ret;
 
-try_to_free:
+               /*
+                * This is a safety check because mem_cgroup_force_empty_list
+                * could have raced with mem_cgroup_replace_page_cache callers
+                * so the lru seemed empty but the page could have been added
+                * right after the check. RES_USAGE should be safe as we always
+                * charge before adding to the LRU.
+                */
+       } while (res_counter_read_u64(&memcg->res, RES_USAGE) > 0);
+}
+
+/*
+ * Reclaims as many pages from the given memcg as possible and moves
+ * the rest to the parent.
+ *
+ * Caller is responsible for holding css reference for memcg.
+ */
+static int mem_cgroup_force_empty(struct mem_cgroup *memcg)
+{
+       int nr_retries = MEM_CGROUP_RECLAIM_RETRIES;
+       struct cgroup *cgrp = memcg->css.cgroup;
+
        /* returns EBUSY if there is a task or if we come here twice. */
-       if (cgroup_task_count(cgrp) || !list_empty(&cgrp->children) || shrink) {
-               ret = -EBUSY;
-               goto out;
-       }
+       if (cgroup_task_count(cgrp) || !list_empty(&cgrp->children))
+               return -EBUSY;
+
        /* we call try-to-free pages for make this cgroup empty */
        lru_add_drain_all();
        /* try to free all pages in this cgroup */
-       shrink = 1;
        while (nr_retries && res_counter_read_u64(&memcg->res, RES_USAGE) > 0) {
                int progress;
 
-               if (signal_pending(current)) {
-                       ret = -EINTR;
-                       goto out;
-               }
+               if (signal_pending(current))
+                       return -EINTR;
+
                progress = try_to_free_mem_cgroup_pages(memcg, GFP_KERNEL,
                                                false);
                if (!progress) {
@@ -3808,13 +3800,23 @@ try_to_free:
 
        }
        lru_add_drain();
-       /* try move_account...there may be some *locked* pages. */
-       goto move_account;
+       mem_cgroup_reparent_charges(memcg);
+
+       return 0;
 }
 
 static int mem_cgroup_force_empty_write(struct cgroup *cont, unsigned int event)
 {
-       return mem_cgroup_force_empty(mem_cgroup_from_cont(cont), true);
+       struct mem_cgroup *memcg = mem_cgroup_from_cont(cont);
+       int ret;
+
+       if (mem_cgroup_is_root(memcg))
+               return -EINVAL;
+       css_get(&memcg->css);
+       ret = mem_cgroup_force_empty(memcg);
+       css_put(&memcg->css);
+
+       return ret;
 }
 
 
@@ -5001,11 +5003,11 @@ free_out:
        return ERR_PTR(error);
 }
 
-static int mem_cgroup_pre_destroy(struct cgroup *cont)
+static void mem_cgroup_pre_destroy(struct cgroup *cont)
 {
        struct mem_cgroup *memcg = mem_cgroup_from_cont(cont);
 
-       return mem_cgroup_force_empty(memcg, false);
+       mem_cgroup_reparent_charges(memcg);
 }
 
 static void mem_cgroup_destroy(struct cgroup *cont)
@@ -5607,7 +5609,6 @@ struct cgroup_subsys mem_cgroup_subsys = {
        .base_cftypes = mem_cgroup_files,
        .early_init = 0,
        .use_id = 1,
-       .__DEPRECATED_clear_css_refs = true,
 };
 
 #ifdef CONFIG_MEMCG_SWAP