3 files changed, 121 insertions, 60 deletions

diff --git a/arch/s390/mm/cmm.c b/arch/s390/mm/cmm.c
index 786a44dba5bf..f2e00df99bae 100644
--- a/arch/s390/mm/cmm.c
+++ b/arch/s390/mm/cmm.c
@@ -15,6 +15,7 @@
 #include <linux/sched.h>
 #include <linux/sysctl.h>
 #include <linux/ctype.h>
+#include <linux/swap.h>
 
 #include <asm/pgalloc.h>
 #include <asm/uaccess.h>
@@ -34,17 +35,18 @@ struct cmm_page_array {
         unsigned long pages[CMM_NR_PAGES];
 };
 
-static long cmm_pages = 0;
-static long cmm_timed_pages = 0;
-static volatile long cmm_pages_target = 0;
-static volatile long cmm_timed_pages_target = 0;
-static long cmm_timeout_pages = 0;
-static long cmm_timeout_seconds = 0;
+static long cmm_pages;
+static long cmm_timed_pages;
+static volatile long cmm_pages_target;
+static volatile long cmm_timed_pages_target;
+static long cmm_timeout_pages;
+static long cmm_timeout_seconds;
 
-static struct cmm_page_array *cmm_page_list = NULL;
-static struct cmm_page_array *cmm_timed_page_list = NULL;
+static struct cmm_page_array *cmm_page_list;
+static struct cmm_page_array *cmm_timed_page_list;
+static DEFINE_SPINLOCK(cmm_lock);
 
-static unsigned long cmm_thread_active = 0;
+static unsigned long cmm_thread_active;
 static struct work_struct cmm_thread_starter;
 static wait_queue_head_t cmm_thread_wait;
 static struct timer_list cmm_timer;
@@ -53,58 +55,89 @@ static void cmm_timer_fn(unsigned long);
 static void cmm_set_timer(void);
 
 static long
-cmm_alloc_pages(long pages, long *counter, struct cmm_page_array **list)
+cmm_alloc_pages(long nr, long *counter, struct cmm_page_array **list)
 {
-        struct cmm_page_array *pa;
-        unsigned long page;
+        struct cmm_page_array *pa, *npa;
+        unsigned long addr;
 
-        pa = *list;
-        while (pages) {
-                page = __get_free_page(GFP_NOIO);
-                if (!page)
+        while (nr) {
+                addr = __get_free_page(GFP_NOIO);
+                if (!addr)
                         break;
+                spin_lock(&cmm_lock);
+                pa = *list;
                 if (!pa || pa->index >= CMM_NR_PAGES) {
                         /* Need a new page for the page list. */
-                        pa = (struct cmm_page_array *)
+                        spin_unlock(&cmm_lock);
+                        npa = (struct cmm_page_array *)
                                 __get_free_page(GFP_NOIO);
-                        if (!pa) {
-                                free_page(page);
+                        if (!npa) {
+                                free_page(addr);
                                 break;
                         }
-                        pa->next = *list;
-                        pa->index = 0;
-                        *list = pa;
+                        spin_lock(&cmm_lock);
+                        pa = *list;
+                        if (!pa || pa->index >= CMM_NR_PAGES) {
+                                npa->next = pa;
+                                npa->index = 0;
+                                pa = npa;
+                                *list = pa;
+                        } else
+                                free_page((unsigned long) npa);
                 }
-                diag10(page);
-                pa->pages[pa->index++] = page;
+                diag10(addr);
+                pa->pages[pa->index++] = addr;
                 (*counter)++;
-                pages--;
+                spin_unlock(&cmm_lock);
+                nr--;
         }
-        return pages;
+        return nr;
 }
 
-static void
-cmm_free_pages(long pages, long *counter, struct cmm_page_array **list)
+static long
+cmm_free_pages(long nr, long *counter, struct cmm_page_array **list)
 {
         struct cmm_page_array *pa;
-        unsigned long page;
+        unsigned long addr;
 
+        spin_lock(&cmm_lock);
         pa = *list;
-        while (pages) {
+        while (nr) {
                 if (!pa || pa->index <= 0)
                         break;
-                page = pa->pages[--pa->index];
+                addr = pa->pages[--pa->index];
                 if (pa->index == 0) {
                         pa = pa->next;
                         free_page((unsigned long) *list);
                         *list = pa;
                 }
-                free_page(page);
+                free_page(addr);
                 (*counter)--;
-                pages--;
+                nr--;
         }
+        spin_unlock(&cmm_lock);
+        return nr;
 }
 
+static int cmm_oom_notify(struct notifier_block *self,
+                          unsigned long dummy, void *parm)
+{
+        unsigned long *freed = parm;
+        long nr = 256;
+
+        nr = cmm_free_pages(nr, &cmm_timed_pages, &cmm_timed_page_list);
+        if (nr > 0)
+                nr = cmm_free_pages(nr, &cmm_pages, &cmm_page_list);
+        cmm_pages_target = cmm_pages;
+        cmm_timed_pages_target = cmm_timed_pages;
+        *freed += 256 - nr;
+        return NOTIFY_OK;
+}
+
+static struct notifier_block cmm_oom_nb = {
+        .notifier_call = cmm_oom_notify
+};
+
 static int
 cmm_thread(void *dummy)
 {
@@ -177,21 +210,21 @@ cmm_set_timer(void)
 static void
 cmm_timer_fn(unsigned long ignored)
 {
-        long pages;
+        long nr;
 
-        pages = cmm_timed_pages_target - cmm_timeout_pages;
-        if (pages < 0)
+        nr = cmm_timed_pages_target - cmm_timeout_pages;
+        if (nr < 0)
                 cmm_timed_pages_target = 0;
         else
-                cmm_timed_pages_target = pages;
+                cmm_timed_pages_target = nr;
         cmm_kick_thread();
         cmm_set_timer();
 }
 
 void
-cmm_set_pages(long pages)
+cmm_set_pages(long nr)
 {
-        cmm_pages_target = pages;
+        cmm_pages_target = nr;
         cmm_kick_thread();
 }
 
@@ -202,9 +235,9 @@ cmm_get_pages(void)
 }
 
 void
-cmm_add_timed_pages(long pages)
+cmm_add_timed_pages(long nr)
 {
-        cmm_timed_pages_target += pages;
+        cmm_timed_pages_target += nr;
         cmm_kick_thread();
 }
 
@@ -215,9 +248,9 @@ cmm_get_timed_pages(void)
 }
 
 void
-cmm_set_timeout(long pages, long seconds)
+cmm_set_timeout(long nr, long seconds)
 {
-        cmm_timeout_pages = pages;
+        cmm_timeout_pages = nr;
         cmm_timeout_seconds = seconds;
         cmm_set_timer();
 }
@@ -245,7 +278,7 @@ cmm_pages_handler(ctl_table *ctl, int write, struct file *filp,
                   void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         char buf[16], *p;
-        long pages;
+        long nr;
         int len;
 
         if (!*lenp || (*ppos && !write)) {
@@ -260,17 +293,17 @@ cmm_pages_handler(ctl_table *ctl, int write, struct file *filp,
                         return -EFAULT;
                 buf[sizeof(buf) - 1] = '\0';
                 cmm_skip_blanks(buf, &p);
-                pages = simple_strtoul(p, &p, 0);
+                nr = simple_strtoul(p, &p, 0);
                 if (ctl == &cmm_table[0])
-                        cmm_set_pages(pages);
+                        cmm_set_pages(nr);
                 else
-                        cmm_add_timed_pages(pages);
+                        cmm_add_timed_pages(nr);
         } else {
                 if (ctl == &cmm_table[0])
-                        pages = cmm_get_pages();
+                        nr = cmm_get_pages();
                 else
-                        pages = cmm_get_timed_pages();
-                len = sprintf(buf, "%ld\n", pages);
+                        nr = cmm_get_timed_pages();
+                len = sprintf(buf, "%ld\n", nr);
                 if (len > *lenp)
                         len = *lenp;
                 if (copy_to_user(buffer, buf, len))
@@ -286,7 +319,7 @@ cmm_timeout_handler(ctl_table *ctl, int write, struct file *filp,
                     void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         char buf[64], *p;
-        long pages, seconds;
+        long nr, seconds;
         int len;
 
         if (!*lenp || (*ppos && !write)) {
@@ -301,10 +334,10 @@ cmm_timeout_handler(ctl_table *ctl, int write, struct file *filp,
                         return -EFAULT;
                 buf[sizeof(buf) - 1] = '\0';
                 cmm_skip_blanks(buf, &p);
-                pages = simple_strtoul(p, &p, 0);
+                nr = simple_strtoul(p, &p, 0);
                 cmm_skip_blanks(p, &p);
                 seconds = simple_strtoul(p, &p, 0);
-                cmm_set_timeout(pages, seconds);
+                cmm_set_timeout(nr, seconds);
         } else {
                 len = sprintf(buf, "%ld %ld\n",
                               cmm_timeout_pages, cmm_timeout_seconds);
@@ -357,7 +390,7 @@ static struct ctl_table cmm_dir_table[] = {
 static void
 cmm_smsg_target(char *from, char *msg)
 {
-        long pages, seconds;
+        long nr, seconds;
 
         if (strlen(sender) > 0 && strcmp(from, sender) != 0)
                 return;
@@ -366,27 +399,27 @@ cmm_smsg_target(char *from, char *msg)
         if (strncmp(msg, "SHRINK", 6) == 0) {
                 if (!cmm_skip_blanks(msg + 6, &msg))
                         return;
-                pages = simple_strtoul(msg, &msg, 0);
+                nr = simple_strtoul(msg, &msg, 0);
                 cmm_skip_blanks(msg, &msg);
                 if (*msg == '\0')
-                        cmm_set_pages(pages);
+                        cmm_set_pages(nr);
         } else if (strncmp(msg, "RELEASE", 7) == 0) {
                 if (!cmm_skip_blanks(msg + 7, &msg))
                         return;
-                pages = simple_strtoul(msg, &msg, 0);
+                nr = simple_strtoul(msg, &msg, 0);
                 cmm_skip_blanks(msg, &msg);
                 if (*msg == '\0')
-                        cmm_add_timed_pages(pages);
+                        cmm_add_timed_pages(nr);
         } else if (strncmp(msg, "REUSE", 5) == 0) {
                 if (!cmm_skip_blanks(msg + 5, &msg))
                         return;
-                pages = simple_strtoul(msg, &msg, 0);
+                nr = simple_strtoul(msg, &msg, 0);
                 if (!cmm_skip_blanks(msg, &msg))
                         return;
                 seconds = simple_strtoul(msg, &msg, 0);
                 cmm_skip_blanks(msg, &msg);
                 if (*msg == '\0')
-                        cmm_set_timeout(pages, seconds);
+                        cmm_set_timeout(nr, seconds);
         }
 }
 #endif
@@ -402,6 +435,7 @@ cmm_init (void)
 #ifdef CONFIG_CMM_IUCV
         smsg_register_callback(SMSG_PREFIX, cmm_smsg_target);
 #endif
+        register_oom_notifier(&cmm_oom_nb);
         INIT_WORK(&cmm_thread_starter, (void *) cmm_start_thread, NULL);
         init_waitqueue_head(&cmm_thread_wait);
         init_timer(&cmm_timer);
@@ -411,6 +445,7 @@ cmm_init (void)
 static void
 cmm_exit(void)
 {
+        unregister_oom_notifier(&cmm_oom_nb);
         cmm_free_pages(cmm_pages, &cmm_pages, &cmm_page_list);
         cmm_free_pages(cmm_timed_pages, &cmm_timed_pages, &cmm_timed_page_list);
 #ifdef CONFIG_CMM_PROC
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 34a6bc3e6cf3..32db06c8ffe0 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -10,6 +10,8 @@
 #include <asm/atomic.h>
 #include <asm/page.h>
 
+struct notifier_block;
+
 #define SWAP_FLAG_PREFER        0x8000  /* set if swap priority specified */
 #define SWAP_FLAG_PRIO_MASK     0x7fff
 #define SWAP_FLAG_PRIO_SHIFT    0
@@ -156,6 +158,8 @@ struct swap_list_t {
 
 /* linux/mm/oom_kill.c */
 extern void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask, int order);
+extern int register_oom_notifier(struct notifier_block *nb);
+extern int unregister_oom_notifier(struct notifier_block *nb);
 
 /* linux/mm/memory.c */
 extern void swapin_readahead(swp_entry_t, unsigned long, struct vm_area_struct *);
diff --git a/mm/oom_kill.c b/mm/oom_kill.c
index b9af136e5cfa..7d056843fa2d 100644
--- a/mm/oom_kill.c
+++ b/mm/oom_kill.c
@@ -21,6 +21,8 @@
 #include <linux/timex.h>
 #include <linux/jiffies.h>
 #include <linux/cpuset.h>
+#include <linux/module.h>
+#include <linux/notifier.h>
 
 int sysctl_panic_on_oom;
 /* #define DEBUG */
@@ -306,6 +308,20 @@ static int oom_kill_process(struct task_struct *p, unsigned long points,
         return oom_kill_task(p, message);
 }
 
+static BLOCKING_NOTIFIER_HEAD(oom_notify_list);
+
+int register_oom_notifier(struct notifier_block *nb)
+{
+        return blocking_notifier_chain_register(&oom_notify_list, nb);
+}
+EXPORT_SYMBOL_GPL(register_oom_notifier);
+
+int unregister_oom_notifier(struct notifier_block *nb)
+{
+        return blocking_notifier_chain_unregister(&oom_notify_list, nb);
+}
+EXPORT_SYMBOL_GPL(unregister_oom_notifier);
+
 /**
  * out_of_memory - kill the "best" process when we run out of memory
  *
@@ -318,6 +334,12 @@ void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask, int order)
 {
         struct task_struct *p;
         unsigned long points = 0;
+        unsigned long freed = 0;
+
+        blocking_notifier_call_chain(&oom_notify_list, 0, &freed);
+        if (freed > 0)
+                /* Got some memory back in the last second. */
+                return;
 
         if (printk_ratelimit()) {
                 printk("oom-killer: gfp_mask=0x%x, order=%d\n",