[net-next-2.6.git] / arch / s390 / mm / cmm.c

/*
 *  Collaborative memory management interface.
 *
 *    Copyright IBM Corp 2003,2010
 *    Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>,
 *
 */

#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/gfp.h>
#include <linux/sched.h>
#include <linux/sysctl.h>
#include <linux/ctype.h>
#include <linux/swap.h>
#include <linux/kthread.h>
#include <linux/oom.h>
#include <linux/suspend.h>
#include <linux/uaccess.h>

#include <asm/pgalloc.h>
#include <asm/diag.h>

static char *sender = "VMRMSVM";
module_param(sender, charp, 0400);
MODULE_PARM_DESC(sender,
		 "Guest name that may send SMSG messages (default VMRMSVM)");

#include "../../../drivers/s390/net/smsgiucv.h"

#define CMM_NR_PAGES ((PAGE_SIZE / sizeof(unsigned long)) - 2)

struct cmm_page_array {
	struct cmm_page_array *next;
	unsigned long index;
	unsigned long pages[CMM_NR_PAGES];
};

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 int cmm_suspended;

static struct cmm_page_array *cmm_page_list;
static struct cmm_page_array *cmm_timed_page_list;
static DEFINE_SPINLOCK(cmm_lock);

static struct task_struct *cmm_thread_ptr;
static DECLARE_WAIT_QUEUE_HEAD(cmm_thread_wait);
static DEFINE_TIMER(cmm_timer, NULL, 0, 0);

static void cmm_timer_fn(unsigned long);
static void cmm_set_timer(void);

static long cmm_alloc_pages(long nr, long *counter,
			    struct cmm_page_array **list)
{
	struct cmm_page_array *pa, *npa;
	unsigned long addr;

	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. */
			spin_unlock(&cmm_lock);
			npa = (struct cmm_page_array *)
				__get_free_page(GFP_NOIO);
			if (!npa) {
				free_page(addr);
				break;
			}
			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(addr);
		pa->pages[pa->index++] = addr;
		(*counter)++;
		spin_unlock(&cmm_lock);
		nr--;
	}
	return nr;
}

static long cmm_free_pages(long nr, long *counter, struct cmm_page_array **list)
{
	struct cmm_page_array *pa;
	unsigned long addr;

	spin_lock(&cmm_lock);
	pa = *list;
	while (nr) {
		if (!pa || pa->index <= 0)
			break;
		addr = pa->pages[--pa->index];
		if (pa->index == 0) {
			pa = pa->next;
			free_page((unsigned long) *list);
			*list = pa;
		}
		free_page(addr);
		(*counter)--;
		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)
{
	int rc;

	while (1) {
		rc = wait_event_interruptible(cmm_thread_wait,
			(!cmm_suspended && (cmm_pages != cmm_pages_target ||
			 cmm_timed_pages != cmm_timed_pages_target)) ||
			 kthread_should_stop());
		if (kthread_should_stop() || rc == -ERESTARTSYS) {
			cmm_pages_target = cmm_pages;
			cmm_timed_pages_target = cmm_timed_pages;
			break;
		}
		if (cmm_pages_target > cmm_pages) {
			if (cmm_alloc_pages(1, &cmm_pages, &cmm_page_list))
				cmm_pages_target = cmm_pages;
		} else if (cmm_pages_target < cmm_pages) {
			cmm_free_pages(1, &cmm_pages, &cmm_page_list);
		}
		if (cmm_timed_pages_target > cmm_timed_pages) {
			if (cmm_alloc_pages(1, &cmm_timed_pages,
					   &cmm_timed_page_list))
				cmm_timed_pages_target = cmm_timed_pages;
		} else if (cmm_timed_pages_target < cmm_timed_pages) {
			cmm_free_pages(1, &cmm_timed_pages,
				       &cmm_timed_page_list);
		}
		if (cmm_timed_pages > 0 && !timer_pending(&cmm_timer))
			cmm_set_timer();
	}
	return 0;
}

static void cmm_kick_thread(void)
{
	wake_up(&cmm_thread_wait);
}

static void cmm_set_timer(void)
{
	if (cmm_timed_pages_target <= 0 || cmm_timeout_seconds <= 0) {
		if (timer_pending(&cmm_timer))
			del_timer(&cmm_timer);
		return;
	}
	if (timer_pending(&cmm_timer)) {
		if (mod_timer(&cmm_timer, jiffies + cmm_timeout_seconds*HZ))
			return;
	}
	cmm_timer.function = cmm_timer_fn;
	cmm_timer.data = 0;
	cmm_timer.expires = jiffies + cmm_timeout_seconds*HZ;
	add_timer(&cmm_timer);
}

static void cmm_timer_fn(unsigned long ignored)
{
	long nr;

	nr = cmm_timed_pages_target - cmm_timeout_pages;
	if (nr < 0)
		cmm_timed_pages_target = 0;
	else
		cmm_timed_pages_target = nr;
	cmm_kick_thread();
	cmm_set_timer();
}

static void cmm_set_pages(long nr)
{
	cmm_pages_target = nr;
	cmm_kick_thread();
}

static long cmm_get_pages(void)
{
	return cmm_pages;
}

static void cmm_add_timed_pages(long nr)
{
	cmm_timed_pages_target += nr;
	cmm_kick_thread();
}

static long cmm_get_timed_pages(void)
{
	return cmm_timed_pages;
}

static void cmm_set_timeout(long nr, long seconds)
{
	cmm_timeout_pages = nr;
	cmm_timeout_seconds = seconds;
	cmm_set_timer();
}

static int cmm_skip_blanks(char *cp, char **endp)
{
	char *str;

	for (str = cp; *str == ' ' || *str == '\t'; str++)
		;
	*endp = str;
	return str != cp;
}

static struct ctl_table cmm_table[];

static int cmm_pages_handler(ctl_table *ctl, int write, void __user *buffer,
			     size_t *lenp, loff_t *ppos)
{
	char buf[16], *p;
	long nr;
	int len;

	if (!*lenp || (*ppos && !write)) {
		*lenp = 0;
		return 0;
	}

	if (write) {
		len = *lenp;
		if (copy_from_user(buf, buffer,
				   len > sizeof(buf) ? sizeof(buf) : len))
			return -EFAULT;
		buf[sizeof(buf) - 1] = '\0';
		cmm_skip_blanks(buf, &p);
		nr = simple_strtoul(p, &p, 0);
		if (ctl == &cmm_table[0])
			cmm_set_pages(nr);
		else
			cmm_add_timed_pages(nr);
	} else {
		if (ctl == &cmm_table[0])
			nr = cmm_get_pages();
		else
			nr = cmm_get_timed_pages();
		len = sprintf(buf, "%ld\n", nr);
		if (len > *lenp)
			len = *lenp;
		if (copy_to_user(buffer, buf, len))
			return -EFAULT;
	}
	*lenp = len;
	*ppos += len;
	return 0;
}

static int cmm_timeout_handler(ctl_table *ctl, int write,  void __user *buffer,
			       size_t *lenp, loff_t *ppos)
{
	char buf[64], *p;
	long nr, seconds;
	int len;

	if (!*lenp || (*ppos && !write)) {
		*lenp = 0;
		return 0;
	}

	if (write) {
		len = *lenp;
		if (copy_from_user(buf, buffer,
				   len > sizeof(buf) ? sizeof(buf) : len))
			return -EFAULT;
		buf[sizeof(buf) - 1] = '\0';
		cmm_skip_blanks(buf, &p);
		nr = simple_strtoul(p, &p, 0);
		cmm_skip_blanks(p, &p);
		seconds = simple_strtoul(p, &p, 0);
		cmm_set_timeout(nr, seconds);
	} else {
		len = sprintf(buf, "%ld %ld\n",
			      cmm_timeout_pages, cmm_timeout_seconds);
		if (len > *lenp)
			len = *lenp;
		if (copy_to_user(buffer, buf, len))
			return -EFAULT;
	}
	*lenp = len;
	*ppos += len;
	return 0;
}

static struct ctl_table cmm_table[] = {
	{
		.procname	= "cmm_pages",
		.mode		= 0644,
		.proc_handler	= cmm_pages_handler,
	},
	{
		.procname	= "cmm_timed_pages",
		.mode		= 0644,
		.proc_handler	= cmm_pages_handler,
	},
	{
		.procname	= "cmm_timeout",
		.mode		= 0644,
		.proc_handler	= cmm_timeout_handler,
	},
	{ }
};

static struct ctl_table cmm_dir_table[] = {
	{
		.procname	= "vm",
		.maxlen		= 0,
		.mode		= 0555,
		.child		= cmm_table,
	},
	{ }
};

#ifdef CONFIG_CMM_IUCV
#define SMSG_PREFIX "CMM"
static void cmm_smsg_target(const char *from, char *msg)
{
	long nr, seconds;

	if (strlen(sender) > 0 && strcmp(from, sender) != 0)
		return;
	if (!cmm_skip_blanks(msg + strlen(SMSG_PREFIX), &msg))
		return;
	if (strncmp(msg, "SHRINK", 6) == 0) {
		if (!cmm_skip_blanks(msg + 6, &msg))
			return;
		nr = simple_strtoul(msg, &msg, 0);
		cmm_skip_blanks(msg, &msg);
		if (*msg == '\0')
			cmm_set_pages(nr);
	} else if (strncmp(msg, "RELEASE", 7) == 0) {
		if (!cmm_skip_blanks(msg + 7, &msg))
			return;
		nr = simple_strtoul(msg, &msg, 0);
		cmm_skip_blanks(msg, &msg);
		if (*msg == '\0')
			cmm_add_timed_pages(nr);
	} else if (strncmp(msg, "REUSE", 5) == 0) {
		if (!cmm_skip_blanks(msg + 5, &msg))
			return;
		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(nr, seconds);
	}
}
#endif

static struct ctl_table_header *cmm_sysctl_header;

static int cmm_suspend(void)
{
	cmm_suspended = 1;
	cmm_free_pages(cmm_pages, &cmm_pages, &cmm_page_list);
	cmm_free_pages(cmm_timed_pages, &cmm_timed_pages, &cmm_timed_page_list);
	return 0;
}

static int cmm_resume(void)
{
	cmm_suspended = 0;
	cmm_kick_thread();
	return 0;
}

static int cmm_power_event(struct notifier_block *this,
			   unsigned long event, void *ptr)
{
	switch (event) {
	case PM_POST_HIBERNATION:
		return cmm_resume();
	case PM_HIBERNATION_PREPARE:
		return cmm_suspend();
	default:
		return NOTIFY_DONE;
	}
}

static struct notifier_block cmm_power_notifier = {
	.notifier_call = cmm_power_event,
};

static int cmm_init(void)
{
	int rc = -ENOMEM;

	cmm_sysctl_header = register_sysctl_table(cmm_dir_table);
	if (!cmm_sysctl_header)
		goto out_sysctl;
#ifdef CONFIG_CMM_IUCV
	rc = smsg_register_callback(SMSG_PREFIX, cmm_smsg_target);
	if (rc < 0)
		goto out_smsg;
#endif
	rc = register_oom_notifier(&cmm_oom_nb);
	if (rc < 0)
		goto out_oom_notify;
	rc = register_pm_notifier(&cmm_power_notifier);
	if (rc)
		goto out_pm;
	cmm_thread_ptr = kthread_run(cmm_thread, NULL, "cmmthread");
	rc = IS_ERR(cmm_thread_ptr) ? PTR_ERR(cmm_thread_ptr) : 0;
	if (rc)
		goto out_kthread;
	return 0;

out_kthread:
	unregister_pm_notifier(&cmm_power_notifier);
out_pm:
	unregister_oom_notifier(&cmm_oom_nb);
out_oom_notify:
#ifdef CONFIG_CMM_IUCV
	smsg_unregister_callback(SMSG_PREFIX, cmm_smsg_target);
out_smsg:
#endif
	unregister_sysctl_table(cmm_sysctl_header);
out_sysctl:
	del_timer_sync(&cmm_timer);
	return rc;
}
module_init(cmm_init);

static void cmm_exit(void)
{
	unregister_sysctl_table(cmm_sysctl_header);
#ifdef CONFIG_CMM_IUCV
	smsg_unregister_callback(SMSG_PREFIX, cmm_smsg_target);
#endif
	unregister_pm_notifier(&cmm_power_notifier);
	unregister_oom_notifier(&cmm_oom_nb);
	kthread_stop(cmm_thread_ptr);
	del_timer_sync(&cmm_timer);
	cmm_free_pages(cmm_pages, &cmm_pages, &cmm_page_list);
	cmm_free_pages(cmm_timed_pages, &cmm_timed_pages, &cmm_timed_page_list);
}
module_exit(cmm_exit);

MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4	1	/*
db705e83	2	* Collaborative memory management interface.
1da177e4	3	*
db705e83 HC	4	* Copyright IBM Corp 2003,2010
db705e83 HC	5	* Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>,
1da177e4	6	*
1da177e4 LT	7	*/
1da177e4 LT	8
1da177e4 LT	9	#include <linux/errno.h>
	10	#include <linux/fs.h>
	11	#include <linux/init.h>
	12	#include <linux/module.h>
5a0e3ad6	13	#include <linux/gfp.h>
1da177e4 LT	14	#include <linux/sched.h>
	15	#include <linux/sysctl.h>
	16	#include <linux/ctype.h>
8bc719d3	17	#include <linux/swap.h>
e8216dee	18	#include <linux/kthread.h>
5a3135c2	19	#include <linux/oom.h>
52b169c8	20	#include <linux/suspend.h>
db705e83	21	#include <linux/uaccess.h>
1da177e4 LT	22
1da177e4 LT	23	#include <asm/pgalloc.h>
0a87c5cf	24	#include <asm/diag.h>
1da177e4	25
15439d74	26	static char *sender = "VMRMSVM";
447570cf	27	module_param(sender, charp, 0400);
15439d74 MS	28	MODULE_PARM_DESC(sender,
	29	"Guest name that may send SMSG messages (default VMRMSVM)");
	30
1da177e4 LT	31	#include "../../../drivers/s390/net/smsgiucv.h"
	32
	33	#define CMM_NR_PAGES ((PAGE_SIZE / sizeof(unsigned long)) - 2)
	34
	35	struct cmm_page_array {
	36	struct cmm_page_array *next;
	37	unsigned long index;
	38	unsigned long pages[CMM_NR_PAGES];
	39	};
	40
8bc719d3 MS	41	static long cmm_pages;
	42	static long cmm_timed_pages;
	43	static volatile long cmm_pages_target;
	44	static volatile long cmm_timed_pages_target;
	45	static long cmm_timeout_pages;
	46	static long cmm_timeout_seconds;
52b169c8	47	static int cmm_suspended;
1da177e4	48
8bc719d3 MS	49	static struct cmm_page_array *cmm_page_list;
	50	static struct cmm_page_array *cmm_timed_page_list;
	51	static DEFINE_SPINLOCK(cmm_lock);
1da177e4	52
e8216dee	53	static struct task_struct *cmm_thread_ptr;
1ef6acf5 HC	54	static DECLARE_WAIT_QUEUE_HEAD(cmm_thread_wait);
1ef6acf5 HC	55	static DEFINE_TIMER(cmm_timer, NULL, 0, 0);
1da177e4 LT	56
	57	static void cmm_timer_fn(unsigned long);
	58	static void cmm_set_timer(void);
	59
db705e83 HC	60	static long cmm_alloc_pages(long nr, long *counter,
db705e83 HC	61	struct cmm_page_array **list)
1da177e4	62	{
8bc719d3 MS	63	struct cmm_page_array pa, npa;
8bc719d3 MS	64	unsigned long addr;
1da177e4	65
8bc719d3 MS	66	while (nr) {
	67	addr = __get_free_page(GFP_NOIO);
	68	if (!addr)
1da177e4	69	break;
8bc719d3 MS	70	spin_lock(&cmm_lock);
8bc719d3 MS	71	pa = *list;
1da177e4 LT	72	if (!pa \|\| pa->index >= CMM_NR_PAGES) {
1da177e4 LT	73	/* Need a new page for the page list. */
8bc719d3 MS	74	spin_unlock(&cmm_lock);
8bc719d3 MS	75	npa = (struct cmm_page_array *)
1da177e4	76	__get_free_page(GFP_NOIO);
8bc719d3 MS	77	if (!npa) {
8bc719d3 MS	78	free_page(addr);
1da177e4 LT	79	break;
1da177e4 LT	80	}
8bc719d3 MS	81	spin_lock(&cmm_lock);
	82	pa = *list;
	83	if (!pa \|\| pa->index >= CMM_NR_PAGES) {
	84	npa->next = pa;
	85	npa->index = 0;
	86	pa = npa;
	87	*list = pa;
	88	} else
	89	free_page((unsigned long) npa);
1da177e4	90	}
8bc719d3 MS	91	diag10(addr);
8bc719d3 MS	92	pa->pages[pa->index++] = addr;
1da177e4	93	(*counter)++;
8bc719d3 MS	94	spin_unlock(&cmm_lock);
8bc719d3 MS	95	nr--;
1da177e4	96	}
8bc719d3	97	return nr;
1da177e4 LT	98	}
1da177e4 LT	99
db705e83	100	static long cmm_free_pages(long nr, long counter, struct cmm_page_array *list)
1da177e4 LT	101	{
1da177e4 LT	102	struct cmm_page_array *pa;
8bc719d3	103	unsigned long addr;
1da177e4	104
8bc719d3	105	spin_lock(&cmm_lock);
1da177e4	106	pa = *list;
8bc719d3	107	while (nr) {
1da177e4 LT	108	if (!pa \|\| pa->index <= 0)
1da177e4 LT	109	break;
8bc719d3	110	addr = pa->pages[--pa->index];
1da177e4 LT	111	if (pa->index == 0) {
	112	pa = pa->next;
	113	free_page((unsigned long) *list);
	114	*list = pa;
	115	}
8bc719d3	116	free_page(addr);
1da177e4	117	(*counter)--;
8bc719d3	118	nr--;
1da177e4	119	}
8bc719d3 MS	120	spin_unlock(&cmm_lock);
8bc719d3 MS	121	return nr;
1da177e4 LT	122	}
1da177e4 LT	123
8bc719d3 MS	124	static int cmm_oom_notify(struct notifier_block *self,
	125	unsigned long dummy, void *parm)
	126	{
	127	unsigned long *freed = parm;
	128	long nr = 256;
	129
	130	nr = cmm_free_pages(nr, &cmm_timed_pages, &cmm_timed_page_list);
	131	if (nr > 0)
	132	nr = cmm_free_pages(nr, &cmm_pages, &cmm_page_list);
	133	cmm_pages_target = cmm_pages;
	134	cmm_timed_pages_target = cmm_timed_pages;
	135	*freed += 256 - nr;
	136	return NOTIFY_OK;
	137	}
	138
	139	static struct notifier_block cmm_oom_nb = {
db705e83	140	.notifier_call = cmm_oom_notify,
8bc719d3 MS	141	};
8bc719d3 MS	142
db705e83	143	static int cmm_thread(void *dummy)
1da177e4 LT	144	{
	145	int rc;
	146
1da177e4 LT	147	while (1) {
1da177e4 LT	148	rc = wait_event_interruptible(cmm_thread_wait,
52b169c8 MS	149	(!cmm_suspended && (cmm_pages != cmm_pages_target \|\|
	150	cmm_timed_pages != cmm_timed_pages_target)) \|\|
	151	kthread_should_stop());
e8216dee	152	if (kthread_should_stop() \|\| rc == -ERESTARTSYS) {
1da177e4 LT	153	cmm_pages_target = cmm_pages;
	154	cmm_timed_pages_target = cmm_timed_pages;
	155	break;
	156	}
	157	if (cmm_pages_target > cmm_pages) {
	158	if (cmm_alloc_pages(1, &cmm_pages, &cmm_page_list))
	159	cmm_pages_target = cmm_pages;
	160	} else if (cmm_pages_target < cmm_pages) {
	161	cmm_free_pages(1, &cmm_pages, &cmm_page_list);
	162	}
	163	if (cmm_timed_pages_target > cmm_timed_pages) {
	164	if (cmm_alloc_pages(1, &cmm_timed_pages,
	165	&cmm_timed_page_list))
	166	cmm_timed_pages_target = cmm_timed_pages;
	167	} else if (cmm_timed_pages_target < cmm_timed_pages) {
	168	cmm_free_pages(1, &cmm_timed_pages,
db705e83	169	&cmm_timed_page_list);
1da177e4 LT	170	}
	171	if (cmm_timed_pages > 0 && !timer_pending(&cmm_timer))
	172	cmm_set_timer();
	173	}
	174	return 0;
	175	}
	176
db705e83	177	static void cmm_kick_thread(void)
1da177e4	178	{
1da177e4 LT	179	wake_up(&cmm_thread_wait);
	180	}
	181
db705e83	182	static void cmm_set_timer(void)
1da177e4 LT	183	{
	184	if (cmm_timed_pages_target <= 0 \|\| cmm_timeout_seconds <= 0) {
	185	if (timer_pending(&cmm_timer))
	186	del_timer(&cmm_timer);
	187	return;
	188	}
	189	if (timer_pending(&cmm_timer)) {
	190	if (mod_timer(&cmm_timer, jiffies + cmm_timeout_seconds*HZ))
	191	return;
	192	}
	193	cmm_timer.function = cmm_timer_fn;
	194	cmm_timer.data = 0;
	195	cmm_timer.expires = jiffies + cmm_timeout_seconds*HZ;
	196	add_timer(&cmm_timer);
	197	}
	198
db705e83	199	static void cmm_timer_fn(unsigned long ignored)
1da177e4	200	{
8bc719d3	201	long nr;
1da177e4	202
8bc719d3 MS	203	nr = cmm_timed_pages_target - cmm_timeout_pages;
8bc719d3 MS	204	if (nr < 0)
1da177e4 LT	205	cmm_timed_pages_target = 0;
1da177e4 LT	206	else
8bc719d3	207	cmm_timed_pages_target = nr;
1da177e4 LT	208	cmm_kick_thread();
	209	cmm_set_timer();
	210	}
	211
db705e83	212	static void cmm_set_pages(long nr)
1da177e4	213	{
8bc719d3	214	cmm_pages_target = nr;
1da177e4 LT	215	cmm_kick_thread();
	216	}
	217
db705e83	218	static long cmm_get_pages(void)
1da177e4 LT	219	{
	220	return cmm_pages;
	221	}
	222
db705e83	223	static void cmm_add_timed_pages(long nr)
1da177e4	224	{
8bc719d3	225	cmm_timed_pages_target += nr;
1da177e4 LT	226	cmm_kick_thread();
	227	}
	228
db705e83	229	static long cmm_get_timed_pages(void)
1da177e4 LT	230	{
	231	return cmm_timed_pages;
	232	}
	233
db705e83	234	static void cmm_set_timeout(long nr, long seconds)
1da177e4	235	{
8bc719d3	236	cmm_timeout_pages = nr;
1da177e4 LT	237	cmm_timeout_seconds = seconds;
	238	cmm_set_timer();
	239	}
	240
db705e83	241	static int cmm_skip_blanks(char cp, char *endp)
1da177e4 LT	242	{
	243	char *str;
	244
db705e83 HC	245	for (str = cp; str == ' ' \|\| str == '\t'; str++)
db705e83 HC	246	;
1da177e4 LT	247	*endp = str;
	248	return str != cp;
	249	}
	250
1da177e4 LT	251	static struct ctl_table cmm_table[];
1da177e4 LT	252
db705e83 HC	253	static int cmm_pages_handler(ctl_table ctl, int write, void __user buffer,
db705e83 HC	254	size_t lenp, loff_t ppos)
1da177e4 LT	255	{
1da177e4 LT	256	char buf[16], *p;
8bc719d3	257	long nr;
1da177e4 LT	258	int len;
	259
	260	if (!lenp \|\| (ppos && !write)) {
	261	*lenp = 0;
	262	return 0;
	263	}
	264
	265	if (write) {
	266	len = *lenp;
	267	if (copy_from_user(buf, buffer,
	268	len > sizeof(buf) ? sizeof(buf) : len))
	269	return -EFAULT;
	270	buf[sizeof(buf) - 1] = '\0';
	271	cmm_skip_blanks(buf, &p);
8bc719d3	272	nr = simple_strtoul(p, &p, 0);
1da177e4	273	if (ctl == &cmm_table[0])
8bc719d3	274	cmm_set_pages(nr);
1da177e4	275	else
8bc719d3	276	cmm_add_timed_pages(nr);
1da177e4 LT	277	} else {
1da177e4 LT	278	if (ctl == &cmm_table[0])
8bc719d3	279	nr = cmm_get_pages();
1da177e4	280	else
8bc719d3 MS	281	nr = cmm_get_timed_pages();
8bc719d3 MS	282	len = sprintf(buf, "%ld\n", nr);
1da177e4 LT	283	if (len > *lenp)
	284	len = *lenp;
	285	if (copy_to_user(buffer, buf, len))
	286	return -EFAULT;
	287	}
	288	*lenp = len;
	289	*ppos += len;
	290	return 0;
	291	}
	292
db705e83 HC	293	static int cmm_timeout_handler(ctl_table ctl, int write, void __user buffer,
db705e83 HC	294	size_t lenp, loff_t ppos)
1da177e4 LT	295	{
1da177e4 LT	296	char buf[64], *p;
8bc719d3	297	long nr, seconds;
1da177e4 LT	298	int len;
	299
	300	if (!lenp \|\| (ppos && !write)) {
	301	*lenp = 0;
	302	return 0;
	303	}
	304
	305	if (write) {
	306	len = *lenp;
	307	if (copy_from_user(buf, buffer,
	308	len > sizeof(buf) ? sizeof(buf) : len))
	309	return -EFAULT;
	310	buf[sizeof(buf) - 1] = '\0';
	311	cmm_skip_blanks(buf, &p);
8bc719d3	312	nr = simple_strtoul(p, &p, 0);
1da177e4	313	cmm_skip_blanks(p, &p);
7d5d688f	314	seconds = simple_strtoul(p, &p, 0);
8bc719d3	315	cmm_set_timeout(nr, seconds);
1da177e4 LT	316	} else {
	317	len = sprintf(buf, "%ld %ld\n",
	318	cmm_timeout_pages, cmm_timeout_seconds);
	319	if (len > *lenp)
	320	len = *lenp;
	321	if (copy_to_user(buffer, buf, len))
	322	return -EFAULT;
	323	}
	324	*lenp = len;
	325	*ppos += len;
	326	return 0;
	327	}
	328
	329	static struct ctl_table cmm_table[] = {
	330	{
1da177e4	331	.procname = "cmm_pages",
5e8b1c40	332	.mode = 0644,
6d456111	333	.proc_handler = cmm_pages_handler,
1da177e4 LT	334	},
1da177e4 LT	335	{
1da177e4	336	.procname = "cmm_timed_pages",
5e8b1c40	337	.mode = 0644,
6d456111	338	.proc_handler = cmm_pages_handler,
1da177e4 LT	339	},
1da177e4 LT	340	{
1da177e4	341	.procname = "cmm_timeout",
5e8b1c40	342	.mode = 0644,
6d456111	343	.proc_handler = cmm_timeout_handler,
1da177e4	344	},
b05fd35d	345	{ }
1da177e4 LT	346	};
	347
	348	static struct ctl_table cmm_dir_table[] = {
	349	{
1da177e4 LT	350	.procname = "vm",
	351	.maxlen = 0,
	352	.mode = 0555,
	353	.child = cmm_table,
	354	},
b05fd35d	355	{ }
1da177e4	356	};
1da177e4 LT	357
	358	#ifdef CONFIG_CMM_IUCV
	359	#define SMSG_PREFIX "CMM"
db705e83	360	static void cmm_smsg_target(const char from, char msg)
1da177e4	361	{
8bc719d3	362	long nr, seconds;
1da177e4	363
15439d74 MS	364	if (strlen(sender) > 0 && strcmp(from, sender) != 0)
15439d74 MS	365	return;
1da177e4 LT	366	if (!cmm_skip_blanks(msg + strlen(SMSG_PREFIX), &msg))
	367	return;
	368	if (strncmp(msg, "SHRINK", 6) == 0) {
	369	if (!cmm_skip_blanks(msg + 6, &msg))
	370	return;
8bc719d3	371	nr = simple_strtoul(msg, &msg, 0);
1da177e4 LT	372	cmm_skip_blanks(msg, &msg);
1da177e4 LT	373	if (*msg == '\0')
8bc719d3	374	cmm_set_pages(nr);
1da177e4 LT	375	} else if (strncmp(msg, "RELEASE", 7) == 0) {
	376	if (!cmm_skip_blanks(msg + 7, &msg))
	377	return;
8bc719d3	378	nr = simple_strtoul(msg, &msg, 0);
1da177e4 LT	379	cmm_skip_blanks(msg, &msg);
1da177e4 LT	380	if (*msg == '\0')
8bc719d3	381	cmm_add_timed_pages(nr);
1da177e4 LT	382	} else if (strncmp(msg, "REUSE", 5) == 0) {
	383	if (!cmm_skip_blanks(msg + 5, &msg))
	384	return;
8bc719d3	385	nr = simple_strtoul(msg, &msg, 0);
1da177e4 LT	386	if (!cmm_skip_blanks(msg, &msg))
1da177e4 LT	387	return;
7d5d688f	388	seconds = simple_strtoul(msg, &msg, 0);
1da177e4 LT	389	cmm_skip_blanks(msg, &msg);
1da177e4 LT	390	if (*msg == '\0')
8bc719d3	391	cmm_set_timeout(nr, seconds);
1da177e4 LT	392	}
	393	}
	394	#endif
	395
2b67fc46	396	static struct ctl_table_header *cmm_sysctl_header;
1da177e4	397
52b169c8 MS	398	static int cmm_suspend(void)
	399	{
	400	cmm_suspended = 1;
	401	cmm_free_pages(cmm_pages, &cmm_pages, &cmm_page_list);
	402	cmm_free_pages(cmm_timed_pages, &cmm_timed_pages, &cmm_timed_page_list);
	403	return 0;
	404	}
	405
	406	static int cmm_resume(void)
	407	{
	408	cmm_suspended = 0;
	409	cmm_kick_thread();
	410	return 0;
	411	}
	412
	413	static int cmm_power_event(struct notifier_block *this,
	414	unsigned long event, void *ptr)
	415	{
	416	switch (event) {
	417	case PM_POST_HIBERNATION:
	418	return cmm_resume();
	419	case PM_HIBERNATION_PREPARE:
	420	return cmm_suspend();
	421	default:
	422	return NOTIFY_DONE;
	423	}
	424	}
	425
	426	static struct notifier_block cmm_power_notifier = {
	427	.notifier_call = cmm_power_event,
	428	};
	429
db705e83	430	static int cmm_init(void)
1da177e4	431	{
e8216dee HC	432	int rc = -ENOMEM;
e8216dee HC	433
0b4d4147	434	cmm_sysctl_header = register_sysctl_table(cmm_dir_table);
e8216dee	435	if (!cmm_sysctl_header)
52b169c8	436	goto out_sysctl;
1da177e4	437	#ifdef CONFIG_CMM_IUCV
e8216dee HC	438	rc = smsg_register_callback(SMSG_PREFIX, cmm_smsg_target);
	439	if (rc < 0)
	440	goto out_smsg;
1da177e4	441	#endif
e8216dee HC	442	rc = register_oom_notifier(&cmm_oom_nb);
	443	if (rc < 0)
	444	goto out_oom_notify;
52b169c8 MS	445	rc = register_pm_notifier(&cmm_power_notifier);
	446	if (rc)
	447	goto out_pm;
e8216dee HC	448	cmm_thread_ptr = kthread_run(cmm_thread, NULL, "cmmthread");
e8216dee HC	449	rc = IS_ERR(cmm_thread_ptr) ? PTR_ERR(cmm_thread_ptr) : 0;
52b169c8 MS	450	if (rc)
	451	goto out_kthread;
	452	return 0;
e8216dee	453
52b169c8 MS	454	out_kthread:
	455	unregister_pm_notifier(&cmm_power_notifier);
	456	out_pm:
	457	unregister_oom_notifier(&cmm_oom_nb);
e8216dee HC	458	out_oom_notify:
	459	#ifdef CONFIG_CMM_IUCV
	460	smsg_unregister_callback(SMSG_PREFIX, cmm_smsg_target);
	461	out_smsg:
	462	#endif
e8216dee	463	unregister_sysctl_table(cmm_sysctl_header);
52b169c8	464	out_sysctl:
1ef6acf5	465	del_timer_sync(&cmm_timer);
e8216dee	466	return rc;
1da177e4	467	}
db705e83	468	module_init(cmm_init);
1da177e4	469
db705e83	470	static void cmm_exit(void)
1da177e4	471	{
1da177e4	472	unregister_sysctl_table(cmm_sysctl_header);
1da177e4 LT	473	#ifdef CONFIG_CMM_IUCV
	474	smsg_unregister_callback(SMSG_PREFIX, cmm_smsg_target);
	475	#endif
1ef6acf5 HC	476	unregister_pm_notifier(&cmm_power_notifier);
	477	unregister_oom_notifier(&cmm_oom_nb);
	478	kthread_stop(cmm_thread_ptr);
	479	del_timer_sync(&cmm_timer);
	480	cmm_free_pages(cmm_pages, &cmm_pages, &cmm_page_list);
	481	cmm_free_pages(cmm_timed_pages, &cmm_timed_pages, &cmm_timed_page_list);
1da177e4	482	}
1da177e4 LT	483	module_exit(cmm_exit);
1da177e4 LT	484
1da177e4	485	MODULE_LICENSE("GPL");