2007-10-22 10:52:47 +00:00
|
|
|
/*
|
2012-07-20 09:15:04 +00:00
|
|
|
* Copyright IBM Corp. 2007, 2011
|
2007-10-22 10:52:47 +00:00
|
|
|
* Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/errno.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/gfp.h>
|
2007-10-22 10:52:47 +00:00
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/swap.h>
|
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/highmem.h>
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/quicklist.h>
|
2010-10-25 14:10:11 +00:00
|
|
|
#include <linux/rcupdate.h>
|
2011-07-24 08:48:20 +00:00
|
|
|
#include <linux/slab.h>
|
2007-10-22 10:52:47 +00:00
|
|
|
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/pgalloc.h>
|
|
|
|
#include <asm/tlb.h>
|
|
|
|
#include <asm/tlbflush.h>
|
2008-02-09 17:24:37 +00:00
|
|
|
#include <asm/mmu_context.h>
|
2007-10-22 10:52:47 +00:00
|
|
|
|
|
|
|
#ifndef CONFIG_64BIT
|
|
|
|
#define ALLOC_ORDER 1
|
2011-06-06 12:14:41 +00:00
|
|
|
#define FRAG_MASK 0x0f
|
2007-10-22 10:52:47 +00:00
|
|
|
#else
|
|
|
|
#define ALLOC_ORDER 2
|
2011-06-06 12:14:41 +00:00
|
|
|
#define FRAG_MASK 0x03
|
2007-10-22 10:52:47 +00:00
|
|
|
#endif
|
|
|
|
|
2009-06-12 08:26:33 +00:00
|
|
|
|
2011-05-23 08:24:23 +00:00
|
|
|
unsigned long *crst_table_alloc(struct mm_struct *mm)
|
2007-10-22 10:52:47 +00:00
|
|
|
{
|
|
|
|
struct page *page = alloc_pages(GFP_KERNEL, ALLOC_ORDER);
|
|
|
|
|
|
|
|
if (!page)
|
|
|
|
return NULL;
|
|
|
|
return (unsigned long *) page_to_phys(page);
|
|
|
|
}
|
|
|
|
|
2010-10-25 14:10:11 +00:00
|
|
|
void crst_table_free(struct mm_struct *mm, unsigned long *table)
|
|
|
|
{
|
2011-05-23 08:24:23 +00:00
|
|
|
free_pages((unsigned long) table, ALLOC_ORDER);
|
2010-10-25 14:10:11 +00:00
|
|
|
}
|
|
|
|
|
2008-02-09 17:24:37 +00:00
|
|
|
#ifdef CONFIG_64BIT
|
2013-10-28 13:48:30 +00:00
|
|
|
static void __crst_table_upgrade(void *arg)
|
|
|
|
{
|
|
|
|
struct mm_struct *mm = arg;
|
|
|
|
|
|
|
|
if (current->active_mm == mm)
|
|
|
|
update_mm(mm, current);
|
|
|
|
__tlb_flush_local();
|
|
|
|
}
|
|
|
|
|
2008-02-09 17:24:37 +00:00
|
|
|
int crst_table_upgrade(struct mm_struct *mm, unsigned long limit)
|
|
|
|
{
|
|
|
|
unsigned long *table, *pgd;
|
|
|
|
unsigned long entry;
|
2013-10-28 13:48:30 +00:00
|
|
|
int flush;
|
2008-02-09 17:24:37 +00:00
|
|
|
|
|
|
|
BUG_ON(limit > (1UL << 53));
|
2013-10-28 13:48:30 +00:00
|
|
|
flush = 0;
|
2008-02-09 17:24:37 +00:00
|
|
|
repeat:
|
2011-05-23 08:24:23 +00:00
|
|
|
table = crst_table_alloc(mm);
|
2008-02-09 17:24:37 +00:00
|
|
|
if (!table)
|
|
|
|
return -ENOMEM;
|
2010-10-25 14:10:11 +00:00
|
|
|
spin_lock_bh(&mm->page_table_lock);
|
2008-02-09 17:24:37 +00:00
|
|
|
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;
|
2009-03-18 12:27:36 +00:00
|
|
|
mm->task_size = mm->context.asce_limit;
|
2008-02-09 17:24:37 +00:00
|
|
|
table = NULL;
|
2013-10-28 13:48:30 +00:00
|
|
|
flush = 1;
|
2008-02-09 17:24:37 +00:00
|
|
|
}
|
2010-10-25 14:10:11 +00:00
|
|
|
spin_unlock_bh(&mm->page_table_lock);
|
2008-02-09 17:24:37 +00:00
|
|
|
if (table)
|
|
|
|
crst_table_free(mm, table);
|
|
|
|
if (mm->context.asce_limit < limit)
|
|
|
|
goto repeat;
|
2013-10-28 13:48:30 +00:00
|
|
|
if (flush)
|
|
|
|
on_each_cpu(__crst_table_upgrade, mm, 0);
|
2008-02-09 17:24:37 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void crst_table_downgrade(struct mm_struct *mm, unsigned long limit)
|
|
|
|
{
|
|
|
|
pgd_t *pgd;
|
|
|
|
|
2013-10-28 13:48:30 +00:00
|
|
|
if (current->active_mm == mm)
|
|
|
|
__tlb_flush_mm(mm);
|
2008-02-09 17:24:37 +00:00
|
|
|
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);
|
2009-03-18 12:27:36 +00:00
|
|
|
mm->task_size = mm->context.asce_limit;
|
2008-02-09 17:24:37 +00:00
|
|
|
crst_table_free(mm, (unsigned long *) pgd);
|
|
|
|
}
|
2013-10-28 13:48:30 +00:00
|
|
|
if (current->active_mm == mm)
|
|
|
|
update_mm(mm, current);
|
2008-02-09 17:24:37 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2011-07-24 08:48:20 +00:00
|
|
|
#ifdef CONFIG_PGSTE
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gmap_alloc - allocate a guest address space
|
|
|
|
* @mm: pointer to the parent mm_struct
|
|
|
|
*
|
|
|
|
* Returns a guest address space structure.
|
|
|
|
*/
|
|
|
|
struct gmap *gmap_alloc(struct mm_struct *mm)
|
2011-06-06 12:14:41 +00:00
|
|
|
{
|
2011-07-24 08:48:20 +00:00
|
|
|
struct gmap *gmap;
|
|
|
|
struct page *page;
|
|
|
|
unsigned long *table;
|
2011-06-06 12:14:41 +00:00
|
|
|
|
2011-07-24 08:48:20 +00:00
|
|
|
gmap = kzalloc(sizeof(struct gmap), GFP_KERNEL);
|
|
|
|
if (!gmap)
|
|
|
|
goto out;
|
|
|
|
INIT_LIST_HEAD(&gmap->crst_list);
|
|
|
|
gmap->mm = mm;
|
|
|
|
page = alloc_pages(GFP_KERNEL, ALLOC_ORDER);
|
|
|
|
if (!page)
|
|
|
|
goto out_free;
|
|
|
|
list_add(&page->lru, &gmap->crst_list);
|
|
|
|
table = (unsigned long *) page_to_phys(page);
|
|
|
|
crst_table_init(table, _REGION1_ENTRY_EMPTY);
|
|
|
|
gmap->table = table;
|
2011-09-20 15:07:28 +00:00
|
|
|
gmap->asce = _ASCE_TYPE_REGION1 | _ASCE_TABLE_LENGTH |
|
|
|
|
_ASCE_USER_BITS | __pa(table);
|
2011-07-24 08:48:20 +00:00
|
|
|
list_add(&gmap->list, &mm->context.gmap_list);
|
|
|
|
return gmap;
|
|
|
|
|
|
|
|
out_free:
|
|
|
|
kfree(gmap);
|
|
|
|
out:
|
|
|
|
return NULL;
|
2011-06-06 12:14:41 +00:00
|
|
|
}
|
2011-07-24 08:48:20 +00:00
|
|
|
EXPORT_SYMBOL_GPL(gmap_alloc);
|
2011-06-06 12:14:41 +00:00
|
|
|
|
2011-07-24 08:48:20 +00:00
|
|
|
static int gmap_unlink_segment(struct gmap *gmap, unsigned long *table)
|
|
|
|
{
|
|
|
|
struct gmap_pgtable *mp;
|
|
|
|
struct gmap_rmap *rmap;
|
|
|
|
struct page *page;
|
|
|
|
|
2013-07-23 18:57:57 +00:00
|
|
|
if (*table & _SEGMENT_ENTRY_INVALID)
|
2011-07-24 08:48:20 +00:00
|
|
|
return 0;
|
|
|
|
page = pfn_to_page(*table >> PAGE_SHIFT);
|
|
|
|
mp = (struct gmap_pgtable *) page->index;
|
|
|
|
list_for_each_entry(rmap, &mp->mapper, list) {
|
|
|
|
if (rmap->entry != table)
|
|
|
|
continue;
|
|
|
|
list_del(&rmap->list);
|
|
|
|
kfree(rmap);
|
|
|
|
break;
|
|
|
|
}
|
2013-07-23 18:57:57 +00:00
|
|
|
*table = mp->vmaddr | _SEGMENT_ENTRY_INVALID | _SEGMENT_ENTRY_PROTECT;
|
2011-07-24 08:48:20 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void gmap_flush_tlb(struct gmap *gmap)
|
|
|
|
{
|
|
|
|
if (MACHINE_HAS_IDTE)
|
|
|
|
__tlb_flush_idte((unsigned long) gmap->table |
|
|
|
|
_ASCE_TYPE_REGION1);
|
|
|
|
else
|
|
|
|
__tlb_flush_global();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gmap_free - free a guest address space
|
|
|
|
* @gmap: pointer to the guest address space structure
|
2007-10-22 10:52:47 +00:00
|
|
|
*/
|
2011-07-24 08:48:20 +00:00
|
|
|
void gmap_free(struct gmap *gmap)
|
|
|
|
{
|
|
|
|
struct page *page, *next;
|
|
|
|
unsigned long *table;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
|
|
/* Flush tlb. */
|
|
|
|
if (MACHINE_HAS_IDTE)
|
|
|
|
__tlb_flush_idte((unsigned long) gmap->table |
|
|
|
|
_ASCE_TYPE_REGION1);
|
|
|
|
else
|
|
|
|
__tlb_flush_global();
|
|
|
|
|
|
|
|
/* Free all segment & region tables. */
|
|
|
|
down_read(&gmap->mm->mmap_sem);
|
2011-10-30 14:17:01 +00:00
|
|
|
spin_lock(&gmap->mm->page_table_lock);
|
2011-07-24 08:48:20 +00:00
|
|
|
list_for_each_entry_safe(page, next, &gmap->crst_list, lru) {
|
|
|
|
table = (unsigned long *) page_to_phys(page);
|
|
|
|
if ((*table & _REGION_ENTRY_TYPE_MASK) == 0)
|
|
|
|
/* Remove gmap rmap structures for segment table. */
|
|
|
|
for (i = 0; i < PTRS_PER_PMD; i++, table++)
|
|
|
|
gmap_unlink_segment(gmap, table);
|
|
|
|
__free_pages(page, ALLOC_ORDER);
|
|
|
|
}
|
2011-10-30 14:17:01 +00:00
|
|
|
spin_unlock(&gmap->mm->page_table_lock);
|
2011-07-24 08:48:20 +00:00
|
|
|
up_read(&gmap->mm->mmap_sem);
|
|
|
|
list_del(&gmap->list);
|
|
|
|
kfree(gmap);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gmap_free);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gmap_enable - switch primary space to the guest address space
|
|
|
|
* @gmap: pointer to the guest address space structure
|
|
|
|
*/
|
|
|
|
void gmap_enable(struct gmap *gmap)
|
|
|
|
{
|
|
|
|
S390_lowcore.gmap = (unsigned long) gmap;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gmap_enable);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gmap_disable - switch back to the standard primary address space
|
|
|
|
* @gmap: pointer to the guest address space structure
|
|
|
|
*/
|
|
|
|
void gmap_disable(struct gmap *gmap)
|
|
|
|
{
|
|
|
|
S390_lowcore.gmap = 0UL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gmap_disable);
|
|
|
|
|
2011-10-30 14:17:00 +00:00
|
|
|
/*
|
|
|
|
* gmap_alloc_table is assumed to be called with mmap_sem held
|
|
|
|
*/
|
2011-07-24 08:48:20 +00:00
|
|
|
static int gmap_alloc_table(struct gmap *gmap,
|
2013-09-06 16:48:58 +00:00
|
|
|
unsigned long *table, unsigned long init)
|
|
|
|
__releases(&gmap->mm->page_table_lock)
|
|
|
|
__acquires(&gmap->mm->page_table_lock)
|
2011-07-24 08:48:20 +00:00
|
|
|
{
|
|
|
|
struct page *page;
|
|
|
|
unsigned long *new;
|
|
|
|
|
[S390] kvm: fix sleeping function ... at mm/page_alloc.c:2260
commit cc772456ac9b460693492b3a3d89e8c81eda5874
[S390] fix list corruption in gmap reverse mapping
added a potential dead lock:
BUG: sleeping function called from invalid context at mm/page_alloc.c:2260
in_atomic(): 1, irqs_disabled(): 0, pid: 1108, name: qemu-system-s39
3 locks held by qemu-system-s39/1108:
#0: (&kvm->slots_lock){+.+.+.}, at: [<000003e004866542>] kvm_set_memory_region+0x3a/0x6c [kvm]
#1: (&mm->mmap_sem){++++++}, at: [<0000000000123790>] gmap_map_segment+0x9c/0x298
#2: (&(&mm->page_table_lock)->rlock){+.+.+.}, at: [<00000000001237a8>] gmap_map_segment+0xb4/0x298
CPU: 0 Not tainted 3.1.3 #45
Process qemu-system-s39 (pid: 1108, task: 00000004f8b3cb30, ksp: 00000004fd5978d0)
00000004fd5979a0 00000004fd597920 0000000000000002 0000000000000000
00000004fd5979c0 00000004fd597938 00000004fd597938 0000000000617e96
0000000000000000 00000004f8b3cf58 0000000000000000 0000000000000000
000000000000000d 000000000000000c 00000004fd597988 0000000000000000
0000000000000000 0000000000100a18 00000004fd597920 00000004fd597960
Call Trace:
([<0000000000100926>] show_trace+0xee/0x144)
[<0000000000131f3a>] __might_sleep+0x12a/0x158
[<0000000000217fb4>] __alloc_pages_nodemask+0x224/0xadc
[<0000000000123086>] gmap_alloc_table+0x46/0x114
[<000000000012395c>] gmap_map_segment+0x268/0x298
[<000003e00486b014>] kvm_arch_commit_memory_region+0x44/0x6c [kvm]
[<000003e004866414>] __kvm_set_memory_region+0x3b0/0x4a4 [kvm]
[<000003e004866554>] kvm_set_memory_region+0x4c/0x6c [kvm]
[<000003e004867c7a>] kvm_vm_ioctl+0x14a/0x314 [kvm]
[<0000000000292100>] do_vfs_ioctl+0x94/0x588
[<0000000000292688>] SyS_ioctl+0x94/0xac
[<000000000061e124>] sysc_noemu+0x22/0x28
[<000003fffcd5e7ca>] 0x3fffcd5e7ca
3 locks held by qemu-system-s39/1108:
#0: (&kvm->slots_lock){+.+.+.}, at: [<000003e004866542>] kvm_set_memory_region+0x3a/0x6c [kvm]
#1: (&mm->mmap_sem){++++++}, at: [<0000000000123790>] gmap_map_segment+0x9c/0x298
#2: (&(&mm->page_table_lock)->rlock){+.+.+.}, at: [<00000000001237a8>] gmap_map_segment+0xb4/0x298
Fix this by freeing the lock on the alloc path. This is ok, since the
gmap table is never freed until we call gmap_free, so the table we are
walking cannot go.
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
2011-12-27 10:25:47 +00:00
|
|
|
/* since we dont free the gmap table until gmap_free we can unlock */
|
|
|
|
spin_unlock(&gmap->mm->page_table_lock);
|
2011-07-24 08:48:20 +00:00
|
|
|
page = alloc_pages(GFP_KERNEL, ALLOC_ORDER);
|
[S390] kvm: fix sleeping function ... at mm/page_alloc.c:2260
commit cc772456ac9b460693492b3a3d89e8c81eda5874
[S390] fix list corruption in gmap reverse mapping
added a potential dead lock:
BUG: sleeping function called from invalid context at mm/page_alloc.c:2260
in_atomic(): 1, irqs_disabled(): 0, pid: 1108, name: qemu-system-s39
3 locks held by qemu-system-s39/1108:
#0: (&kvm->slots_lock){+.+.+.}, at: [<000003e004866542>] kvm_set_memory_region+0x3a/0x6c [kvm]
#1: (&mm->mmap_sem){++++++}, at: [<0000000000123790>] gmap_map_segment+0x9c/0x298
#2: (&(&mm->page_table_lock)->rlock){+.+.+.}, at: [<00000000001237a8>] gmap_map_segment+0xb4/0x298
CPU: 0 Not tainted 3.1.3 #45
Process qemu-system-s39 (pid: 1108, task: 00000004f8b3cb30, ksp: 00000004fd5978d0)
00000004fd5979a0 00000004fd597920 0000000000000002 0000000000000000
00000004fd5979c0 00000004fd597938 00000004fd597938 0000000000617e96
0000000000000000 00000004f8b3cf58 0000000000000000 0000000000000000
000000000000000d 000000000000000c 00000004fd597988 0000000000000000
0000000000000000 0000000000100a18 00000004fd597920 00000004fd597960
Call Trace:
([<0000000000100926>] show_trace+0xee/0x144)
[<0000000000131f3a>] __might_sleep+0x12a/0x158
[<0000000000217fb4>] __alloc_pages_nodemask+0x224/0xadc
[<0000000000123086>] gmap_alloc_table+0x46/0x114
[<000000000012395c>] gmap_map_segment+0x268/0x298
[<000003e00486b014>] kvm_arch_commit_memory_region+0x44/0x6c [kvm]
[<000003e004866414>] __kvm_set_memory_region+0x3b0/0x4a4 [kvm]
[<000003e004866554>] kvm_set_memory_region+0x4c/0x6c [kvm]
[<000003e004867c7a>] kvm_vm_ioctl+0x14a/0x314 [kvm]
[<0000000000292100>] do_vfs_ioctl+0x94/0x588
[<0000000000292688>] SyS_ioctl+0x94/0xac
[<000000000061e124>] sysc_noemu+0x22/0x28
[<000003fffcd5e7ca>] 0x3fffcd5e7ca
3 locks held by qemu-system-s39/1108:
#0: (&kvm->slots_lock){+.+.+.}, at: [<000003e004866542>] kvm_set_memory_region+0x3a/0x6c [kvm]
#1: (&mm->mmap_sem){++++++}, at: [<0000000000123790>] gmap_map_segment+0x9c/0x298
#2: (&(&mm->page_table_lock)->rlock){+.+.+.}, at: [<00000000001237a8>] gmap_map_segment+0xb4/0x298
Fix this by freeing the lock on the alloc path. This is ok, since the
gmap table is never freed until we call gmap_free, so the table we are
walking cannot go.
Signed-off-by: Christian Borntraeger <borntraeger@de.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
2011-12-27 10:25:47 +00:00
|
|
|
spin_lock(&gmap->mm->page_table_lock);
|
2011-07-24 08:48:20 +00:00
|
|
|
if (!page)
|
|
|
|
return -ENOMEM;
|
|
|
|
new = (unsigned long *) page_to_phys(page);
|
|
|
|
crst_table_init(new, init);
|
2013-07-23 18:57:57 +00:00
|
|
|
if (*table & _REGION_ENTRY_INVALID) {
|
2011-07-24 08:48:20 +00:00
|
|
|
list_add(&page->lru, &gmap->crst_list);
|
|
|
|
*table = (unsigned long) new | _REGION_ENTRY_LENGTH |
|
|
|
|
(*table & _REGION_ENTRY_TYPE_MASK);
|
|
|
|
} else
|
|
|
|
__free_pages(page, ALLOC_ORDER);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gmap_unmap_segment - unmap segment from the guest address space
|
|
|
|
* @gmap: pointer to the guest address space structure
|
|
|
|
* @addr: address in the guest address space
|
|
|
|
* @len: length of the memory area to unmap
|
|
|
|
*
|
2013-12-13 11:53:42 +00:00
|
|
|
* Returns 0 if the unmap succeeded, -EINVAL if not.
|
2011-07-24 08:48:20 +00:00
|
|
|
*/
|
|
|
|
int gmap_unmap_segment(struct gmap *gmap, unsigned long to, unsigned long len)
|
|
|
|
{
|
|
|
|
unsigned long *table;
|
|
|
|
unsigned long off;
|
|
|
|
int flush;
|
|
|
|
|
|
|
|
if ((to | len) & (PMD_SIZE - 1))
|
|
|
|
return -EINVAL;
|
|
|
|
if (len == 0 || to + len < to)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
flush = 0;
|
|
|
|
down_read(&gmap->mm->mmap_sem);
|
2011-10-30 14:17:01 +00:00
|
|
|
spin_lock(&gmap->mm->page_table_lock);
|
2011-07-24 08:48:20 +00:00
|
|
|
for (off = 0; off < len; off += PMD_SIZE) {
|
|
|
|
/* Walk the guest addr space page table */
|
|
|
|
table = gmap->table + (((to + off) >> 53) & 0x7ff);
|
2013-07-23 18:57:57 +00:00
|
|
|
if (*table & _REGION_ENTRY_INVALID)
|
2011-09-26 14:40:34 +00:00
|
|
|
goto out;
|
2011-07-24 08:48:20 +00:00
|
|
|
table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
|
|
|
|
table = table + (((to + off) >> 42) & 0x7ff);
|
2013-07-23 18:57:57 +00:00
|
|
|
if (*table & _REGION_ENTRY_INVALID)
|
2011-09-26 14:40:34 +00:00
|
|
|
goto out;
|
2011-07-24 08:48:20 +00:00
|
|
|
table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
|
|
|
|
table = table + (((to + off) >> 31) & 0x7ff);
|
2013-07-23 18:57:57 +00:00
|
|
|
if (*table & _REGION_ENTRY_INVALID)
|
2011-09-26 14:40:34 +00:00
|
|
|
goto out;
|
2011-07-24 08:48:20 +00:00
|
|
|
table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
|
|
|
|
table = table + (((to + off) >> 20) & 0x7ff);
|
|
|
|
|
|
|
|
/* Clear segment table entry in guest address space. */
|
|
|
|
flush |= gmap_unlink_segment(gmap, table);
|
2013-07-23 18:57:57 +00:00
|
|
|
*table = _SEGMENT_ENTRY_INVALID;
|
2011-07-24 08:48:20 +00:00
|
|
|
}
|
2011-09-26 14:40:34 +00:00
|
|
|
out:
|
2011-10-30 14:17:01 +00:00
|
|
|
spin_unlock(&gmap->mm->page_table_lock);
|
2011-07-24 08:48:20 +00:00
|
|
|
up_read(&gmap->mm->mmap_sem);
|
|
|
|
if (flush)
|
|
|
|
gmap_flush_tlb(gmap);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gmap_unmap_segment);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gmap_mmap_segment - map a segment to the guest address space
|
|
|
|
* @gmap: pointer to the guest address space structure
|
|
|
|
* @from: source address in the parent address space
|
|
|
|
* @to: target address in the guest address space
|
|
|
|
*
|
2013-12-13 11:53:42 +00:00
|
|
|
* Returns 0 if the mmap succeeded, -EINVAL or -ENOMEM if not.
|
2011-07-24 08:48:20 +00:00
|
|
|
*/
|
|
|
|
int gmap_map_segment(struct gmap *gmap, unsigned long from,
|
|
|
|
unsigned long to, unsigned long len)
|
|
|
|
{
|
|
|
|
unsigned long *table;
|
|
|
|
unsigned long off;
|
|
|
|
int flush;
|
|
|
|
|
|
|
|
if ((from | to | len) & (PMD_SIZE - 1))
|
|
|
|
return -EINVAL;
|
2013-07-26 13:04:03 +00:00
|
|
|
if (len == 0 || from + len > TASK_MAX_SIZE ||
|
2011-07-24 08:48:20 +00:00
|
|
|
from + len < from || to + len < to)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
flush = 0;
|
|
|
|
down_read(&gmap->mm->mmap_sem);
|
2011-10-30 14:17:01 +00:00
|
|
|
spin_lock(&gmap->mm->page_table_lock);
|
2011-07-24 08:48:20 +00:00
|
|
|
for (off = 0; off < len; off += PMD_SIZE) {
|
|
|
|
/* Walk the gmap address space page table */
|
|
|
|
table = gmap->table + (((to + off) >> 53) & 0x7ff);
|
2013-07-23 18:57:57 +00:00
|
|
|
if ((*table & _REGION_ENTRY_INVALID) &&
|
2011-07-24 08:48:20 +00:00
|
|
|
gmap_alloc_table(gmap, table, _REGION2_ENTRY_EMPTY))
|
|
|
|
goto out_unmap;
|
|
|
|
table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
|
|
|
|
table = table + (((to + off) >> 42) & 0x7ff);
|
2013-07-23 18:57:57 +00:00
|
|
|
if ((*table & _REGION_ENTRY_INVALID) &&
|
2011-07-24 08:48:20 +00:00
|
|
|
gmap_alloc_table(gmap, table, _REGION3_ENTRY_EMPTY))
|
|
|
|
goto out_unmap;
|
|
|
|
table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
|
|
|
|
table = table + (((to + off) >> 31) & 0x7ff);
|
2013-07-23 18:57:57 +00:00
|
|
|
if ((*table & _REGION_ENTRY_INVALID) &&
|
2011-07-24 08:48:20 +00:00
|
|
|
gmap_alloc_table(gmap, table, _SEGMENT_ENTRY_EMPTY))
|
|
|
|
goto out_unmap;
|
|
|
|
table = (unsigned long *) (*table & _REGION_ENTRY_ORIGIN);
|
|
|
|
table = table + (((to + off) >> 20) & 0x7ff);
|
|
|
|
|
|
|
|
/* Store 'from' address in an invalid segment table entry. */
|
|
|
|
flush |= gmap_unlink_segment(gmap, table);
|
2013-07-23 18:57:57 +00:00
|
|
|
*table = (from + off) | (_SEGMENT_ENTRY_INVALID |
|
|
|
|
_SEGMENT_ENTRY_PROTECT);
|
2011-07-24 08:48:20 +00:00
|
|
|
}
|
2011-10-30 14:17:01 +00:00
|
|
|
spin_unlock(&gmap->mm->page_table_lock);
|
2011-07-24 08:48:20 +00:00
|
|
|
up_read(&gmap->mm->mmap_sem);
|
|
|
|
if (flush)
|
|
|
|
gmap_flush_tlb(gmap);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_unmap:
|
2011-10-30 14:17:01 +00:00
|
|
|
spin_unlock(&gmap->mm->page_table_lock);
|
2011-07-24 08:48:20 +00:00
|
|
|
up_read(&gmap->mm->mmap_sem);
|
|
|
|
gmap_unmap_segment(gmap, to, len);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gmap_map_segment);
|
|
|
|
|
2012-09-10 14:14:33 +00:00
|
|
|
static unsigned long *gmap_table_walk(unsigned long address, struct gmap *gmap)
|
|
|
|
{
|
|
|
|
unsigned long *table;
|
|
|
|
|
|
|
|
table = gmap->table + ((address >> 53) & 0x7ff);
|
2013-07-23 18:57:57 +00:00
|
|
|
if (unlikely(*table & _REGION_ENTRY_INVALID))
|
2012-09-10 14:14:33 +00:00
|
|
|
return ERR_PTR(-EFAULT);
|
|
|
|
table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
|
|
|
|
table = table + ((address >> 42) & 0x7ff);
|
2013-07-23 18:57:57 +00:00
|
|
|
if (unlikely(*table & _REGION_ENTRY_INVALID))
|
2012-09-10 14:14:33 +00:00
|
|
|
return ERR_PTR(-EFAULT);
|
|
|
|
table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
|
|
|
|
table = table + ((address >> 31) & 0x7ff);
|
2013-07-23 18:57:57 +00:00
|
|
|
if (unlikely(*table & _REGION_ENTRY_INVALID))
|
2012-09-10 14:14:33 +00:00
|
|
|
return ERR_PTR(-EFAULT);
|
|
|
|
table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
|
|
|
|
table = table + ((address >> 20) & 0x7ff);
|
|
|
|
return table;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __gmap_translate - translate a guest address to a user space address
|
|
|
|
* @address: guest address
|
|
|
|
* @gmap: pointer to guest mapping meta data structure
|
|
|
|
*
|
|
|
|
* Returns user space address which corresponds to the guest address or
|
|
|
|
* -EFAULT if no such mapping exists.
|
|
|
|
* This function does not establish potentially missing page table entries.
|
|
|
|
* The mmap_sem of the mm that belongs to the address space must be held
|
|
|
|
* when this function gets called.
|
|
|
|
*/
|
|
|
|
unsigned long __gmap_translate(unsigned long address, struct gmap *gmap)
|
|
|
|
{
|
|
|
|
unsigned long *segment_ptr, vmaddr, segment;
|
|
|
|
struct gmap_pgtable *mp;
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
current->thread.gmap_addr = address;
|
|
|
|
segment_ptr = gmap_table_walk(address, gmap);
|
|
|
|
if (IS_ERR(segment_ptr))
|
|
|
|
return PTR_ERR(segment_ptr);
|
|
|
|
/* Convert the gmap address to an mm address. */
|
|
|
|
segment = *segment_ptr;
|
2013-07-23 18:57:57 +00:00
|
|
|
if (!(segment & _SEGMENT_ENTRY_INVALID)) {
|
2012-09-10 14:14:33 +00:00
|
|
|
page = pfn_to_page(segment >> PAGE_SHIFT);
|
|
|
|
mp = (struct gmap_pgtable *) page->index;
|
|
|
|
return mp->vmaddr | (address & ~PMD_MASK);
|
2013-07-23 18:57:57 +00:00
|
|
|
} else if (segment & _SEGMENT_ENTRY_PROTECT) {
|
2012-09-10 14:14:33 +00:00
|
|
|
vmaddr = segment & _SEGMENT_ENTRY_ORIGIN;
|
|
|
|
return vmaddr | (address & ~PMD_MASK);
|
|
|
|
}
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(__gmap_translate);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gmap_translate - translate a guest address to a user space address
|
|
|
|
* @address: guest address
|
|
|
|
* @gmap: pointer to guest mapping meta data structure
|
|
|
|
*
|
|
|
|
* Returns user space address which corresponds to the guest address or
|
|
|
|
* -EFAULT if no such mapping exists.
|
|
|
|
* This function does not establish potentially missing page table entries.
|
|
|
|
*/
|
|
|
|
unsigned long gmap_translate(unsigned long address, struct gmap *gmap)
|
|
|
|
{
|
|
|
|
unsigned long rc;
|
|
|
|
|
|
|
|
down_read(&gmap->mm->mmap_sem);
|
|
|
|
rc = __gmap_translate(address, gmap);
|
|
|
|
up_read(&gmap->mm->mmap_sem);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gmap_translate);
|
|
|
|
|
2013-04-17 08:53:39 +00:00
|
|
|
static int gmap_connect_pgtable(unsigned long address, unsigned long segment,
|
|
|
|
unsigned long *segment_ptr, struct gmap *gmap)
|
2011-07-24 08:48:20 +00:00
|
|
|
{
|
2013-04-16 11:37:46 +00:00
|
|
|
unsigned long vmaddr;
|
2012-09-10 14:14:33 +00:00
|
|
|
struct vm_area_struct *vma;
|
2011-07-24 08:48:20 +00:00
|
|
|
struct gmap_pgtable *mp;
|
|
|
|
struct gmap_rmap *rmap;
|
2012-09-10 14:14:33 +00:00
|
|
|
struct mm_struct *mm;
|
2011-07-24 08:48:20 +00:00
|
|
|
struct page *page;
|
|
|
|
pgd_t *pgd;
|
|
|
|
pud_t *pud;
|
|
|
|
pmd_t *pmd;
|
|
|
|
|
2013-04-16 11:37:46 +00:00
|
|
|
mm = gmap->mm;
|
|
|
|
vmaddr = segment & _SEGMENT_ENTRY_ORIGIN;
|
|
|
|
vma = find_vma(mm, vmaddr);
|
|
|
|
if (!vma || vma->vm_start > vmaddr)
|
|
|
|
return -EFAULT;
|
|
|
|
/* Walk the parent mm page table */
|
|
|
|
pgd = pgd_offset(mm, vmaddr);
|
|
|
|
pud = pud_alloc(mm, pgd, vmaddr);
|
|
|
|
if (!pud)
|
|
|
|
return -ENOMEM;
|
|
|
|
pmd = pmd_alloc(mm, pud, vmaddr);
|
|
|
|
if (!pmd)
|
|
|
|
return -ENOMEM;
|
|
|
|
if (!pmd_present(*pmd) &&
|
|
|
|
__pte_alloc(mm, vma, pmd, vmaddr))
|
|
|
|
return -ENOMEM;
|
|
|
|
/* pmd now points to a valid segment table entry. */
|
|
|
|
rmap = kmalloc(sizeof(*rmap), GFP_KERNEL|__GFP_REPEAT);
|
|
|
|
if (!rmap)
|
|
|
|
return -ENOMEM;
|
|
|
|
/* Link gmap segment table entry location to page table. */
|
|
|
|
page = pmd_page(*pmd);
|
|
|
|
mp = (struct gmap_pgtable *) page->index;
|
2013-04-17 08:53:39 +00:00
|
|
|
rmap->gmap = gmap;
|
2013-04-16 11:37:46 +00:00
|
|
|
rmap->entry = segment_ptr;
|
2013-05-29 11:08:39 +00:00
|
|
|
rmap->vmaddr = address & PMD_MASK;
|
2013-04-16 11:37:46 +00:00
|
|
|
spin_lock(&mm->page_table_lock);
|
|
|
|
if (*segment_ptr == segment) {
|
|
|
|
list_add(&rmap->list, &mp->mapper);
|
|
|
|
/* Set gmap segment table entry to page table. */
|
|
|
|
*segment_ptr = pmd_val(*pmd) & PAGE_MASK;
|
|
|
|
rmap = NULL;
|
|
|
|
}
|
|
|
|
spin_unlock(&mm->page_table_lock);
|
|
|
|
kfree(rmap);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void gmap_disconnect_pgtable(struct mm_struct *mm, unsigned long *table)
|
|
|
|
{
|
|
|
|
struct gmap_rmap *rmap, *next;
|
|
|
|
struct gmap_pgtable *mp;
|
|
|
|
struct page *page;
|
|
|
|
int flush;
|
|
|
|
|
|
|
|
flush = 0;
|
|
|
|
spin_lock(&mm->page_table_lock);
|
|
|
|
page = pfn_to_page(__pa(table) >> PAGE_SHIFT);
|
|
|
|
mp = (struct gmap_pgtable *) page->index;
|
|
|
|
list_for_each_entry_safe(rmap, next, &mp->mapper, list) {
|
2013-07-23 18:57:57 +00:00
|
|
|
*rmap->entry = mp->vmaddr | (_SEGMENT_ENTRY_INVALID |
|
|
|
|
_SEGMENT_ENTRY_PROTECT);
|
2013-04-16 11:37:46 +00:00
|
|
|
list_del(&rmap->list);
|
|
|
|
kfree(rmap);
|
|
|
|
flush = 1;
|
|
|
|
}
|
|
|
|
spin_unlock(&mm->page_table_lock);
|
|
|
|
if (flush)
|
|
|
|
__tlb_flush_global();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this function is assumed to be called with mmap_sem held
|
|
|
|
*/
|
|
|
|
unsigned long __gmap_fault(unsigned long address, struct gmap *gmap)
|
|
|
|
{
|
|
|
|
unsigned long *segment_ptr, segment;
|
|
|
|
struct gmap_pgtable *mp;
|
|
|
|
struct page *page;
|
|
|
|
int rc;
|
|
|
|
|
2011-07-24 08:48:20 +00:00
|
|
|
current->thread.gmap_addr = address;
|
2012-09-10 14:14:33 +00:00
|
|
|
segment_ptr = gmap_table_walk(address, gmap);
|
|
|
|
if (IS_ERR(segment_ptr))
|
2011-07-24 08:48:20 +00:00
|
|
|
return -EFAULT;
|
|
|
|
/* Convert the gmap address to an mm address. */
|
2013-04-16 11:37:46 +00:00
|
|
|
while (1) {
|
|
|
|
segment = *segment_ptr;
|
2013-07-23 18:57:57 +00:00
|
|
|
if (!(segment & _SEGMENT_ENTRY_INVALID)) {
|
2013-04-16 11:37:46 +00:00
|
|
|
/* Page table is present */
|
|
|
|
page = pfn_to_page(segment >> PAGE_SHIFT);
|
|
|
|
mp = (struct gmap_pgtable *) page->index;
|
|
|
|
return mp->vmaddr | (address & ~PMD_MASK);
|
|
|
|
}
|
2013-07-23 18:57:57 +00:00
|
|
|
if (!(segment & _SEGMENT_ENTRY_PROTECT))
|
2013-04-16 11:37:46 +00:00
|
|
|
/* Nothing mapped in the gmap address space. */
|
|
|
|
break;
|
2013-04-17 08:53:39 +00:00
|
|
|
rc = gmap_connect_pgtable(address, segment, segment_ptr, gmap);
|
2013-04-16 11:37:46 +00:00
|
|
|
if (rc)
|
|
|
|
return rc;
|
2011-07-24 08:48:20 +00:00
|
|
|
}
|
|
|
|
return -EFAULT;
|
2011-10-30 14:17:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
unsigned long gmap_fault(unsigned long address, struct gmap *gmap)
|
|
|
|
{
|
|
|
|
unsigned long rc;
|
|
|
|
|
|
|
|
down_read(&gmap->mm->mmap_sem);
|
|
|
|
rc = __gmap_fault(address, gmap);
|
|
|
|
up_read(&gmap->mm->mmap_sem);
|
2011-07-24 08:48:20 +00:00
|
|
|
|
2011-10-30 14:17:02 +00:00
|
|
|
return rc;
|
2011-07-24 08:48:20 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gmap_fault);
|
|
|
|
|
2011-10-30 14:17:03 +00:00
|
|
|
void gmap_discard(unsigned long from, unsigned long to, struct gmap *gmap)
|
|
|
|
{
|
|
|
|
|
|
|
|
unsigned long *table, address, size;
|
|
|
|
struct vm_area_struct *vma;
|
|
|
|
struct gmap_pgtable *mp;
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
down_read(&gmap->mm->mmap_sem);
|
|
|
|
address = from;
|
|
|
|
while (address < to) {
|
|
|
|
/* Walk the gmap address space page table */
|
|
|
|
table = gmap->table + ((address >> 53) & 0x7ff);
|
2013-07-23 18:57:57 +00:00
|
|
|
if (unlikely(*table & _REGION_ENTRY_INVALID)) {
|
2011-10-30 14:17:03 +00:00
|
|
|
address = (address + PMD_SIZE) & PMD_MASK;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
|
|
|
|
table = table + ((address >> 42) & 0x7ff);
|
2013-07-23 18:57:57 +00:00
|
|
|
if (unlikely(*table & _REGION_ENTRY_INVALID)) {
|
2011-10-30 14:17:03 +00:00
|
|
|
address = (address + PMD_SIZE) & PMD_MASK;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
|
|
|
|
table = table + ((address >> 31) & 0x7ff);
|
2013-07-23 18:57:57 +00:00
|
|
|
if (unlikely(*table & _REGION_ENTRY_INVALID)) {
|
2011-10-30 14:17:03 +00:00
|
|
|
address = (address + PMD_SIZE) & PMD_MASK;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
table = (unsigned long *)(*table & _REGION_ENTRY_ORIGIN);
|
|
|
|
table = table + ((address >> 20) & 0x7ff);
|
2013-07-23 18:57:57 +00:00
|
|
|
if (unlikely(*table & _SEGMENT_ENTRY_INVALID)) {
|
2011-10-30 14:17:03 +00:00
|
|
|
address = (address + PMD_SIZE) & PMD_MASK;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
page = pfn_to_page(*table >> PAGE_SHIFT);
|
|
|
|
mp = (struct gmap_pgtable *) page->index;
|
|
|
|
vma = find_vma(gmap->mm, mp->vmaddr);
|
|
|
|
size = min(to - address, PMD_SIZE - (address & ~PMD_MASK));
|
|
|
|
zap_page_range(vma, mp->vmaddr | (address & ~PMD_MASK),
|
|
|
|
size, NULL);
|
|
|
|
address = (address + PMD_SIZE) & PMD_MASK;
|
|
|
|
}
|
|
|
|
up_read(&gmap->mm->mmap_sem);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gmap_discard);
|
|
|
|
|
2013-04-17 08:53:39 +00:00
|
|
|
static LIST_HEAD(gmap_notifier_list);
|
|
|
|
static DEFINE_SPINLOCK(gmap_notifier_lock);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gmap_register_ipte_notifier - register a pte invalidation callback
|
|
|
|
* @nb: pointer to the gmap notifier block
|
|
|
|
*/
|
|
|
|
void gmap_register_ipte_notifier(struct gmap_notifier *nb)
|
|
|
|
{
|
|
|
|
spin_lock(&gmap_notifier_lock);
|
|
|
|
list_add(&nb->list, &gmap_notifier_list);
|
|
|
|
spin_unlock(&gmap_notifier_lock);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gmap_register_ipte_notifier);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gmap_unregister_ipte_notifier - remove a pte invalidation callback
|
|
|
|
* @nb: pointer to the gmap notifier block
|
|
|
|
*/
|
|
|
|
void gmap_unregister_ipte_notifier(struct gmap_notifier *nb)
|
|
|
|
{
|
|
|
|
spin_lock(&gmap_notifier_lock);
|
|
|
|
list_del_init(&nb->list);
|
|
|
|
spin_unlock(&gmap_notifier_lock);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gmap_unregister_ipte_notifier);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gmap_ipte_notify - mark a range of ptes for invalidation notification
|
|
|
|
* @gmap: pointer to guest mapping meta data structure
|
|
|
|
* @address: virtual address in the guest address space
|
|
|
|
* @len: size of area
|
|
|
|
*
|
|
|
|
* Returns 0 if for each page in the given range a gmap mapping exists and
|
|
|
|
* the invalidation notification could be set. If the gmap mapping is missing
|
|
|
|
* for one or more pages -EFAULT is returned. If no memory could be allocated
|
|
|
|
* -ENOMEM is returned. This function establishes missing page table entries.
|
|
|
|
*/
|
|
|
|
int gmap_ipte_notify(struct gmap *gmap, unsigned long start, unsigned long len)
|
|
|
|
{
|
|
|
|
unsigned long addr;
|
|
|
|
spinlock_t *ptl;
|
|
|
|
pte_t *ptep, entry;
|
|
|
|
pgste_t pgste;
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
if ((start & ~PAGE_MASK) || (len & ~PAGE_MASK))
|
|
|
|
return -EINVAL;
|
|
|
|
down_read(&gmap->mm->mmap_sem);
|
|
|
|
while (len) {
|
|
|
|
/* Convert gmap address and connect the page tables */
|
|
|
|
addr = __gmap_fault(start, gmap);
|
|
|
|
if (IS_ERR_VALUE(addr)) {
|
|
|
|
rc = addr;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Get the page mapped */
|
2013-05-08 13:25:38 +00:00
|
|
|
if (fixup_user_fault(current, gmap->mm, addr, FAULT_FLAG_WRITE)) {
|
2013-04-17 08:53:39 +00:00
|
|
|
rc = -EFAULT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Walk the process page table, lock and get pte pointer */
|
|
|
|
ptep = get_locked_pte(gmap->mm, addr, &ptl);
|
|
|
|
if (unlikely(!ptep))
|
|
|
|
continue;
|
|
|
|
/* Set notification bit in the pgste of the pte */
|
|
|
|
entry = *ptep;
|
2013-07-23 18:57:57 +00:00
|
|
|
if ((pte_val(entry) & (_PAGE_INVALID | _PAGE_PROTECT)) == 0) {
|
2013-04-17 08:53:39 +00:00
|
|
|
pgste = pgste_get_lock(ptep);
|
2013-05-17 12:41:33 +00:00
|
|
|
pgste_val(pgste) |= PGSTE_IN_BIT;
|
2013-04-17 08:53:39 +00:00
|
|
|
pgste_set_unlock(ptep, pgste);
|
|
|
|
start += PAGE_SIZE;
|
|
|
|
len -= PAGE_SIZE;
|
|
|
|
}
|
|
|
|
spin_unlock(ptl);
|
|
|
|
}
|
|
|
|
up_read(&gmap->mm->mmap_sem);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gmap_ipte_notify);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gmap_do_ipte_notify - call all invalidation callbacks for a specific pte.
|
|
|
|
* @mm: pointer to the process mm_struct
|
|
|
|
* @addr: virtual address in the process address space
|
|
|
|
* @pte: pointer to the page table entry
|
|
|
|
*
|
|
|
|
* This function is assumed to be called with the page table lock held
|
|
|
|
* for the pte to notify.
|
|
|
|
*/
|
|
|
|
void gmap_do_ipte_notify(struct mm_struct *mm, unsigned long addr, pte_t *pte)
|
|
|
|
{
|
|
|
|
unsigned long segment_offset;
|
|
|
|
struct gmap_notifier *nb;
|
|
|
|
struct gmap_pgtable *mp;
|
|
|
|
struct gmap_rmap *rmap;
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
segment_offset = ((unsigned long) pte) & (255 * sizeof(pte_t));
|
|
|
|
segment_offset = segment_offset * (4096 / sizeof(pte_t));
|
|
|
|
page = pfn_to_page(__pa(pte) >> PAGE_SHIFT);
|
|
|
|
mp = (struct gmap_pgtable *) page->index;
|
|
|
|
spin_lock(&gmap_notifier_lock);
|
|
|
|
list_for_each_entry(rmap, &mp->mapper, list) {
|
|
|
|
list_for_each_entry(nb, &gmap_notifier_list, list)
|
|
|
|
nb->notifier_call(rmap->gmap,
|
|
|
|
rmap->vmaddr + segment_offset);
|
|
|
|
}
|
|
|
|
spin_unlock(&gmap_notifier_lock);
|
|
|
|
}
|
|
|
|
|
2013-07-26 13:04:02 +00:00
|
|
|
static inline int page_table_with_pgste(struct page *page)
|
|
|
|
{
|
|
|
|
return atomic_read(&page->_mapcount) == 0;
|
|
|
|
}
|
|
|
|
|
2011-07-24 08:48:20 +00:00
|
|
|
static inline unsigned long *page_table_alloc_pgste(struct mm_struct *mm,
|
|
|
|
unsigned long vmaddr)
|
2011-06-06 12:14:41 +00:00
|
|
|
{
|
|
|
|
struct page *page;
|
|
|
|
unsigned long *table;
|
2011-07-24 08:48:20 +00:00
|
|
|
struct gmap_pgtable *mp;
|
2011-06-06 12:14:41 +00:00
|
|
|
|
|
|
|
page = alloc_page(GFP_KERNEL|__GFP_REPEAT);
|
|
|
|
if (!page)
|
|
|
|
return NULL;
|
2011-07-24 08:48:20 +00:00
|
|
|
mp = kmalloc(sizeof(*mp), GFP_KERNEL|__GFP_REPEAT);
|
|
|
|
if (!mp) {
|
|
|
|
__free_page(page);
|
|
|
|
return NULL;
|
|
|
|
}
|
2013-11-14 22:31:39 +00:00
|
|
|
if (!pgtable_page_ctor(page)) {
|
|
|
|
kfree(mp);
|
|
|
|
__free_page(page);
|
|
|
|
return NULL;
|
|
|
|
}
|
2011-07-24 08:48:20 +00:00
|
|
|
mp->vmaddr = vmaddr & PMD_MASK;
|
|
|
|
INIT_LIST_HEAD(&mp->mapper);
|
|
|
|
page->index = (unsigned long) mp;
|
2013-07-26 13:04:02 +00:00
|
|
|
atomic_set(&page->_mapcount, 0);
|
2011-06-06 12:14:41 +00:00
|
|
|
table = (unsigned long *) page_to_phys(page);
|
2013-07-23 18:57:57 +00:00
|
|
|
clear_table(table, _PAGE_INVALID, PAGE_SIZE/2);
|
2013-07-23 20:11:42 +00:00
|
|
|
clear_table(table + PTRS_PER_PTE, PGSTE_HR_BIT | PGSTE_HC_BIT,
|
|
|
|
PAGE_SIZE/2);
|
2011-06-06 12:14:41 +00:00
|
|
|
return table;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void page_table_free_pgste(unsigned long *table)
|
|
|
|
{
|
|
|
|
struct page *page;
|
2011-07-24 08:48:20 +00:00
|
|
|
struct gmap_pgtable *mp;
|
2011-06-06 12:14:41 +00:00
|
|
|
|
|
|
|
page = pfn_to_page(__pa(table) >> PAGE_SHIFT);
|
2011-07-24 08:48:20 +00:00
|
|
|
mp = (struct gmap_pgtable *) page->index;
|
|
|
|
BUG_ON(!list_empty(&mp->mapper));
|
2012-02-17 09:29:21 +00:00
|
|
|
pgtable_page_dtor(page);
|
2011-06-06 12:14:41 +00:00
|
|
|
atomic_set(&page->_mapcount, -1);
|
2011-07-24 08:48:20 +00:00
|
|
|
kfree(mp);
|
2011-06-06 12:14:41 +00:00
|
|
|
__free_page(page);
|
|
|
|
}
|
|
|
|
|
2013-05-27 08:42:04 +00:00
|
|
|
int set_guest_storage_key(struct mm_struct *mm, unsigned long addr,
|
|
|
|
unsigned long key, bool nq)
|
|
|
|
{
|
|
|
|
spinlock_t *ptl;
|
|
|
|
pgste_t old, new;
|
|
|
|
pte_t *ptep;
|
|
|
|
|
|
|
|
down_read(&mm->mmap_sem);
|
|
|
|
ptep = get_locked_pte(current->mm, addr, &ptl);
|
|
|
|
if (unlikely(!ptep)) {
|
|
|
|
up_read(&mm->mmap_sem);
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
new = old = pgste_get_lock(ptep);
|
|
|
|
pgste_val(new) &= ~(PGSTE_GR_BIT | PGSTE_GC_BIT |
|
|
|
|
PGSTE_ACC_BITS | PGSTE_FP_BIT);
|
|
|
|
pgste_val(new) |= (key & (_PAGE_CHANGED | _PAGE_REFERENCED)) << 48;
|
|
|
|
pgste_val(new) |= (key & (_PAGE_ACC_BITS | _PAGE_FP_BIT)) << 56;
|
|
|
|
if (!(pte_val(*ptep) & _PAGE_INVALID)) {
|
2013-07-23 20:11:42 +00:00
|
|
|
unsigned long address, bits, skey;
|
2013-05-27 08:42:04 +00:00
|
|
|
|
|
|
|
address = pte_val(*ptep) & PAGE_MASK;
|
2013-07-23 20:11:42 +00:00
|
|
|
skey = (unsigned long) page_get_storage_key(address);
|
2013-05-27 08:42:04 +00:00
|
|
|
bits = skey & (_PAGE_CHANGED | _PAGE_REFERENCED);
|
2013-07-23 20:11:42 +00:00
|
|
|
skey = key & (_PAGE_ACC_BITS | _PAGE_FP_BIT);
|
2013-05-27 08:42:04 +00:00
|
|
|
/* Set storage key ACC and FP */
|
2013-07-23 20:11:42 +00:00
|
|
|
page_set_storage_key(address, skey, !nq);
|
2013-05-27 08:42:04 +00:00
|
|
|
/* Merge host changed & referenced into pgste */
|
|
|
|
pgste_val(new) |= bits << 52;
|
|
|
|
}
|
|
|
|
/* changing the guest storage key is considered a change of the page */
|
|
|
|
if ((pgste_val(new) ^ pgste_val(old)) &
|
|
|
|
(PGSTE_ACC_BITS | PGSTE_FP_BIT | PGSTE_GR_BIT | PGSTE_GC_BIT))
|
2013-07-23 20:11:42 +00:00
|
|
|
pgste_val(new) |= PGSTE_HC_BIT;
|
2013-05-27 08:42:04 +00:00
|
|
|
|
|
|
|
pgste_set_unlock(ptep, new);
|
|
|
|
pte_unmap_unlock(*ptep, ptl);
|
|
|
|
up_read(&mm->mmap_sem);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(set_guest_storage_key);
|
|
|
|
|
2011-07-24 08:48:20 +00:00
|
|
|
#else /* CONFIG_PGSTE */
|
|
|
|
|
2013-07-26 13:04:02 +00:00
|
|
|
static inline int page_table_with_pgste(struct page *page)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-07-24 08:48:20 +00:00
|
|
|
static inline unsigned long *page_table_alloc_pgste(struct mm_struct *mm,
|
|
|
|
unsigned long vmaddr)
|
|
|
|
{
|
2011-08-03 14:44:18 +00:00
|
|
|
return NULL;
|
2011-07-24 08:48:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void page_table_free_pgste(unsigned long *table)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-04-16 11:37:46 +00:00
|
|
|
static inline void gmap_disconnect_pgtable(struct mm_struct *mm,
|
|
|
|
unsigned long *table)
|
2011-07-24 08:48:20 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_PGSTE */
|
|
|
|
|
|
|
|
static inline unsigned int atomic_xor_bits(atomic_t *v, unsigned int bits)
|
|
|
|
{
|
|
|
|
unsigned int old, new;
|
|
|
|
|
|
|
|
do {
|
|
|
|
old = atomic_read(v);
|
|
|
|
new = old ^ bits;
|
|
|
|
} while (atomic_cmpxchg(v, old, new) != old);
|
|
|
|
return new;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* page table entry allocation/free routines.
|
|
|
|
*/
|
|
|
|
unsigned long *page_table_alloc(struct mm_struct *mm, unsigned long vmaddr)
|
2007-10-22 10:52:47 +00:00
|
|
|
{
|
2012-09-14 09:09:52 +00:00
|
|
|
unsigned long *uninitialized_var(table);
|
|
|
|
struct page *uninitialized_var(page);
|
2011-06-06 12:14:41 +00:00
|
|
|
unsigned int mask, bit;
|
2007-10-22 10:52:47 +00:00
|
|
|
|
2011-06-06 12:14:41 +00:00
|
|
|
if (mm_has_pgste(mm))
|
2011-07-24 08:48:20 +00:00
|
|
|
return page_table_alloc_pgste(mm, vmaddr);
|
2011-06-06 12:14:41 +00:00
|
|
|
/* Allocate fragments of a 4K page as 1K/2K page table */
|
2010-10-25 14:10:11 +00:00
|
|
|
spin_lock_bh(&mm->context.list_lock);
|
2011-06-06 12:14:41 +00:00
|
|
|
mask = FRAG_MASK;
|
2008-02-09 17:24:35 +00:00
|
|
|
if (!list_empty(&mm->context.pgtable_list)) {
|
|
|
|
page = list_first_entry(&mm->context.pgtable_list,
|
|
|
|
struct page, lru);
|
2011-06-06 12:14:41 +00:00
|
|
|
table = (unsigned long *) page_to_phys(page);
|
|
|
|
mask = atomic_read(&page->_mapcount);
|
|
|
|
mask = mask | (mask >> 4);
|
2008-02-09 17:24:35 +00:00
|
|
|
}
|
2011-06-06 12:14:41 +00:00
|
|
|
if ((mask & FRAG_MASK) == FRAG_MASK) {
|
2010-10-25 14:10:11 +00:00
|
|
|
spin_unlock_bh(&mm->context.list_lock);
|
2008-02-09 17:24:35 +00:00
|
|
|
page = alloc_page(GFP_KERNEL|__GFP_REPEAT);
|
|
|
|
if (!page)
|
2007-10-22 10:52:47 +00:00
|
|
|
return NULL;
|
2013-11-14 22:31:39 +00:00
|
|
|
if (!pgtable_page_ctor(page)) {
|
|
|
|
__free_page(page);
|
|
|
|
return NULL;
|
|
|
|
}
|
2011-06-06 12:14:41 +00:00
|
|
|
atomic_set(&page->_mapcount, 1);
|
2008-02-09 17:24:35 +00:00
|
|
|
table = (unsigned long *) page_to_phys(page);
|
2013-07-23 18:57:57 +00:00
|
|
|
clear_table(table, _PAGE_INVALID, PAGE_SIZE);
|
2010-10-25 14:10:11 +00:00
|
|
|
spin_lock_bh(&mm->context.list_lock);
|
2008-02-09 17:24:35 +00:00
|
|
|
list_add(&page->lru, &mm->context.pgtable_list);
|
2011-06-06 12:14:41 +00:00
|
|
|
} else {
|
|
|
|
for (bit = 1; mask & bit; bit <<= 1)
|
|
|
|
table += PTRS_PER_PTE;
|
|
|
|
mask = atomic_xor_bits(&page->_mapcount, bit);
|
|
|
|
if ((mask & FRAG_MASK) == FRAG_MASK)
|
|
|
|
list_del(&page->lru);
|
2007-10-22 10:52:47 +00:00
|
|
|
}
|
2010-10-25 14:10:11 +00:00
|
|
|
spin_unlock_bh(&mm->context.list_lock);
|
2007-10-22 10:52:47 +00:00
|
|
|
return table;
|
|
|
|
}
|
|
|
|
|
2011-06-06 12:14:41 +00:00
|
|
|
void page_table_free(struct mm_struct *mm, unsigned long *table)
|
2010-10-25 14:10:11 +00:00
|
|
|
{
|
|
|
|
struct page *page;
|
2011-06-06 12:14:41 +00:00
|
|
|
unsigned int bit, mask;
|
2010-10-25 14:10:11 +00:00
|
|
|
|
2013-07-26 13:04:02 +00:00
|
|
|
page = pfn_to_page(__pa(table) >> PAGE_SHIFT);
|
|
|
|
if (page_table_with_pgste(page)) {
|
2013-04-16 11:37:46 +00:00
|
|
|
gmap_disconnect_pgtable(mm, table);
|
2011-06-06 12:14:41 +00:00
|
|
|
return page_table_free_pgste(table);
|
2011-07-24 08:48:20 +00:00
|
|
|
}
|
2011-06-06 12:14:41 +00:00
|
|
|
/* Free 1K/2K page table fragment of a 4K page */
|
|
|
|
bit = 1 << ((__pa(table) & ~PAGE_MASK)/(PTRS_PER_PTE*sizeof(pte_t)));
|
|
|
|
spin_lock_bh(&mm->context.list_lock);
|
|
|
|
if ((atomic_read(&page->_mapcount) & FRAG_MASK) != FRAG_MASK)
|
|
|
|
list_del(&page->lru);
|
|
|
|
mask = atomic_xor_bits(&page->_mapcount, bit);
|
|
|
|
if (mask & FRAG_MASK)
|
|
|
|
list_add(&page->lru, &mm->context.pgtable_list);
|
|
|
|
spin_unlock_bh(&mm->context.list_lock);
|
|
|
|
if (mask == 0) {
|
2010-10-25 14:10:11 +00:00
|
|
|
pgtable_page_dtor(page);
|
2011-06-06 12:14:41 +00:00
|
|
|
atomic_set(&page->_mapcount, -1);
|
2010-10-25 14:10:11 +00:00
|
|
|
__free_page(page);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-06 12:14:41 +00:00
|
|
|
static void __page_table_free_rcu(void *table, unsigned bit)
|
2007-10-22 10:52:47 +00:00
|
|
|
{
|
2008-02-09 17:24:35 +00:00
|
|
|
struct page *page;
|
2007-10-22 10:52:47 +00:00
|
|
|
|
2011-06-06 12:14:41 +00:00
|
|
|
if (bit == FRAG_MASK)
|
|
|
|
return page_table_free_pgste(table);
|
|
|
|
/* Free 1K/2K page table fragment of a 4K page */
|
2008-02-09 17:24:35 +00:00
|
|
|
page = pfn_to_page(__pa(table) >> PAGE_SHIFT);
|
2011-06-06 12:14:41 +00:00
|
|
|
if (atomic_xor_bits(&page->_mapcount, bit) == 0) {
|
2008-02-09 17:24:35 +00:00
|
|
|
pgtable_page_dtor(page);
|
2011-06-06 12:14:41 +00:00
|
|
|
atomic_set(&page->_mapcount, -1);
|
2008-02-09 17:24:35 +00:00
|
|
|
__free_page(page);
|
|
|
|
}
|
|
|
|
}
|
2007-10-22 10:52:47 +00:00
|
|
|
|
2011-06-06 12:14:41 +00:00
|
|
|
void page_table_free_rcu(struct mmu_gather *tlb, unsigned long *table)
|
2010-10-25 14:10:11 +00:00
|
|
|
{
|
2011-06-06 12:14:41 +00:00
|
|
|
struct mm_struct *mm;
|
2010-10-25 14:10:11 +00:00
|
|
|
struct page *page;
|
2011-06-06 12:14:41 +00:00
|
|
|
unsigned int bit, mask;
|
2010-10-25 14:10:11 +00:00
|
|
|
|
2011-06-06 12:14:41 +00:00
|
|
|
mm = tlb->mm;
|
2013-07-26 13:04:02 +00:00
|
|
|
page = pfn_to_page(__pa(table) >> PAGE_SHIFT);
|
|
|
|
if (page_table_with_pgste(page)) {
|
2013-04-16 11:37:46 +00:00
|
|
|
gmap_disconnect_pgtable(mm, table);
|
2011-06-06 12:14:41 +00:00
|
|
|
table = (unsigned long *) (__pa(table) | FRAG_MASK);
|
|
|
|
tlb_remove_table(tlb, table);
|
|
|
|
return;
|
2010-10-25 14:10:11 +00:00
|
|
|
}
|
2011-06-06 12:14:41 +00:00
|
|
|
bit = 1 << ((__pa(table) & ~PAGE_MASK) / (PTRS_PER_PTE*sizeof(pte_t)));
|
2010-10-25 14:10:11 +00:00
|
|
|
spin_lock_bh(&mm->context.list_lock);
|
2011-06-06 12:14:41 +00:00
|
|
|
if ((atomic_read(&page->_mapcount) & FRAG_MASK) != FRAG_MASK)
|
|
|
|
list_del(&page->lru);
|
|
|
|
mask = atomic_xor_bits(&page->_mapcount, bit | (bit << 4));
|
|
|
|
if (mask & FRAG_MASK)
|
|
|
|
list_add_tail(&page->lru, &mm->context.pgtable_list);
|
2010-10-25 14:10:11 +00:00
|
|
|
spin_unlock_bh(&mm->context.list_lock);
|
2011-06-06 12:14:41 +00:00
|
|
|
table = (unsigned long *) (__pa(table) | (bit << 4));
|
|
|
|
tlb_remove_table(tlb, table);
|
|
|
|
}
|
|
|
|
|
2013-09-06 17:10:48 +00:00
|
|
|
static void __tlb_remove_table(void *_table)
|
2011-06-06 12:14:41 +00:00
|
|
|
{
|
2011-10-30 14:16:08 +00:00
|
|
|
const unsigned long mask = (FRAG_MASK << 4) | FRAG_MASK;
|
|
|
|
void *table = (void *)((unsigned long) _table & ~mask);
|
|
|
|
unsigned type = (unsigned long) _table & mask;
|
2011-06-06 12:14:41 +00:00
|
|
|
|
|
|
|
if (type)
|
|
|
|
__page_table_free_rcu(table, type);
|
|
|
|
else
|
|
|
|
free_pages((unsigned long) table, ALLOC_ORDER);
|
2010-10-25 14:10:11 +00:00
|
|
|
}
|
|
|
|
|
2012-04-11 12:28:07 +00:00
|
|
|
static void tlb_remove_table_smp_sync(void *arg)
|
|
|
|
{
|
|
|
|
/* Simply deliver the interrupt */
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tlb_remove_table_one(void *table)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* This isn't an RCU grace period and hence the page-tables cannot be
|
|
|
|
* assumed to be actually RCU-freed.
|
|
|
|
*
|
|
|
|
* It is however sufficient for software page-table walkers that rely
|
|
|
|
* on IRQ disabling. See the comment near struct mmu_table_batch.
|
|
|
|
*/
|
|
|
|
smp_call_function(tlb_remove_table_smp_sync, NULL, 1);
|
|
|
|
__tlb_remove_table(table);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tlb_remove_table_rcu(struct rcu_head *head)
|
|
|
|
{
|
|
|
|
struct mmu_table_batch *batch;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
batch = container_of(head, struct mmu_table_batch, rcu);
|
|
|
|
|
|
|
|
for (i = 0; i < batch->nr; i++)
|
|
|
|
__tlb_remove_table(batch->tables[i]);
|
|
|
|
|
|
|
|
free_page((unsigned long)batch);
|
|
|
|
}
|
|
|
|
|
|
|
|
void tlb_table_flush(struct mmu_gather *tlb)
|
|
|
|
{
|
|
|
|
struct mmu_table_batch **batch = &tlb->batch;
|
|
|
|
|
|
|
|
if (*batch) {
|
|
|
|
call_rcu_sched(&(*batch)->rcu, tlb_remove_table_rcu);
|
|
|
|
*batch = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void tlb_remove_table(struct mmu_gather *tlb, void *table)
|
|
|
|
{
|
|
|
|
struct mmu_table_batch **batch = &tlb->batch;
|
|
|
|
|
2013-08-16 11:31:40 +00:00
|
|
|
tlb->mm->context.flush_mm = 1;
|
2012-04-11 12:28:07 +00:00
|
|
|
if (*batch == NULL) {
|
|
|
|
*batch = (struct mmu_table_batch *)
|
|
|
|
__get_free_page(GFP_NOWAIT | __GFP_NOWARN);
|
|
|
|
if (*batch == NULL) {
|
2013-08-16 11:31:40 +00:00
|
|
|
__tlb_flush_mm_lazy(tlb->mm);
|
2012-04-11 12:28:07 +00:00
|
|
|
tlb_remove_table_one(table);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
(*batch)->nr = 0;
|
|
|
|
}
|
|
|
|
(*batch)->tables[(*batch)->nr++] = table;
|
|
|
|
if ((*batch)->nr == MAX_TABLE_BATCH)
|
2013-08-16 11:31:40 +00:00
|
|
|
tlb_flush_mmu(tlb);
|
2012-04-11 12:28:07 +00:00
|
|
|
}
|
2011-06-06 12:14:41 +00:00
|
|
|
|
2012-10-08 23:30:21 +00:00
|
|
|
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
|
2013-07-26 13:04:02 +00:00
|
|
|
static inline void thp_split_vma(struct vm_area_struct *vma)
|
2012-10-08 23:30:21 +00:00
|
|
|
{
|
|
|
|
unsigned long addr;
|
|
|
|
|
2013-07-26 13:04:02 +00:00
|
|
|
for (addr = vma->vm_start; addr < vma->vm_end; addr += PAGE_SIZE)
|
|
|
|
follow_page(vma, addr, FOLL_SPLIT);
|
2012-10-08 23:30:21 +00:00
|
|
|
}
|
|
|
|
|
2013-07-26 13:04:02 +00:00
|
|
|
static inline void thp_split_mm(struct mm_struct *mm)
|
2012-10-08 23:30:21 +00:00
|
|
|
{
|
2013-07-26 13:04:02 +00:00
|
|
|
struct vm_area_struct *vma;
|
2012-10-08 23:30:21 +00:00
|
|
|
|
2013-07-26 13:04:02 +00:00
|
|
|
for (vma = mm->mmap; vma != NULL; vma = vma->vm_next) {
|
2012-10-08 23:30:21 +00:00
|
|
|
thp_split_vma(vma);
|
|
|
|
vma->vm_flags &= ~VM_HUGEPAGE;
|
|
|
|
vma->vm_flags |= VM_NOHUGEPAGE;
|
|
|
|
}
|
2013-07-26 13:04:02 +00:00
|
|
|
mm->def_flags |= VM_NOHUGEPAGE;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void thp_split_mm(struct mm_struct *mm)
|
|
|
|
{
|
2012-10-08 23:30:21 +00:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_TRANSPARENT_HUGEPAGE */
|
|
|
|
|
2013-07-26 13:04:02 +00:00
|
|
|
static unsigned long page_table_realloc_pmd(struct mmu_gather *tlb,
|
|
|
|
struct mm_struct *mm, pud_t *pud,
|
|
|
|
unsigned long addr, unsigned long end)
|
|
|
|
{
|
|
|
|
unsigned long next, *table, *new;
|
|
|
|
struct page *page;
|
|
|
|
pmd_t *pmd;
|
|
|
|
|
|
|
|
pmd = pmd_offset(pud, addr);
|
|
|
|
do {
|
|
|
|
next = pmd_addr_end(addr, end);
|
|
|
|
again:
|
|
|
|
if (pmd_none_or_clear_bad(pmd))
|
|
|
|
continue;
|
|
|
|
table = (unsigned long *) pmd_deref(*pmd);
|
|
|
|
page = pfn_to_page(__pa(table) >> PAGE_SHIFT);
|
|
|
|
if (page_table_with_pgste(page))
|
|
|
|
continue;
|
|
|
|
/* Allocate new page table with pgstes */
|
|
|
|
new = page_table_alloc_pgste(mm, addr);
|
2013-10-31 09:01:16 +00:00
|
|
|
if (!new)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2013-07-26 13:04:02 +00:00
|
|
|
spin_lock(&mm->page_table_lock);
|
|
|
|
if (likely((unsigned long *) pmd_deref(*pmd) == table)) {
|
|
|
|
/* Nuke pmd entry pointing to the "short" page table */
|
|
|
|
pmdp_flush_lazy(mm, addr, pmd);
|
|
|
|
pmd_clear(pmd);
|
|
|
|
/* Copy ptes from old table to new table */
|
|
|
|
memcpy(new, table, PAGE_SIZE/2);
|
|
|
|
clear_table(table, _PAGE_INVALID, PAGE_SIZE/2);
|
|
|
|
/* Establish new table */
|
|
|
|
pmd_populate(mm, pmd, (pte_t *) new);
|
|
|
|
/* Free old table with rcu, there might be a walker! */
|
|
|
|
page_table_free_rcu(tlb, table);
|
|
|
|
new = NULL;
|
|
|
|
}
|
|
|
|
spin_unlock(&mm->page_table_lock);
|
|
|
|
if (new) {
|
|
|
|
page_table_free_pgste(new);
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
} while (pmd++, addr = next, addr != end);
|
|
|
|
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned long page_table_realloc_pud(struct mmu_gather *tlb,
|
|
|
|
struct mm_struct *mm, pgd_t *pgd,
|
|
|
|
unsigned long addr, unsigned long end)
|
|
|
|
{
|
|
|
|
unsigned long next;
|
|
|
|
pud_t *pud;
|
|
|
|
|
|
|
|
pud = pud_offset(pgd, addr);
|
|
|
|
do {
|
|
|
|
next = pud_addr_end(addr, end);
|
|
|
|
if (pud_none_or_clear_bad(pud))
|
|
|
|
continue;
|
|
|
|
next = page_table_realloc_pmd(tlb, mm, pud, addr, next);
|
2013-10-31 09:01:16 +00:00
|
|
|
if (unlikely(IS_ERR_VALUE(next)))
|
|
|
|
return next;
|
2013-07-26 13:04:02 +00:00
|
|
|
} while (pud++, addr = next, addr != end);
|
|
|
|
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
2013-10-31 09:01:16 +00:00
|
|
|
static unsigned long page_table_realloc(struct mmu_gather *tlb, struct mm_struct *mm,
|
|
|
|
unsigned long addr, unsigned long end)
|
2013-07-26 13:04:02 +00:00
|
|
|
{
|
|
|
|
unsigned long next;
|
|
|
|
pgd_t *pgd;
|
|
|
|
|
|
|
|
pgd = pgd_offset(mm, addr);
|
|
|
|
do {
|
|
|
|
next = pgd_addr_end(addr, end);
|
|
|
|
if (pgd_none_or_clear_bad(pgd))
|
|
|
|
continue;
|
|
|
|
next = page_table_realloc_pud(tlb, mm, pgd, addr, next);
|
2013-10-31 09:01:16 +00:00
|
|
|
if (unlikely(IS_ERR_VALUE(next)))
|
|
|
|
return next;
|
2013-07-26 13:04:02 +00:00
|
|
|
} while (pgd++, addr = next, addr != end);
|
2013-10-31 09:01:16 +00:00
|
|
|
|
|
|
|
return 0;
|
2013-07-26 13:04:02 +00:00
|
|
|
}
|
|
|
|
|
2008-03-25 17:47:10 +00:00
|
|
|
/*
|
|
|
|
* switch on pgstes for its userspace process (for kvm)
|
|
|
|
*/
|
|
|
|
int s390_enable_sie(void)
|
|
|
|
{
|
|
|
|
struct task_struct *tsk = current;
|
2013-07-26 13:04:02 +00:00
|
|
|
struct mm_struct *mm = tsk->mm;
|
|
|
|
struct mmu_gather tlb;
|
2008-03-25 17:47:10 +00:00
|
|
|
|
2008-05-21 11:37:29 +00:00
|
|
|
/* Do we have pgstes? if yes, we are done */
|
2011-06-06 12:14:41 +00:00
|
|
|
if (mm_has_pgste(tsk->mm))
|
2008-05-21 11:37:29 +00:00
|
|
|
return 0;
|
2008-03-25 17:47:10 +00:00
|
|
|
|
2013-07-26 13:04:02 +00:00
|
|
|
down_write(&mm->mmap_sem);
|
2012-10-08 23:30:21 +00:00
|
|
|
/* split thp mappings and disable thp for future mappings */
|
|
|
|
thp_split_mm(mm);
|
2013-07-26 13:04:02 +00:00
|
|
|
/* Reallocate the page tables with pgstes */
|
2013-09-05 01:15:06 +00:00
|
|
|
tlb_gather_mmu(&tlb, mm, 0, TASK_SIZE);
|
2013-10-31 09:01:16 +00:00
|
|
|
if (!page_table_realloc(&tlb, mm, 0, TASK_SIZE))
|
|
|
|
mm->context.has_pgste = 1;
|
2013-09-05 01:15:06 +00:00
|
|
|
tlb_finish_mmu(&tlb, 0, TASK_SIZE);
|
2013-07-26 13:04:02 +00:00
|
|
|
up_write(&mm->mmap_sem);
|
|
|
|
return mm->context.has_pgste ? 0 : -ENOMEM;
|
2008-03-25 17:47:10 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(s390_enable_sie);
|
2009-06-16 08:30:26 +00:00
|
|
|
|
2012-10-08 23:30:15 +00:00
|
|
|
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
|
2012-10-08 23:30:24 +00:00
|
|
|
int pmdp_clear_flush_young(struct vm_area_struct *vma, unsigned long address,
|
|
|
|
pmd_t *pmdp)
|
|
|
|
{
|
|
|
|
VM_BUG_ON(address & ~HPAGE_PMD_MASK);
|
|
|
|
/* No need to flush TLB
|
|
|
|
* On s390 reference bits are in storage key and never in TLB */
|
|
|
|
return pmdp_test_and_clear_young(vma, address, pmdp);
|
|
|
|
}
|
|
|
|
|
|
|
|
int pmdp_set_access_flags(struct vm_area_struct *vma,
|
|
|
|
unsigned long address, pmd_t *pmdp,
|
|
|
|
pmd_t entry, int dirty)
|
|
|
|
{
|
|
|
|
VM_BUG_ON(address & ~HPAGE_PMD_MASK);
|
|
|
|
|
|
|
|
if (pmd_same(*pmdp, entry))
|
|
|
|
return 0;
|
|
|
|
pmdp_invalidate(vma, address, pmdp);
|
|
|
|
set_pmd_at(vma->vm_mm, address, pmdp, entry);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2012-10-08 23:30:15 +00:00
|
|
|
static void pmdp_splitting_flush_sync(void *arg)
|
|
|
|
{
|
|
|
|
/* Simply deliver the interrupt */
|
|
|
|
}
|
|
|
|
|
|
|
|
void pmdp_splitting_flush(struct vm_area_struct *vma, unsigned long address,
|
|
|
|
pmd_t *pmdp)
|
|
|
|
{
|
|
|
|
VM_BUG_ON(address & ~HPAGE_PMD_MASK);
|
|
|
|
if (!test_and_set_bit(_SEGMENT_ENTRY_SPLIT_BIT,
|
|
|
|
(unsigned long *) pmdp)) {
|
|
|
|
/* need to serialize against gup-fast (IRQ disabled) */
|
|
|
|
smp_call_function(pmdp_splitting_flush_sync, NULL, 1);
|
|
|
|
}
|
|
|
|
}
|
2012-10-08 23:30:18 +00:00
|
|
|
|
2013-06-06 00:14:02 +00:00
|
|
|
void pgtable_trans_huge_deposit(struct mm_struct *mm, pmd_t *pmdp,
|
|
|
|
pgtable_t pgtable)
|
2012-10-08 23:30:18 +00:00
|
|
|
{
|
|
|
|
struct list_head *lh = (struct list_head *) pgtable;
|
|
|
|
|
|
|
|
assert_spin_locked(&mm->page_table_lock);
|
|
|
|
|
|
|
|
/* FIFO */
|
2013-11-14 22:30:59 +00:00
|
|
|
if (!pmd_huge_pte(mm, pmdp))
|
2012-10-08 23:30:18 +00:00
|
|
|
INIT_LIST_HEAD(lh);
|
|
|
|
else
|
2013-11-14 22:30:59 +00:00
|
|
|
list_add(lh, (struct list_head *) pmd_huge_pte(mm, pmdp));
|
|
|
|
pmd_huge_pte(mm, pmdp) = pgtable;
|
2012-10-08 23:30:18 +00:00
|
|
|
}
|
|
|
|
|
2013-06-06 00:14:02 +00:00
|
|
|
pgtable_t pgtable_trans_huge_withdraw(struct mm_struct *mm, pmd_t *pmdp)
|
2012-10-08 23:30:18 +00:00
|
|
|
{
|
|
|
|
struct list_head *lh;
|
|
|
|
pgtable_t pgtable;
|
|
|
|
pte_t *ptep;
|
|
|
|
|
|
|
|
assert_spin_locked(&mm->page_table_lock);
|
|
|
|
|
|
|
|
/* FIFO */
|
2013-11-14 22:30:59 +00:00
|
|
|
pgtable = pmd_huge_pte(mm, pmdp);
|
2012-10-08 23:30:18 +00:00
|
|
|
lh = (struct list_head *) pgtable;
|
|
|
|
if (list_empty(lh))
|
2013-11-14 22:30:59 +00:00
|
|
|
pmd_huge_pte(mm, pmdp) = NULL;
|
2012-10-08 23:30:18 +00:00
|
|
|
else {
|
2013-11-14 22:30:59 +00:00
|
|
|
pmd_huge_pte(mm, pmdp) = (pgtable_t) lh->next;
|
2012-10-08 23:30:18 +00:00
|
|
|
list_del(lh);
|
|
|
|
}
|
|
|
|
ptep = (pte_t *) pgtable;
|
2013-07-23 18:57:57 +00:00
|
|
|
pte_val(*ptep) = _PAGE_INVALID;
|
2012-10-08 23:30:18 +00:00
|
|
|
ptep++;
|
2013-07-23 18:57:57 +00:00
|
|
|
pte_val(*ptep) = _PAGE_INVALID;
|
2012-10-08 23:30:18 +00:00
|
|
|
return pgtable;
|
|
|
|
}
|
2012-10-08 23:30:15 +00:00
|
|
|
#endif /* CONFIG_TRANSPARENT_HUGEPAGE */
|