1 files changed, 155 insertions, 0 deletions

diff --git a/mm/thrash.c b/mm/thrash.c
new file mode 100644
index 00000000000..e53f7d02c17
--- /dev/null
+++ b/mm/thrash.c
@@ -0,0 +1,155 @@
+/*
+ * mm/thrash.c
+ *
+ * Copyright (C) 2004, Red Hat, Inc.
+ * Copyright (C) 2004, Rik van Riel <riel@redhat.com>
+ * Released under the GPL, see the file COPYING for details.
+ *
+ * Simple token based thrashing protection, using the algorithm
+ * described in: http://www.cse.ohio-state.edu/hpcs/WWW/HTML/publications/abs05-1.html
+ *
+ * Sep 2006, Ashwin Chaugule <ashwin.chaugule@celunite.com>
+ * Improved algorithm to pass token:
+ * Each task has a priority which is incremented if it contended
+ * for the token in an interval less than its previous attempt.
+ * If the token is acquired, that task's priority is boosted to prevent
+ * the token from bouncing around too often and to let the task make
+ * some progress in its execution.
+ */
+
+#include <linux/jiffies.h>
+#include <linux/mm.h>
+#include <linux/sched.h>
+#include <linux/swap.h>
+#include <linux/memcontrol.h>
+
+#include <trace/events/vmscan.h>
+
+#define TOKEN_AGING_INTERVAL    (0xFF)
+
+static DEFINE_SPINLOCK(swap_token_lock);
+struct mm_struct *swap_token_mm;
+struct mem_cgroup *swap_token_memcg;
+
+#ifdef CONFIG_CGROUP_MEM_RES_CTLR
+static struct mem_cgroup *swap_token_memcg_from_mm(struct mm_struct *mm)
+{
+        struct mem_cgroup *memcg;
+
+        memcg = try_get_mem_cgroup_from_mm(mm);
+        if (memcg)
+                css_put(mem_cgroup_css(memcg));
+
+        return memcg;
+}
+#else
+static struct mem_cgroup *swap_token_memcg_from_mm(struct mm_struct *mm)
+{
+        return NULL;
+}
+#endif
+
+void grab_swap_token(struct mm_struct *mm)
+{
+        int current_interval;
+        unsigned int old_prio = mm->token_priority;
+        static unsigned int global_faults;
+        static unsigned int last_aging;
+
+        global_faults++;
+
+        current_interval = global_faults - mm->faultstamp;
+
+        if (!spin_trylock(&swap_token_lock))
+                return;
+
+        /* First come first served */
+        if (!swap_token_mm)
+                goto replace_token;
+
+        /*
+         * Usually, we don't need priority aging because long interval faults
+         * makes priority decrease quickly. But there is one exception. If the
+         * token owner task is sleeping, it never make long interval faults.
+         * Thus, we need a priority aging mechanism instead. The requirements
+         * of priority aging are
+         *  1) An aging interval is reasonable enough long. Too short aging
+         *     interval makes quick swap token lost and decrease performance.
+         *  2) The swap token owner task have to get priority aging even if
+         *     it's under sleep.
+         */
+        if ((global_faults - last_aging) > TOKEN_AGING_INTERVAL) {
+                swap_token_mm->token_priority /= 2;
+                last_aging = global_faults;
+        }
+
+        if (mm == swap_token_mm) {
+                mm->token_priority += 2;
+                goto update_priority;
+        }
+
+        if (current_interval < mm->last_interval)
+                mm->token_priority++;
+        else {
+                if (likely(mm->token_priority > 0))
+                        mm->token_priority--;
+        }
+
+        /* Check if we deserve the token */
+        if (mm->token_priority > swap_token_mm->token_priority)
+                goto replace_token;
+
+update_priority:
+        trace_update_swap_token_priority(mm, old_prio, swap_token_mm);
+
+out:
+        mm->faultstamp = global_faults;
+        mm->last_interval = current_interval;
+        spin_unlock(&swap_token_lock);
+        return;
+
+replace_token:
+        mm->token_priority += 2;
+        trace_replace_swap_token(swap_token_mm, mm);
+        swap_token_mm = mm;
+        swap_token_memcg = swap_token_memcg_from_mm(mm);
+        last_aging = global_faults;
+        goto out;
+}
+
+/* Called on process exit. */
+void __put_swap_token(struct mm_struct *mm)
+{
+        spin_lock(&swap_token_lock);
+        if (likely(mm == swap_token_mm)) {
+                trace_put_swap_token(swap_token_mm);
+                swap_token_mm = NULL;
+                swap_token_memcg = NULL;
+        }
+        spin_unlock(&swap_token_lock);
+}
+
+static bool match_memcg(struct mem_cgroup *a, struct mem_cgroup *b)
+{
+        if (!a)
+                return true;
+        if (!b)
+                return true;
+        if (a == b)
+                return true;
+        return false;
+}
+
+void disable_swap_token(struct mem_cgroup *memcg)
+{
+        /* memcg reclaim don't disable unrelated mm token. */
+        if (match_memcg(memcg, swap_token_memcg)) {
+                spin_lock(&swap_token_lock);
+                if (match_memcg(memcg, swap_token_memcg)) {
+                        trace_disable_swap_token(swap_token_mm);
+                        swap_token_mm = NULL;
+                        swap_token_memcg = NULL;
+                }
+                spin_unlock(&swap_token_lock);
+        }
+}