[deliverable/linux.git] / arch / s390 / mm / pgtable.c

/*
 *    Copyright IBM Corp. 2007,2009
 *    Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>
 */

#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/swap.h>
#include <linux/smp.h>
#include <linux/highmem.h>
#include <linux/slab.h>
#include <linux/pagemap.h>
#include <linux/spinlock.h>
#include <linux/module.h>
#include <linux/quicklist.h>

#include <asm/system.h>
#include <asm/pgtable.h>
#include <asm/pgalloc.h>
#include <asm/tlb.h>
#include <asm/tlbflush.h>
#include <asm/mmu_context.h>

#ifndef CONFIG_64BIT
#define ALLOC_ORDER	1
#define TABLES_PER_PAGE	4
#define FRAG_MASK	15UL
#define SECOND_HALVES	10UL

void clear_table_pgstes(unsigned long *table)
{
	clear_table(table, _PAGE_TYPE_EMPTY, PAGE_SIZE/4);
	memset(table + 256, 0, PAGE_SIZE/4);
	clear_table(table + 512, _PAGE_TYPE_EMPTY, PAGE_SIZE/4);
	memset(table + 768, 0, PAGE_SIZE/4);
}

#else
#define ALLOC_ORDER	2
#define TABLES_PER_PAGE	2
#define FRAG_MASK	3UL
#define SECOND_HALVES	2UL

void clear_table_pgstes(unsigned long *table)
{
	clear_table(table, _PAGE_TYPE_EMPTY, PAGE_SIZE/2);
	memset(table + 256, 0, PAGE_SIZE/2);
}

#endif

unsigned long VMALLOC_START = VMALLOC_END - VMALLOC_SIZE;
EXPORT_SYMBOL(VMALLOC_START);

static int __init parse_vmalloc(char *arg)
{
	if (!arg)
		return -EINVAL;
	VMALLOC_START = (VMALLOC_END - memparse(arg, &arg)) & PAGE_MASK;
	return 0;
}
early_param("vmalloc", parse_vmalloc);

unsigned long *crst_table_alloc(struct mm_struct *mm, int noexec)
{
	struct page *page = alloc_pages(GFP_KERNEL, ALLOC_ORDER);

	if (!page)
		return NULL;
	page->index = 0;
	if (noexec) {
		struct page *shadow = alloc_pages(GFP_KERNEL, ALLOC_ORDER);
		if (!shadow) {
			__free_pages(page, ALLOC_ORDER);
			return NULL;
		}
		page->index = page_to_phys(shadow);
	}
	spin_lock(&mm->page_table_lock);
	list_add(&page->lru, &mm->context.crst_list);
	spin_unlock(&mm->page_table_lock);
	return (unsigned long *) page_to_phys(page);
}

void crst_table_free(struct mm_struct *mm, unsigned long *table)
{
	unsigned long *shadow = get_shadow_table(table);
	struct page *page = virt_to_page(table);

	spin_lock(&mm->page_table_lock);
	list_del(&page->lru);
	spin_unlock(&mm->page_table_lock);
	if (shadow)
		free_pages((unsigned long) shadow, ALLOC_ORDER);
	free_pages((unsigned long) table, ALLOC_ORDER);
}

#ifdef CONFIG_64BIT
int crst_table_upgrade(struct mm_struct *mm, unsigned long limit)
{
	unsigned long *table, *pgd;
	unsigned long entry;

	BUG_ON(limit > (1UL << 53));
repeat:
	table = crst_table_alloc(mm, mm->context.noexec);
	if (!table)
		return -ENOMEM;
	spin_lock(&mm->page_table_lock);
	if (mm->context.asce_limit < limit) {
		pgd = (unsigned long *) mm->pgd;
		if (mm->context.asce_limit <= (1UL << 31)) {
			entry = _REGION3_ENTRY_EMPTY;
			mm->context.asce_limit = 1UL << 42;
			mm->context.asce_bits = _ASCE_TABLE_LENGTH |
						_ASCE_USER_BITS |
						_ASCE_TYPE_REGION3;
		} else {
			entry = _REGION2_ENTRY_EMPTY;
			mm->context.asce_limit = 1UL << 53;
			mm->context.asce_bits = _ASCE_TABLE_LENGTH |
						_ASCE_USER_BITS |
						_ASCE_TYPE_REGION2;
		}
		crst_table_init(table, entry);
		pgd_populate(mm, (pgd_t *) table, (pud_t *) pgd);
		mm->pgd = (pgd_t *) table;
		mm->task_size = mm->context.asce_limit;
		table = NULL;
	}
	spin_unlock(&mm->page_table_lock);
	if (table)
		crst_table_free(mm, table);
	if (mm->context.asce_limit < limit)
		goto repeat;
	update_mm(mm, current);
	return 0;
}

void crst_table_downgrade(struct mm_struct *mm, unsigned long limit)
{
	pgd_t *pgd;

	if (mm->context.asce_limit <= limit)
		return;
	__tlb_flush_mm(mm);
	while (mm->context.asce_limit > limit) {
		pgd = mm->pgd;
		switch (pgd_val(*pgd) & _REGION_ENTRY_TYPE_MASK) {
		case _REGION_ENTRY_TYPE_R2:
			mm->context.asce_limit = 1UL << 42;
			mm->context.asce_bits = _ASCE_TABLE_LENGTH |
						_ASCE_USER_BITS |
						_ASCE_TYPE_REGION3;
			break;
		case _REGION_ENTRY_TYPE_R3:
			mm->context.asce_limit = 1UL << 31;
			mm->context.asce_bits = _ASCE_TABLE_LENGTH |
						_ASCE_USER_BITS |
						_ASCE_TYPE_SEGMENT;
			break;
		default:
			BUG();
		}
		mm->pgd = (pgd_t *) (pgd_val(*pgd) & _REGION_ENTRY_ORIGIN);
		mm->task_size = mm->context.asce_limit;
		crst_table_free(mm, (unsigned long *) pgd);
	}
	update_mm(mm, current);
}
#endif

/*
 * page table entry allocation/free routines.
 */
unsigned long *page_table_alloc(struct mm_struct *mm)
{
	struct page *page;
	unsigned long *table;
	unsigned long bits;

	bits = (mm->context.noexec || mm->context.has_pgste) ? 3UL : 1UL;
	spin_lock(&mm->page_table_lock);
	page = NULL;
	if (!list_empty(&mm->context.pgtable_list)) {
		page = list_first_entry(&mm->context.pgtable_list,
					struct page, lru);
		if ((page->flags & FRAG_MASK) == ((1UL << TABLES_PER_PAGE) - 1))
			page = NULL;
	}
	if (!page) {
		spin_unlock(&mm->page_table_lock);
		page = alloc_page(GFP_KERNEL|__GFP_REPEAT);
		if (!page)
			return NULL;
		pgtable_page_ctor(page);
		page->flags &= ~FRAG_MASK;
		table = (unsigned long *) page_to_phys(page);
		if (mm->context.has_pgste)
			clear_table_pgstes(table);
		else
			clear_table(table, _PAGE_TYPE_EMPTY, PAGE_SIZE);
		spin_lock(&mm->page_table_lock);
		list_add(&page->lru, &mm->context.pgtable_list);
	}
	table = (unsigned long *) page_to_phys(page);
	while (page->flags & bits) {
		table += 256;
		bits <<= 1;
	}
	page->flags |= bits;
	if ((page->flags & FRAG_MASK) == ((1UL << TABLES_PER_PAGE) - 1))
		list_move_tail(&page->lru, &mm->context.pgtable_list);
	spin_unlock(&mm->page_table_lock);
	return table;
}

void page_table_free(struct mm_struct *mm, unsigned long *table)
{
	struct page *page;
	unsigned long bits;

	bits = (mm->context.noexec || mm->context.has_pgste) ? 3UL : 1UL;
	bits <<= (__pa(table) & (PAGE_SIZE - 1)) / 256 / sizeof(unsigned long);
	page = pfn_to_page(__pa(table) >> PAGE_SHIFT);
	spin_lock(&mm->page_table_lock);
	page->flags ^= bits;
	if (page->flags & FRAG_MASK) {
		/* Page now has some free pgtable fragments. */
		list_move(&page->lru, &mm->context.pgtable_list);
		page = NULL;
	} else
		/* All fragments of the 4K page have been freed. */
		list_del(&page->lru);
	spin_unlock(&mm->page_table_lock);
	if (page) {
		pgtable_page_dtor(page);
		__free_page(page);
	}
}

void disable_noexec(struct mm_struct *mm, struct task_struct *tsk)
{
	struct page *page;

	spin_lock(&mm->page_table_lock);
	/* Free shadow region and segment tables. */
	list_for_each_entry(page, &mm->context.crst_list, lru)
		if (page->index) {
			free_pages((unsigned long) page->index, ALLOC_ORDER);
			page->index = 0;
		}
	/* "Free" second halves of page tables. */
	list_for_each_entry(page, &mm->context.pgtable_list, lru)
		page->flags &= ~SECOND_HALVES;
	spin_unlock(&mm->page_table_lock);
	mm->context.noexec = 0;
	update_mm(mm, tsk);
}

/*
 * switch on pgstes for its userspace process (for kvm)
 */
int s390_enable_sie(void)
{
	struct task_struct *tsk = current;
	struct mm_struct *mm, *old_mm;

	/* Do we have switched amode? If no, we cannot do sie */
	if (!switch_amode)
		return -EINVAL;

	/* Do we have pgstes? if yes, we are done */
	if (tsk->mm->context.has_pgste)
		return 0;

	/* lets check if we are allowed to replace the mm */
	task_lock(tsk);
	if (!tsk->mm || atomic_read(&tsk->mm->mm_users) > 1 ||
	    tsk->mm != tsk->active_mm || !hlist_empty(&tsk->mm->ioctx_list)) {
		task_unlock(tsk);
		return -EINVAL;
	}
	task_unlock(tsk);

	/* we copy the mm and let dup_mm create the page tables with_pgstes */
	tsk->mm->context.alloc_pgste = 1;
	mm = dup_mm(tsk);
	tsk->mm->context.alloc_pgste = 0;
	if (!mm)
		return -ENOMEM;

	/* Now lets check again if something happened */
	task_lock(tsk);
	if (!tsk->mm || atomic_read(&tsk->mm->mm_users) > 1 ||
	    tsk->mm != tsk->active_mm || !hlist_empty(&tsk->mm->ioctx_list)) {
		mmput(mm);
		task_unlock(tsk);
		return -EINVAL;
	}

	/* ok, we are alone. No ptrace, no threads, etc. */
	old_mm = tsk->mm;
	tsk->mm = tsk->active_mm = mm;
	preempt_disable();
	update_mm(mm, tsk);
	cpumask_set_cpu(smp_processor_id(), mm_cpumask(mm));
	preempt_enable();
	task_unlock(tsk);
	mmput(old_mm);
	return 0;
}
EXPORT_SYMBOL_GPL(s390_enable_sie);
Commit	Line	Data
3610cce8	1	/*
239a6425	2	* Copyright IBM Corp. 2007,2009
3610cce8 MS	3	* Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>
	4	*/
	5
	6	#include <linux/sched.h>
	7	#include <linux/kernel.h>
	8	#include <linux/errno.h>
	9	#include <linux/mm.h>
	10	#include <linux/swap.h>
	11	#include <linux/smp.h>
	12	#include <linux/highmem.h>
	13	#include <linux/slab.h>
	14	#include <linux/pagemap.h>
	15	#include <linux/spinlock.h>
	16	#include <linux/module.h>
	17	#include <linux/quicklist.h>
	18
	19	#include <asm/system.h>
	20	#include <asm/pgtable.h>
	21	#include <asm/pgalloc.h>
	22	#include <asm/tlb.h>
	23	#include <asm/tlbflush.h>
6252d702	24	#include <asm/mmu_context.h>
3610cce8 MS	25
	26	#ifndef CONFIG_64BIT
	27	#define ALLOC_ORDER 1
146e4b3c MS	28	#define TABLES_PER_PAGE 4
	29	#define FRAG_MASK 15UL
	30	#define SECOND_HALVES 10UL
402b0862 CO	31
	32	void clear_table_pgstes(unsigned long *table)
	33	{
	34	clear_table(table, _PAGE_TYPE_EMPTY, PAGE_SIZE/4);
	35	memset(table + 256, 0, PAGE_SIZE/4);
	36	clear_table(table + 512, _PAGE_TYPE_EMPTY, PAGE_SIZE/4);
	37	memset(table + 768, 0, PAGE_SIZE/4);
	38	}
	39
3610cce8 MS	40	#else
3610cce8 MS	41	#define ALLOC_ORDER 2
146e4b3c MS	42	#define TABLES_PER_PAGE 2
	43	#define FRAG_MASK 3UL
	44	#define SECOND_HALVES 2UL
402b0862 CO	45
	46	void clear_table_pgstes(unsigned long *table)
	47	{
	48	clear_table(table, _PAGE_TYPE_EMPTY, PAGE_SIZE/2);
	49	memset(table + 256, 0, PAGE_SIZE/2);
	50	}
	51
3610cce8 MS	52	#endif
3610cce8 MS	53
239a6425 HC	54	unsigned long VMALLOC_START = VMALLOC_END - VMALLOC_SIZE;
	55	EXPORT_SYMBOL(VMALLOC_START);
	56
	57	static int __init parse_vmalloc(char *arg)
	58	{
	59	if (!arg)
	60	return -EINVAL;
	61	VMALLOC_START = (VMALLOC_END - memparse(arg, &arg)) & PAGE_MASK;
	62	return 0;
	63	}
	64	early_param("vmalloc", parse_vmalloc);
	65
3610cce8 MS	66	unsigned long crst_table_alloc(struct mm_struct mm, int noexec)
	67	{
	68	struct page *page = alloc_pages(GFP_KERNEL, ALLOC_ORDER);
	69
	70	if (!page)
	71	return NULL;
	72	page->index = 0;
	73	if (noexec) {
	74	struct page *shadow = alloc_pages(GFP_KERNEL, ALLOC_ORDER);
	75	if (!shadow) {
	76	__free_pages(page, ALLOC_ORDER);
	77	return NULL;
	78	}
	79	page->index = page_to_phys(shadow);
	80	}
146e4b3c MS	81	spin_lock(&mm->page_table_lock);
	82	list_add(&page->lru, &mm->context.crst_list);
	83	spin_unlock(&mm->page_table_lock);
3610cce8 MS	84	return (unsigned long *) page_to_phys(page);
	85	}
	86
146e4b3c	87	void crst_table_free(struct mm_struct mm, unsigned long table)
3610cce8 MS	88	{
3610cce8 MS	89	unsigned long *shadow = get_shadow_table(table);
146e4b3c	90	struct page *page = virt_to_page(table);
3610cce8	91
146e4b3c MS	92	spin_lock(&mm->page_table_lock);
	93	list_del(&page->lru);
	94	spin_unlock(&mm->page_table_lock);
3610cce8 MS	95	if (shadow)
	96	free_pages((unsigned long) shadow, ALLOC_ORDER);
	97	free_pages((unsigned long) table, ALLOC_ORDER);
	98	}
	99
6252d702 MS	100	#ifdef CONFIG_64BIT
	101	int crst_table_upgrade(struct mm_struct *mm, unsigned long limit)
	102	{
	103	unsigned long table, pgd;
	104	unsigned long entry;
	105
	106	BUG_ON(limit > (1UL << 53));
	107	repeat:
	108	table = crst_table_alloc(mm, mm->context.noexec);
	109	if (!table)
	110	return -ENOMEM;
	111	spin_lock(&mm->page_table_lock);
	112	if (mm->context.asce_limit < limit) {
	113	pgd = (unsigned long *) mm->pgd;
	114	if (mm->context.asce_limit <= (1UL << 31)) {
	115	entry = _REGION3_ENTRY_EMPTY;
	116	mm->context.asce_limit = 1UL << 42;
	117	mm->context.asce_bits = _ASCE_TABLE_LENGTH \|
	118	_ASCE_USER_BITS \|
	119	_ASCE_TYPE_REGION3;
	120	} else {
	121	entry = _REGION2_ENTRY_EMPTY;
	122	mm->context.asce_limit = 1UL << 53;
	123	mm->context.asce_bits = _ASCE_TABLE_LENGTH \|
	124	_ASCE_USER_BITS \|
	125	_ASCE_TYPE_REGION2;
	126	}
	127	crst_table_init(table, entry);
	128	pgd_populate(mm, (pgd_t ) table, (pud_t ) pgd);
	129	mm->pgd = (pgd_t *) table;
f481bfaf	130	mm->task_size = mm->context.asce_limit;
6252d702 MS	131	table = NULL;
	132	}
	133	spin_unlock(&mm->page_table_lock);
	134	if (table)
	135	crst_table_free(mm, table);
	136	if (mm->context.asce_limit < limit)
	137	goto repeat;
	138	update_mm(mm, current);
	139	return 0;
	140	}
	141
	142	void crst_table_downgrade(struct mm_struct *mm, unsigned long limit)
	143	{
	144	pgd_t *pgd;
	145
	146	if (mm->context.asce_limit <= limit)
	147	return;
	148	__tlb_flush_mm(mm);
	149	while (mm->context.asce_limit > limit) {
	150	pgd = mm->pgd;
	151	switch (pgd_val(*pgd) & _REGION_ENTRY_TYPE_MASK) {
	152	case _REGION_ENTRY_TYPE_R2:
	153	mm->context.asce_limit = 1UL << 42;
	154	mm->context.asce_bits = _ASCE_TABLE_LENGTH \|
	155	_ASCE_USER_BITS \|
	156	_ASCE_TYPE_REGION3;
	157	break;
	158	case _REGION_ENTRY_TYPE_R3:
	159	mm->context.asce_limit = 1UL << 31;
	160	mm->context.asce_bits = _ASCE_TABLE_LENGTH \|
	161	_ASCE_USER_BITS \|
	162	_ASCE_TYPE_SEGMENT;
	163	break;
	164	default:
	165	BUG();
	166	}
	167	mm->pgd = (pgd_t ) (pgd_val(pgd) & _REGION_ENTRY_ORIGIN);
f481bfaf	168	mm->task_size = mm->context.asce_limit;
6252d702 MS	169	crst_table_free(mm, (unsigned long *) pgd);
	170	}
	171	update_mm(mm, current);
	172	}
	173	#endif
	174
3610cce8 MS	175	/*
	176	* page table entry allocation/free routines.
	177	*/
146e4b3c	178	unsigned long page_table_alloc(struct mm_struct mm)
3610cce8	179	{
146e4b3c	180	struct page *page;
3610cce8	181	unsigned long *table;
146e4b3c	182	unsigned long bits;
3610cce8	183
250cf776	184	bits = (mm->context.noexec \|\| mm->context.has_pgste) ? 3UL : 1UL;
146e4b3c MS	185	spin_lock(&mm->page_table_lock);
	186	page = NULL;
	187	if (!list_empty(&mm->context.pgtable_list)) {
	188	page = list_first_entry(&mm->context.pgtable_list,
	189	struct page, lru);
	190	if ((page->flags & FRAG_MASK) == ((1UL << TABLES_PER_PAGE) - 1))
	191	page = NULL;
	192	}
	193	if (!page) {
	194	spin_unlock(&mm->page_table_lock);
	195	page = alloc_page(GFP_KERNEL\|__GFP_REPEAT);
	196	if (!page)
3610cce8	197	return NULL;
146e4b3c MS	198	pgtable_page_ctor(page);
	199	page->flags &= ~FRAG_MASK;
	200	table = (unsigned long *) page_to_phys(page);
250cf776	201	if (mm->context.has_pgste)
402b0862 CO	202	clear_table_pgstes(table);
	203	else
	204	clear_table(table, _PAGE_TYPE_EMPTY, PAGE_SIZE);
146e4b3c MS	205	spin_lock(&mm->page_table_lock);
146e4b3c MS	206	list_add(&page->lru, &mm->context.pgtable_list);
3610cce8 MS	207	}
3610cce8 MS	208	table = (unsigned long *) page_to_phys(page);
146e4b3c MS	209	while (page->flags & bits) {
	210	table += 256;
	211	bits <<= 1;
	212	}
	213	page->flags \|= bits;
	214	if ((page->flags & FRAG_MASK) == ((1UL << TABLES_PER_PAGE) - 1))
	215	list_move_tail(&page->lru, &mm->context.pgtable_list);
	216	spin_unlock(&mm->page_table_lock);
3610cce8 MS	217	return table;
	218	}
	219
146e4b3c	220	void page_table_free(struct mm_struct mm, unsigned long table)
3610cce8	221	{
146e4b3c MS	222	struct page *page;
146e4b3c MS	223	unsigned long bits;
3610cce8	224
250cf776	225	bits = (mm->context.noexec \|\| mm->context.has_pgste) ? 3UL : 1UL;
146e4b3c MS	226	bits <<= (__pa(table) & (PAGE_SIZE - 1)) / 256 / sizeof(unsigned long);
	227	page = pfn_to_page(__pa(table) >> PAGE_SHIFT);
	228	spin_lock(&mm->page_table_lock);
	229	page->flags ^= bits;
	230	if (page->flags & FRAG_MASK) {
	231	/* Page now has some free pgtable fragments. */
	232	list_move(&page->lru, &mm->context.pgtable_list);
	233	page = NULL;
	234	} else
	235	/* All fragments of the 4K page have been freed. */
	236	list_del(&page->lru);
	237	spin_unlock(&mm->page_table_lock);
	238	if (page) {
	239	pgtable_page_dtor(page);
	240	__free_page(page);
	241	}
	242	}
3610cce8	243
146e4b3c MS	244	void disable_noexec(struct mm_struct mm, struct task_struct tsk)
	245	{
	246	struct page *page;
	247
	248	spin_lock(&mm->page_table_lock);
	249	/* Free shadow region and segment tables. */
	250	list_for_each_entry(page, &mm->context.crst_list, lru)
	251	if (page->index) {
	252	free_pages((unsigned long) page->index, ALLOC_ORDER);
	253	page->index = 0;
	254	}
	255	/* "Free" second halves of page tables. */
	256	list_for_each_entry(page, &mm->context.pgtable_list, lru)
	257	page->flags &= ~SECOND_HALVES;
	258	spin_unlock(&mm->page_table_lock);
	259	mm->context.noexec = 0;
	260	update_mm(mm, tsk);
3610cce8	261	}
402b0862 CO	262
	263	/*
	264	* switch on pgstes for its userspace process (for kvm)
	265	*/
	266	int s390_enable_sie(void)
	267	{
	268	struct task_struct *tsk = current;
74b6b522	269	struct mm_struct mm, old_mm;
402b0862	270
702d9e58 CO	271	/* Do we have switched amode? If no, we cannot do sie */
	272	if (!switch_amode)
	273	return -EINVAL;
	274
74b6b522	275	/* Do we have pgstes? if yes, we are done */
250cf776	276	if (tsk->mm->context.has_pgste)
74b6b522	277	return 0;
402b0862	278
74b6b522 CB	279	/* lets check if we are allowed to replace the mm */
74b6b522 CB	280	task_lock(tsk);
402b0862	281	if (!tsk->mm \|\| atomic_read(&tsk->mm->mm_users) > 1 \|\|
abf137dd	282	tsk->mm != tsk->active_mm \|\| !hlist_empty(&tsk->mm->ioctx_list)) {
74b6b522 CB	283	task_unlock(tsk);
	284	return -EINVAL;
	285	}
	286	task_unlock(tsk);
402b0862	287
250cf776 CB	288	/* we copy the mm and let dup_mm create the page tables with_pgstes */
250cf776 CB	289	tsk->mm->context.alloc_pgste = 1;
402b0862	290	mm = dup_mm(tsk);
250cf776	291	tsk->mm->context.alloc_pgste = 0;
402b0862	292	if (!mm)
74b6b522 CB	293	return -ENOMEM;
74b6b522 CB	294
250cf776	295	/* Now lets check again if something happened */
74b6b522 CB	296	task_lock(tsk);
74b6b522 CB	297	if (!tsk->mm \|\| atomic_read(&tsk->mm->mm_users) > 1 \|\|
abf137dd	298	tsk->mm != tsk->active_mm \|\| !hlist_empty(&tsk->mm->ioctx_list)) {
74b6b522 CB	299	mmput(mm);
	300	task_unlock(tsk);
	301	return -EINVAL;
	302	}
	303
	304	/* ok, we are alone. No ptrace, no threads, etc. */
	305	old_mm = tsk->mm;
402b0862 CO	306	tsk->mm = tsk->active_mm = mm;
	307	preempt_disable();
	308	update_mm(mm, tsk);
005f8eee	309	cpumask_set_cpu(smp_processor_id(), mm_cpumask(mm));
402b0862	310	preempt_enable();
402b0862	311	task_unlock(tsk);
74b6b522 CB	312	mmput(old_mm);
74b6b522 CB	313	return 0;
402b0862 CO	314	}
402b0862 CO	315	EXPORT_SYMBOL_GPL(s390_enable_sie);