![Michael Holzheu](/assets/img/avatar_default.png)
There are several s390 diagnose calls, which must be executed below the 2GB memory boundary. In order to enforce this, those diagnoses must be compiled into the kernel. Currently diag 14 can be called within the vmur kernel module from addresses above 2GB. This leads to specification exceptions. This patch moves diag10, diag14 and diag210 into the new diag.c file. Signed-off-by: Michael Holzheu <holzheu@de.ibm.com> Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com> Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
482 lines
10 KiB
C
482 lines
10 KiB
C
/*
|
|
* arch/s390/mm/cmm.c
|
|
*
|
|
* S390 version
|
|
* Copyright (C) 2003 IBM Deutschland Entwicklung GmbH, IBM Corporation
|
|
* Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
|
|
*
|
|
* Collaborative memory management interface.
|
|
*/
|
|
|
|
#include <linux/errno.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/init.h>
|
|
#include <linux/module.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/sysctl.h>
|
|
#include <linux/ctype.h>
|
|
#include <linux/swap.h>
|
|
#include <linux/kthread.h>
|
|
|
|
#include <asm/pgalloc.h>
|
|
#include <asm/uaccess.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 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 wait_queue_head_t cmm_thread_wait;
|
|
static struct timer_list cmm_timer;
|
|
|
|
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_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();
|
|
}
|
|
|
|
void
|
|
cmm_set_pages(long nr)
|
|
{
|
|
cmm_pages_target = nr;
|
|
cmm_kick_thread();
|
|
}
|
|
|
|
long
|
|
cmm_get_pages(void)
|
|
{
|
|
return cmm_pages;
|
|
}
|
|
|
|
void
|
|
cmm_add_timed_pages(long nr)
|
|
{
|
|
cmm_timed_pages_target += nr;
|
|
cmm_kick_thread();
|
|
}
|
|
|
|
long
|
|
cmm_get_timed_pages(void)
|
|
{
|
|
return cmm_timed_pages;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
#ifdef CONFIG_CMM_PROC
|
|
|
|
static struct ctl_table cmm_table[];
|
|
|
|
static int
|
|
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 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, struct file *filp,
|
|
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[] = {
|
|
{
|
|
.ctl_name = VM_CMM_PAGES,
|
|
.procname = "cmm_pages",
|
|
.mode = 0644,
|
|
.proc_handler = &cmm_pages_handler,
|
|
},
|
|
{
|
|
.ctl_name = VM_CMM_TIMED_PAGES,
|
|
.procname = "cmm_timed_pages",
|
|
.mode = 0644,
|
|
.proc_handler = &cmm_pages_handler,
|
|
},
|
|
{
|
|
.ctl_name = VM_CMM_TIMEOUT,
|
|
.procname = "cmm_timeout",
|
|
.mode = 0644,
|
|
.proc_handler = &cmm_timeout_handler,
|
|
},
|
|
{ .ctl_name = 0 }
|
|
};
|
|
|
|
static struct ctl_table cmm_dir_table[] = {
|
|
{
|
|
.ctl_name = CTL_VM,
|
|
.procname = "vm",
|
|
.maxlen = 0,
|
|
.mode = 0555,
|
|
.child = cmm_table,
|
|
},
|
|
{ .ctl_name = 0 }
|
|
};
|
|
#endif
|
|
|
|
#ifdef CONFIG_CMM_IUCV
|
|
#define SMSG_PREFIX "CMM"
|
|
static void
|
|
cmm_smsg_target(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_init (void)
|
|
{
|
|
int rc = -ENOMEM;
|
|
|
|
#ifdef CONFIG_CMM_PROC
|
|
cmm_sysctl_header = register_sysctl_table(cmm_dir_table);
|
|
if (!cmm_sysctl_header)
|
|
goto out;
|
|
#endif
|
|
#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;
|
|
init_waitqueue_head(&cmm_thread_wait);
|
|
init_timer(&cmm_timer);
|
|
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_create failed. undo all the stuff from above again.
|
|
*/
|
|
unregister_oom_notifier(&cmm_oom_nb);
|
|
|
|
out_oom_notify:
|
|
#ifdef CONFIG_CMM_IUCV
|
|
smsg_unregister_callback(SMSG_PREFIX, cmm_smsg_target);
|
|
out_smsg:
|
|
#endif
|
|
#ifdef CONFIG_CMM_PROC
|
|
unregister_sysctl_table(cmm_sysctl_header);
|
|
#endif
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
static void
|
|
cmm_exit(void)
|
|
{
|
|
kthread_stop(cmm_thread_ptr);
|
|
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
|
|
unregister_sysctl_table(cmm_sysctl_header);
|
|
#endif
|
|
#ifdef CONFIG_CMM_IUCV
|
|
smsg_unregister_callback(SMSG_PREFIX, cmm_smsg_target);
|
|
#endif
|
|
}
|
|
|
|
module_init(cmm_init);
|
|
module_exit(cmm_exit);
|
|
|
|
EXPORT_SYMBOL(cmm_set_pages);
|
|
EXPORT_SYMBOL(cmm_get_pages);
|
|
EXPORT_SYMBOL(cmm_add_timed_pages);
|
|
EXPORT_SYMBOL(cmm_get_timed_pages);
|
|
EXPORT_SYMBOL(cmm_set_timeout);
|
|
|
|
MODULE_LICENSE("GPL");
|