Skip to content

Commit

Permalink
[PATCH] out of memory notifier
Browse files Browse the repository at this point in the history 
Add a notifer chain to the out of memory killer.  If one of the registered
callbacks could release some memory, do not kill the process but return and
retry the allocation that forced the oom killer to run.

The purpose of the notifier is to add a safety net in the presence of
memory ballooners.  If the resource manager inflated the balloon to a size
where memory allocations can not be satisfied anymore, it is better to
deflate the balloon a bit instead of killing processes.

The implementation for the s390 ballooner is included.

[akpm@osdl.org: cleanups]
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
  • Loading branch information
Martin Schwidefsky authored and Linus Torvalds committed Sep 26, 2006
1 parent 19655d3 commit 8bc719d
Show file tree
Hide file tree
Showing 3 changed files with 121 additions and 60 deletions.
155 changes: 95 additions & 60 deletions arch/s390/mm/cmm.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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>
Expand All @@ -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;
Expand All @@ -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)
{
Expand Down Expand Up @@ -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();
}

Expand All @@ -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();
}

Expand All @@ -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();
}
Expand Down Expand Up @@ -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)) {
Expand All @@ -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))
Expand All @@ -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)) {
Expand All @@ -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);
Expand Down Expand Up @@ -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;
Expand All @@ -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
Expand All @@ -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);
Expand All @@ -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
Expand Down
4 changes: 4 additions & 0 deletions include/linux/swap.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down Expand Up @@ -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 *);
Expand Down
22 changes: 22 additions & 0 deletions mm/oom_kill.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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 */
Expand Down Expand Up @@ -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
*
Expand All @@ -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",
Expand Down

0 comments on commit 8bc719d

Please sign in to comment.