2 * Collaborative memory management interface.
4 * Copyright IBM Corp 2003,2010
5 * Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>,
9 #include <linux/errno.h>
11 #include <linux/init.h>
12 #include <linux/module.h>
13 #include <linux/gfp.h>
14 #include <linux/sched.h>
15 #include <linux/sysctl.h>
16 #include <linux/ctype.h>
17 #include <linux/swap.h>
18 #include <linux/kthread.h>
19 #include <linux/oom.h>
20 #include <linux/suspend.h>
21 #include <linux/uaccess.h>
23 #include <asm/pgalloc.h>
26 #ifdef CONFIG_CMM_IUCV
27 static char *cmm_default_sender
= "VMRMSVM";
30 module_param(sender
, charp
, 0400);
31 MODULE_PARM_DESC(sender
,
32 "Guest name that may send SMSG messages (default VMRMSVM)");
34 #include "../../../drivers/s390/net/smsgiucv.h"
36 #define CMM_NR_PAGES ((PAGE_SIZE / sizeof(unsigned long)) - 2)
38 struct cmm_page_array
{
39 struct cmm_page_array
*next
;
41 unsigned long pages
[CMM_NR_PAGES
];
44 static long cmm_pages
;
45 static long cmm_timed_pages
;
46 static volatile long cmm_pages_target
;
47 static volatile long cmm_timed_pages_target
;
48 static long cmm_timeout_pages
;
49 static long cmm_timeout_seconds
;
50 static int cmm_suspended
;
52 static struct cmm_page_array
*cmm_page_list
;
53 static struct cmm_page_array
*cmm_timed_page_list
;
54 static DEFINE_SPINLOCK(cmm_lock
);
56 static struct task_struct
*cmm_thread_ptr
;
57 static DECLARE_WAIT_QUEUE_HEAD(cmm_thread_wait
);
58 static DEFINE_TIMER(cmm_timer
, NULL
, 0, 0);
60 static void cmm_timer_fn(unsigned long);
61 static void cmm_set_timer(void);
63 static long cmm_alloc_pages(long nr
, long *counter
,
64 struct cmm_page_array
**list
)
66 struct cmm_page_array
*pa
, *npa
;
70 addr
= __get_free_page(GFP_NOIO
);
75 if (!pa
|| pa
->index
>= CMM_NR_PAGES
) {
76 /* Need a new page for the page list. */
77 spin_unlock(&cmm_lock
);
78 npa
= (struct cmm_page_array
*)
79 __get_free_page(GFP_NOIO
);
86 if (!pa
|| pa
->index
>= CMM_NR_PAGES
) {
92 free_page((unsigned long) npa
);
95 pa
->pages
[pa
->index
++] = addr
;
97 spin_unlock(&cmm_lock
);
103 static long cmm_free_pages(long nr
, long *counter
, struct cmm_page_array
**list
)
105 struct cmm_page_array
*pa
;
108 spin_lock(&cmm_lock
);
111 if (!pa
|| pa
->index
<= 0)
113 addr
= pa
->pages
[--pa
->index
];
114 if (pa
->index
== 0) {
116 free_page((unsigned long) *list
);
123 spin_unlock(&cmm_lock
);
127 static int cmm_oom_notify(struct notifier_block
*self
,
128 unsigned long dummy
, void *parm
)
130 unsigned long *freed
= parm
;
133 nr
= cmm_free_pages(nr
, &cmm_timed_pages
, &cmm_timed_page_list
);
135 nr
= cmm_free_pages(nr
, &cmm_pages
, &cmm_page_list
);
136 cmm_pages_target
= cmm_pages
;
137 cmm_timed_pages_target
= cmm_timed_pages
;
142 static struct notifier_block cmm_oom_nb
= {
143 .notifier_call
= cmm_oom_notify
,
146 static int cmm_thread(void *dummy
)
151 rc
= wait_event_interruptible(cmm_thread_wait
,
152 (!cmm_suspended
&& (cmm_pages
!= cmm_pages_target
||
153 cmm_timed_pages
!= cmm_timed_pages_target
)) ||
154 kthread_should_stop());
155 if (kthread_should_stop() || rc
== -ERESTARTSYS
) {
156 cmm_pages_target
= cmm_pages
;
157 cmm_timed_pages_target
= cmm_timed_pages
;
160 if (cmm_pages_target
> cmm_pages
) {
161 if (cmm_alloc_pages(1, &cmm_pages
, &cmm_page_list
))
162 cmm_pages_target
= cmm_pages
;
163 } else if (cmm_pages_target
< cmm_pages
) {
164 cmm_free_pages(1, &cmm_pages
, &cmm_page_list
);
166 if (cmm_timed_pages_target
> cmm_timed_pages
) {
167 if (cmm_alloc_pages(1, &cmm_timed_pages
,
168 &cmm_timed_page_list
))
169 cmm_timed_pages_target
= cmm_timed_pages
;
170 } else if (cmm_timed_pages_target
< cmm_timed_pages
) {
171 cmm_free_pages(1, &cmm_timed_pages
,
172 &cmm_timed_page_list
);
174 if (cmm_timed_pages
> 0 && !timer_pending(&cmm_timer
))
180 static void cmm_kick_thread(void)
182 wake_up(&cmm_thread_wait
);
185 static void cmm_set_timer(void)
187 if (cmm_timed_pages_target
<= 0 || cmm_timeout_seconds
<= 0) {
188 if (timer_pending(&cmm_timer
))
189 del_timer(&cmm_timer
);
192 if (timer_pending(&cmm_timer
)) {
193 if (mod_timer(&cmm_timer
, jiffies
+ cmm_timeout_seconds
*HZ
))
196 cmm_timer
.function
= cmm_timer_fn
;
198 cmm_timer
.expires
= jiffies
+ cmm_timeout_seconds
*HZ
;
199 add_timer(&cmm_timer
);
202 static void cmm_timer_fn(unsigned long ignored
)
206 nr
= cmm_timed_pages_target
- cmm_timeout_pages
;
208 cmm_timed_pages_target
= 0;
210 cmm_timed_pages_target
= nr
;
215 static void cmm_set_pages(long nr
)
217 cmm_pages_target
= nr
;
221 static long cmm_get_pages(void)
226 static void cmm_add_timed_pages(long nr
)
228 cmm_timed_pages_target
+= nr
;
232 static long cmm_get_timed_pages(void)
234 return cmm_timed_pages
;
237 static void cmm_set_timeout(long nr
, long seconds
)
239 cmm_timeout_pages
= nr
;
240 cmm_timeout_seconds
= seconds
;
244 static int cmm_skip_blanks(char *cp
, char **endp
)
248 for (str
= cp
; *str
== ' ' || *str
== '\t'; str
++)
254 static struct ctl_table cmm_table
[];
256 static int cmm_pages_handler(ctl_table
*ctl
, int write
, void __user
*buffer
,
257 size_t *lenp
, loff_t
*ppos
)
263 if (!*lenp
|| (*ppos
&& !write
)) {
270 if (copy_from_user(buf
, buffer
,
271 len
> sizeof(buf
) ? sizeof(buf
) : len
))
273 buf
[sizeof(buf
) - 1] = '\0';
274 cmm_skip_blanks(buf
, &p
);
275 nr
= simple_strtoul(p
, &p
, 0);
276 if (ctl
== &cmm_table
[0])
279 cmm_add_timed_pages(nr
);
281 if (ctl
== &cmm_table
[0])
282 nr
= cmm_get_pages();
284 nr
= cmm_get_timed_pages();
285 len
= sprintf(buf
, "%ld\n", nr
);
288 if (copy_to_user(buffer
, buf
, len
))
296 static int cmm_timeout_handler(ctl_table
*ctl
, int write
, void __user
*buffer
,
297 size_t *lenp
, loff_t
*ppos
)
303 if (!*lenp
|| (*ppos
&& !write
)) {
310 if (copy_from_user(buf
, buffer
,
311 len
> sizeof(buf
) ? sizeof(buf
) : len
))
313 buf
[sizeof(buf
) - 1] = '\0';
314 cmm_skip_blanks(buf
, &p
);
315 nr
= simple_strtoul(p
, &p
, 0);
316 cmm_skip_blanks(p
, &p
);
317 seconds
= simple_strtoul(p
, &p
, 0);
318 cmm_set_timeout(nr
, seconds
);
320 len
= sprintf(buf
, "%ld %ld\n",
321 cmm_timeout_pages
, cmm_timeout_seconds
);
324 if (copy_to_user(buffer
, buf
, len
))
332 static struct ctl_table cmm_table
[] = {
334 .procname
= "cmm_pages",
336 .proc_handler
= cmm_pages_handler
,
339 .procname
= "cmm_timed_pages",
341 .proc_handler
= cmm_pages_handler
,
344 .procname
= "cmm_timeout",
346 .proc_handler
= cmm_timeout_handler
,
351 static struct ctl_table cmm_dir_table
[] = {
361 #ifdef CONFIG_CMM_IUCV
362 #define SMSG_PREFIX "CMM"
363 static void cmm_smsg_target(const char *from
, char *msg
)
367 if (strlen(sender
) > 0 && strcmp(from
, sender
) != 0)
369 if (!cmm_skip_blanks(msg
+ strlen(SMSG_PREFIX
), &msg
))
371 if (strncmp(msg
, "SHRINK", 6) == 0) {
372 if (!cmm_skip_blanks(msg
+ 6, &msg
))
374 nr
= simple_strtoul(msg
, &msg
, 0);
375 cmm_skip_blanks(msg
, &msg
);
378 } else if (strncmp(msg
, "RELEASE", 7) == 0) {
379 if (!cmm_skip_blanks(msg
+ 7, &msg
))
381 nr
= simple_strtoul(msg
, &msg
, 0);
382 cmm_skip_blanks(msg
, &msg
);
384 cmm_add_timed_pages(nr
);
385 } else if (strncmp(msg
, "REUSE", 5) == 0) {
386 if (!cmm_skip_blanks(msg
+ 5, &msg
))
388 nr
= simple_strtoul(msg
, &msg
, 0);
389 if (!cmm_skip_blanks(msg
, &msg
))
391 seconds
= simple_strtoul(msg
, &msg
, 0);
392 cmm_skip_blanks(msg
, &msg
);
394 cmm_set_timeout(nr
, seconds
);
399 static struct ctl_table_header
*cmm_sysctl_header
;
401 static int cmm_suspend(void)
404 cmm_free_pages(cmm_pages
, &cmm_pages
, &cmm_page_list
);
405 cmm_free_pages(cmm_timed_pages
, &cmm_timed_pages
, &cmm_timed_page_list
);
409 static int cmm_resume(void)
416 static int cmm_power_event(struct notifier_block
*this,
417 unsigned long event
, void *ptr
)
420 case PM_POST_HIBERNATION
:
422 case PM_HIBERNATION_PREPARE
:
423 return cmm_suspend();
429 static struct notifier_block cmm_power_notifier
= {
430 .notifier_call
= cmm_power_event
,
433 static int __init
cmm_init(void)
437 cmm_sysctl_header
= register_sysctl_table(cmm_dir_table
);
438 if (!cmm_sysctl_header
)
440 #ifdef CONFIG_CMM_IUCV
441 /* convert sender to uppercase characters */
443 int len
= strlen(sender
);
445 sender
[len
] = toupper(sender
[len
]);
447 sender
= cmm_default_sender
;
450 rc
= smsg_register_callback(SMSG_PREFIX
, cmm_smsg_target
);
454 rc
= register_oom_notifier(&cmm_oom_nb
);
457 rc
= register_pm_notifier(&cmm_power_notifier
);
460 cmm_thread_ptr
= kthread_run(cmm_thread
, NULL
, "cmmthread");
461 rc
= IS_ERR(cmm_thread_ptr
) ? PTR_ERR(cmm_thread_ptr
) : 0;
467 unregister_pm_notifier(&cmm_power_notifier
);
469 unregister_oom_notifier(&cmm_oom_nb
);
471 #ifdef CONFIG_CMM_IUCV
472 smsg_unregister_callback(SMSG_PREFIX
, cmm_smsg_target
);
475 unregister_sysctl_table(cmm_sysctl_header
);
477 del_timer_sync(&cmm_timer
);
480 module_init(cmm_init
);
482 static void __exit
cmm_exit(void)
484 unregister_sysctl_table(cmm_sysctl_header
);
485 #ifdef CONFIG_CMM_IUCV
486 smsg_unregister_callback(SMSG_PREFIX
, cmm_smsg_target
);
488 unregister_pm_notifier(&cmm_power_notifier
);
489 unregister_oom_notifier(&cmm_oom_nb
);
490 kthread_stop(cmm_thread_ptr
);
491 del_timer_sync(&cmm_timer
);
492 cmm_free_pages(cmm_pages
, &cmm_pages
, &cmm_page_list
);
493 cmm_free_pages(cmm_timed_pages
, &cmm_timed_pages
, &cmm_timed_page_list
);
495 module_exit(cmm_exit
);
497 MODULE_LICENSE("GPL");