2019-06-04 02:11:33 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2009-01-03 15:23:10 -07:00
|
|
|
/*
|
2011-06-14 17:34:31 -06:00
|
|
|
* Copyright (C) 2008-2011 Freescale Semiconductor, Inc. All rights reserved.
|
2009-01-03 15:23:10 -07:00
|
|
|
*
|
|
|
|
|
* Author: Yu Liu, <yu.liu@freescale.com>
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* This file is derived from arch/powerpc/kvm/44x.c,
|
|
|
|
|
* by Hollis Blanchard <hollisb@us.ibm.com>.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <linux/kvm_host.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 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2009-01-03 15:23:10 -07:00
|
|
|
#include <linux/err.h>
|
2011-12-20 07:43:45 -07:00
|
|
|
#include <linux/export.h>
|
2013-12-09 05:53:42 -07:00
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/miscdevice.h>
|
2009-01-03 15:23:10 -07:00
|
|
|
|
|
|
|
|
#include <asm/reg.h>
|
|
|
|
|
#include <asm/cputable.h>
|
|
|
|
|
#include <asm/kvm_ppc.h>
|
|
|
|
|
|
2011-12-20 08:34:34 -07:00
|
|
|
#include "../mm/mmu_decl.h"
|
2009-01-03 15:23:13 -07:00
|
|
|
#include "booke.h"
|
2011-12-20 08:34:29 -07:00
|
|
|
#include "e500.h"
|
2009-01-03 15:23:10 -07:00
|
|
|
|
2011-12-20 08:34:34 -07:00
|
|
|
struct id {
|
|
|
|
|
unsigned long val;
|
|
|
|
|
struct id **pentry;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define NUM_TIDS 256
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This table provide mappings from:
|
|
|
|
|
* (guestAS,guestTID,guestPR) --> ID of physical cpu
|
|
|
|
|
* guestAS [0..1]
|
|
|
|
|
* guestTID [0..255]
|
|
|
|
|
* guestPR [0..1]
|
|
|
|
|
* ID [1..255]
|
|
|
|
|
* Each vcpu keeps one vcpu_id_table.
|
|
|
|
|
*/
|
|
|
|
|
struct vcpu_id_table {
|
|
|
|
|
struct id id[2][NUM_TIDS][2];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This table provide reversed mappings of vcpu_id_table:
|
|
|
|
|
* ID --> address of vcpu_id_table item.
|
|
|
|
|
* Each physical core has one pcpu_id_table.
|
|
|
|
|
*/
|
|
|
|
|
struct pcpu_id_table {
|
|
|
|
|
struct id *entry[NUM_TIDS];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static DEFINE_PER_CPU(struct pcpu_id_table, pcpu_sids);
|
|
|
|
|
|
|
|
|
|
/* This variable keeps last used shadow ID on local core.
|
|
|
|
|
* The valid range of shadow ID is [1..255] */
|
|
|
|
|
static DEFINE_PER_CPU(unsigned long, pcpu_last_used_sid);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Allocate a free shadow id and setup a valid sid mapping in given entry.
|
|
|
|
|
* A mapping is only valid when vcpu_id_table and pcpu_id_table are match.
|
|
|
|
|
*
|
|
|
|
|
* The caller must have preemption disabled, and keep it that way until
|
|
|
|
|
* it has finished with the returned shadow id (either written into the
|
|
|
|
|
* TLB or arch.shadow_pid, or discarded).
|
|
|
|
|
*/
|
|
|
|
|
static inline int local_sid_setup_one(struct id *entry)
|
|
|
|
|
{
|
|
|
|
|
unsigned long sid;
|
|
|
|
|
int ret = -1;
|
|
|
|
|
|
powerpc: Replace __get_cpu_var uses
This still has not been merged and now powerpc is the only arch that does
not have this change. Sorry about missing linuxppc-dev before.
V2->V2
- Fix up to work against 3.18-rc1
__get_cpu_var() is used for multiple purposes in the kernel source. One of
them is address calculation via the form &__get_cpu_var(x). This calculates
the address for the instance of the percpu variable of the current processor
based on an offset.
Other use cases are for storing and retrieving data from the current
processors percpu area. __get_cpu_var() can be used as an lvalue when
writing data or on the right side of an assignment.
__get_cpu_var() is defined as :
__get_cpu_var() always only does an address determination. However, store
and retrieve operations could use a segment prefix (or global register on
other platforms) to avoid the address calculation.
this_cpu_write() and this_cpu_read() can directly take an offset into a
percpu area and use optimized assembly code to read and write per cpu
variables.
This patch converts __get_cpu_var into either an explicit address
calculation using this_cpu_ptr() or into a use of this_cpu operations that
use the offset. Thereby address calculations are avoided and less registers
are used when code is generated.
At the end of the patch set all uses of __get_cpu_var have been removed so
the macro is removed too.
The patch set includes passes over all arches as well. Once these operations
are used throughout then specialized macros can be defined in non -x86
arches as well in order to optimize per cpu access by f.e. using a global
register that may be set to the per cpu base.
Transformations done to __get_cpu_var()
1. Determine the address of the percpu instance of the current processor.
DEFINE_PER_CPU(int, y);
int *x = &__get_cpu_var(y);
Converts to
int *x = this_cpu_ptr(&y);
2. Same as #1 but this time an array structure is involved.
DEFINE_PER_CPU(int, y[20]);
int *x = __get_cpu_var(y);
Converts to
int *x = this_cpu_ptr(y);
3. Retrieve the content of the current processors instance of a per cpu
variable.
DEFINE_PER_CPU(int, y);
int x = __get_cpu_var(y)
Converts to
int x = __this_cpu_read(y);
4. Retrieve the content of a percpu struct
DEFINE_PER_CPU(struct mystruct, y);
struct mystruct x = __get_cpu_var(y);
Converts to
memcpy(&x, this_cpu_ptr(&y), sizeof(x));
5. Assignment to a per cpu variable
DEFINE_PER_CPU(int, y)
__get_cpu_var(y) = x;
Converts to
__this_cpu_write(y, x);
6. Increment/Decrement etc of a per cpu variable
DEFINE_PER_CPU(int, y);
__get_cpu_var(y)++
Converts to
__this_cpu_inc(y)
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
CC: Paul Mackerras <paulus@samba.org>
Signed-off-by: Christoph Lameter <cl@linux.com>
[mpe: Fix build errors caused by set/or_softirq_pending(), and rework
assignment in __set_breakpoint() to use memcpy().]
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2014-10-21 14:23:25 -06:00
|
|
|
sid = __this_cpu_inc_return(pcpu_last_used_sid);
|
2011-12-20 08:34:34 -07:00
|
|
|
if (sid < NUM_TIDS) {
|
2014-12-18 02:17:08 -07:00
|
|
|
__this_cpu_write(pcpu_sids.entry[sid], entry);
|
2011-12-20 08:34:34 -07:00
|
|
|
entry->val = sid;
|
powerpc: Replace __get_cpu_var uses
This still has not been merged and now powerpc is the only arch that does
not have this change. Sorry about missing linuxppc-dev before.
V2->V2
- Fix up to work against 3.18-rc1
__get_cpu_var() is used for multiple purposes in the kernel source. One of
them is address calculation via the form &__get_cpu_var(x). This calculates
the address for the instance of the percpu variable of the current processor
based on an offset.
Other use cases are for storing and retrieving data from the current
processors percpu area. __get_cpu_var() can be used as an lvalue when
writing data or on the right side of an assignment.
__get_cpu_var() is defined as :
__get_cpu_var() always only does an address determination. However, store
and retrieve operations could use a segment prefix (or global register on
other platforms) to avoid the address calculation.
this_cpu_write() and this_cpu_read() can directly take an offset into a
percpu area and use optimized assembly code to read and write per cpu
variables.
This patch converts __get_cpu_var into either an explicit address
calculation using this_cpu_ptr() or into a use of this_cpu operations that
use the offset. Thereby address calculations are avoided and less registers
are used when code is generated.
At the end of the patch set all uses of __get_cpu_var have been removed so
the macro is removed too.
The patch set includes passes over all arches as well. Once these operations
are used throughout then specialized macros can be defined in non -x86
arches as well in order to optimize per cpu access by f.e. using a global
register that may be set to the per cpu base.
Transformations done to __get_cpu_var()
1. Determine the address of the percpu instance of the current processor.
DEFINE_PER_CPU(int, y);
int *x = &__get_cpu_var(y);
Converts to
int *x = this_cpu_ptr(&y);
2. Same as #1 but this time an array structure is involved.
DEFINE_PER_CPU(int, y[20]);
int *x = __get_cpu_var(y);
Converts to
int *x = this_cpu_ptr(y);
3. Retrieve the content of the current processors instance of a per cpu
variable.
DEFINE_PER_CPU(int, y);
int x = __get_cpu_var(y)
Converts to
int x = __this_cpu_read(y);
4. Retrieve the content of a percpu struct
DEFINE_PER_CPU(struct mystruct, y);
struct mystruct x = __get_cpu_var(y);
Converts to
memcpy(&x, this_cpu_ptr(&y), sizeof(x));
5. Assignment to a per cpu variable
DEFINE_PER_CPU(int, y)
__get_cpu_var(y) = x;
Converts to
__this_cpu_write(y, x);
6. Increment/Decrement etc of a per cpu variable
DEFINE_PER_CPU(int, y);
__get_cpu_var(y)++
Converts to
__this_cpu_inc(y)
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
CC: Paul Mackerras <paulus@samba.org>
Signed-off-by: Christoph Lameter <cl@linux.com>
[mpe: Fix build errors caused by set/or_softirq_pending(), and rework
assignment in __set_breakpoint() to use memcpy().]
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2014-10-21 14:23:25 -06:00
|
|
|
entry->pentry = this_cpu_ptr(&pcpu_sids.entry[sid]);
|
2011-12-20 08:34:34 -07:00
|
|
|
ret = sid;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If sid == NUM_TIDS, we've run out of sids. We return -1, and
|
|
|
|
|
* the caller will invalidate everything and start over.
|
|
|
|
|
*
|
|
|
|
|
* sid > NUM_TIDS indicates a race, which we disable preemption to
|
|
|
|
|
* avoid.
|
|
|
|
|
*/
|
|
|
|
|
WARN_ON(sid > NUM_TIDS);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Check if given entry contain a valid shadow id mapping.
|
|
|
|
|
* An ID mapping is considered valid only if
|
|
|
|
|
* both vcpu and pcpu know this mapping.
|
|
|
|
|
*
|
|
|
|
|
* The caller must have preemption disabled, and keep it that way until
|
|
|
|
|
* it has finished with the returned shadow id (either written into the
|
|
|
|
|
* TLB or arch.shadow_pid, or discarded).
|
|
|
|
|
*/
|
|
|
|
|
static inline int local_sid_lookup(struct id *entry)
|
|
|
|
|
{
|
|
|
|
|
if (entry && entry->val != 0 &&
|
powerpc: Replace __get_cpu_var uses
This still has not been merged and now powerpc is the only arch that does
not have this change. Sorry about missing linuxppc-dev before.
V2->V2
- Fix up to work against 3.18-rc1
__get_cpu_var() is used for multiple purposes in the kernel source. One of
them is address calculation via the form &__get_cpu_var(x). This calculates
the address for the instance of the percpu variable of the current processor
based on an offset.
Other use cases are for storing and retrieving data from the current
processors percpu area. __get_cpu_var() can be used as an lvalue when
writing data or on the right side of an assignment.
__get_cpu_var() is defined as :
__get_cpu_var() always only does an address determination. However, store
and retrieve operations could use a segment prefix (or global register on
other platforms) to avoid the address calculation.
this_cpu_write() and this_cpu_read() can directly take an offset into a
percpu area and use optimized assembly code to read and write per cpu
variables.
This patch converts __get_cpu_var into either an explicit address
calculation using this_cpu_ptr() or into a use of this_cpu operations that
use the offset. Thereby address calculations are avoided and less registers
are used when code is generated.
At the end of the patch set all uses of __get_cpu_var have been removed so
the macro is removed too.
The patch set includes passes over all arches as well. Once these operations
are used throughout then specialized macros can be defined in non -x86
arches as well in order to optimize per cpu access by f.e. using a global
register that may be set to the per cpu base.
Transformations done to __get_cpu_var()
1. Determine the address of the percpu instance of the current processor.
DEFINE_PER_CPU(int, y);
int *x = &__get_cpu_var(y);
Converts to
int *x = this_cpu_ptr(&y);
2. Same as #1 but this time an array structure is involved.
DEFINE_PER_CPU(int, y[20]);
int *x = __get_cpu_var(y);
Converts to
int *x = this_cpu_ptr(y);
3. Retrieve the content of the current processors instance of a per cpu
variable.
DEFINE_PER_CPU(int, y);
int x = __get_cpu_var(y)
Converts to
int x = __this_cpu_read(y);
4. Retrieve the content of a percpu struct
DEFINE_PER_CPU(struct mystruct, y);
struct mystruct x = __get_cpu_var(y);
Converts to
memcpy(&x, this_cpu_ptr(&y), sizeof(x));
5. Assignment to a per cpu variable
DEFINE_PER_CPU(int, y)
__get_cpu_var(y) = x;
Converts to
__this_cpu_write(y, x);
6. Increment/Decrement etc of a per cpu variable
DEFINE_PER_CPU(int, y);
__get_cpu_var(y)++
Converts to
__this_cpu_inc(y)
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
CC: Paul Mackerras <paulus@samba.org>
Signed-off-by: Christoph Lameter <cl@linux.com>
[mpe: Fix build errors caused by set/or_softirq_pending(), and rework
assignment in __set_breakpoint() to use memcpy().]
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2014-10-21 14:23:25 -06:00
|
|
|
__this_cpu_read(pcpu_sids.entry[entry->val]) == entry &&
|
|
|
|
|
entry->pentry == this_cpu_ptr(&pcpu_sids.entry[entry->val]))
|
2011-12-20 08:34:34 -07:00
|
|
|
return entry->val;
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Invalidate all id mappings on local core -- call with preempt disabled */
|
|
|
|
|
static inline void local_sid_destroy_all(void)
|
|
|
|
|
{
|
powerpc: Replace __get_cpu_var uses
This still has not been merged and now powerpc is the only arch that does
not have this change. Sorry about missing linuxppc-dev before.
V2->V2
- Fix up to work against 3.18-rc1
__get_cpu_var() is used for multiple purposes in the kernel source. One of
them is address calculation via the form &__get_cpu_var(x). This calculates
the address for the instance of the percpu variable of the current processor
based on an offset.
Other use cases are for storing and retrieving data from the current
processors percpu area. __get_cpu_var() can be used as an lvalue when
writing data or on the right side of an assignment.
__get_cpu_var() is defined as :
__get_cpu_var() always only does an address determination. However, store
and retrieve operations could use a segment prefix (or global register on
other platforms) to avoid the address calculation.
this_cpu_write() and this_cpu_read() can directly take an offset into a
percpu area and use optimized assembly code to read and write per cpu
variables.
This patch converts __get_cpu_var into either an explicit address
calculation using this_cpu_ptr() or into a use of this_cpu operations that
use the offset. Thereby address calculations are avoided and less registers
are used when code is generated.
At the end of the patch set all uses of __get_cpu_var have been removed so
the macro is removed too.
The patch set includes passes over all arches as well. Once these operations
are used throughout then specialized macros can be defined in non -x86
arches as well in order to optimize per cpu access by f.e. using a global
register that may be set to the per cpu base.
Transformations done to __get_cpu_var()
1. Determine the address of the percpu instance of the current processor.
DEFINE_PER_CPU(int, y);
int *x = &__get_cpu_var(y);
Converts to
int *x = this_cpu_ptr(&y);
2. Same as #1 but this time an array structure is involved.
DEFINE_PER_CPU(int, y[20]);
int *x = __get_cpu_var(y);
Converts to
int *x = this_cpu_ptr(y);
3. Retrieve the content of the current processors instance of a per cpu
variable.
DEFINE_PER_CPU(int, y);
int x = __get_cpu_var(y)
Converts to
int x = __this_cpu_read(y);
4. Retrieve the content of a percpu struct
DEFINE_PER_CPU(struct mystruct, y);
struct mystruct x = __get_cpu_var(y);
Converts to
memcpy(&x, this_cpu_ptr(&y), sizeof(x));
5. Assignment to a per cpu variable
DEFINE_PER_CPU(int, y)
__get_cpu_var(y) = x;
Converts to
__this_cpu_write(y, x);
6. Increment/Decrement etc of a per cpu variable
DEFINE_PER_CPU(int, y);
__get_cpu_var(y)++
Converts to
__this_cpu_inc(y)
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
CC: Paul Mackerras <paulus@samba.org>
Signed-off-by: Christoph Lameter <cl@linux.com>
[mpe: Fix build errors caused by set/or_softirq_pending(), and rework
assignment in __set_breakpoint() to use memcpy().]
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2014-10-21 14:23:25 -06:00
|
|
|
__this_cpu_write(pcpu_last_used_sid, 0);
|
|
|
|
|
memset(this_cpu_ptr(&pcpu_sids), 0, sizeof(pcpu_sids));
|
2011-12-20 08:34:34 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void *kvmppc_e500_id_table_alloc(struct kvmppc_vcpu_e500 *vcpu_e500)
|
|
|
|
|
{
|
|
|
|
|
vcpu_e500->idt = kzalloc(sizeof(struct vcpu_id_table), GFP_KERNEL);
|
|
|
|
|
return vcpu_e500->idt;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void kvmppc_e500_id_table_free(struct kvmppc_vcpu_e500 *vcpu_e500)
|
|
|
|
|
{
|
|
|
|
|
kfree(vcpu_e500->idt);
|
|
|
|
|
vcpu_e500->idt = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Map guest pid to shadow.
|
|
|
|
|
* We use PID to keep shadow of current guest non-zero PID,
|
|
|
|
|
* and use PID1 to keep shadow of guest zero PID.
|
|
|
|
|
* So that guest tlbe with TID=0 can be accessed at any time */
|
|
|
|
|
static void kvmppc_e500_recalc_shadow_pid(struct kvmppc_vcpu_e500 *vcpu_e500)
|
|
|
|
|
{
|
|
|
|
|
preempt_disable();
|
|
|
|
|
vcpu_e500->vcpu.arch.shadow_pid = kvmppc_e500_get_sid(vcpu_e500,
|
|
|
|
|
get_cur_as(&vcpu_e500->vcpu),
|
|
|
|
|
get_cur_pid(&vcpu_e500->vcpu),
|
|
|
|
|
get_cur_pr(&vcpu_e500->vcpu), 1);
|
|
|
|
|
vcpu_e500->vcpu.arch.shadow_pid1 = kvmppc_e500_get_sid(vcpu_e500,
|
|
|
|
|
get_cur_as(&vcpu_e500->vcpu), 0,
|
|
|
|
|
get_cur_pr(&vcpu_e500->vcpu), 1);
|
|
|
|
|
preempt_enable();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Invalidate all mappings on vcpu */
|
|
|
|
|
static void kvmppc_e500_id_table_reset_all(struct kvmppc_vcpu_e500 *vcpu_e500)
|
|
|
|
|
{
|
|
|
|
|
memset(vcpu_e500->idt, 0, sizeof(struct vcpu_id_table));
|
|
|
|
|
|
|
|
|
|
/* Update shadow pid when mappings are changed */
|
|
|
|
|
kvmppc_e500_recalc_shadow_pid(vcpu_e500);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Invalidate one ID mapping on vcpu */
|
|
|
|
|
static inline void kvmppc_e500_id_table_reset_one(
|
|
|
|
|
struct kvmppc_vcpu_e500 *vcpu_e500,
|
|
|
|
|
int as, int pid, int pr)
|
|
|
|
|
{
|
|
|
|
|
struct vcpu_id_table *idt = vcpu_e500->idt;
|
|
|
|
|
|
|
|
|
|
BUG_ON(as >= 2);
|
|
|
|
|
BUG_ON(pid >= NUM_TIDS);
|
|
|
|
|
BUG_ON(pr >= 2);
|
|
|
|
|
|
|
|
|
|
idt->id[as][pid][pr].val = 0;
|
|
|
|
|
idt->id[as][pid][pr].pentry = NULL;
|
|
|
|
|
|
|
|
|
|
/* Update shadow pid when mappings are changed */
|
|
|
|
|
kvmppc_e500_recalc_shadow_pid(vcpu_e500);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Map guest (vcpu,AS,ID,PR) to physical core shadow id.
|
|
|
|
|
* This function first lookup if a valid mapping exists,
|
|
|
|
|
* if not, then creates a new one.
|
|
|
|
|
*
|
|
|
|
|
* The caller must have preemption disabled, and keep it that way until
|
|
|
|
|
* it has finished with the returned shadow id (either written into the
|
|
|
|
|
* TLB or arch.shadow_pid, or discarded).
|
|
|
|
|
*/
|
|
|
|
|
unsigned int kvmppc_e500_get_sid(struct kvmppc_vcpu_e500 *vcpu_e500,
|
|
|
|
|
unsigned int as, unsigned int gid,
|
|
|
|
|
unsigned int pr, int avoid_recursion)
|
|
|
|
|
{
|
|
|
|
|
struct vcpu_id_table *idt = vcpu_e500->idt;
|
|
|
|
|
int sid;
|
|
|
|
|
|
|
|
|
|
BUG_ON(as >= 2);
|
|
|
|
|
BUG_ON(gid >= NUM_TIDS);
|
|
|
|
|
BUG_ON(pr >= 2);
|
|
|
|
|
|
|
|
|
|
sid = local_sid_lookup(&idt->id[as][gid][pr]);
|
|
|
|
|
|
|
|
|
|
while (sid <= 0) {
|
|
|
|
|
/* No mapping yet */
|
|
|
|
|
sid = local_sid_setup_one(&idt->id[as][gid][pr]);
|
|
|
|
|
if (sid <= 0) {
|
|
|
|
|
_tlbil_all();
|
|
|
|
|
local_sid_destroy_all();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Update shadow pid when mappings are changed */
|
|
|
|
|
if (!avoid_recursion)
|
|
|
|
|
kvmppc_e500_recalc_shadow_pid(vcpu_e500);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return sid;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
unsigned int kvmppc_e500_get_tlb_stid(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_book3e_206_tlb_entry *gtlbe)
|
|
|
|
|
{
|
|
|
|
|
return kvmppc_e500_get_sid(to_e500(vcpu), get_tlb_ts(gtlbe),
|
|
|
|
|
get_tlb_tid(gtlbe), get_cur_pr(vcpu), 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void kvmppc_set_pid(struct kvm_vcpu *vcpu, u32 pid)
|
|
|
|
|
{
|
|
|
|
|
struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu);
|
|
|
|
|
|
|
|
|
|
if (vcpu->arch.pid != pid) {
|
|
|
|
|
vcpu_e500->pid[0] = vcpu->arch.pid = pid;
|
|
|
|
|
kvmppc_e500_recalc_shadow_pid(vcpu_e500);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* gtlbe must not be mapped by more than one host tlbe */
|
|
|
|
|
void kvmppc_e500_tlbil_one(struct kvmppc_vcpu_e500 *vcpu_e500,
|
|
|
|
|
struct kvm_book3e_206_tlb_entry *gtlbe)
|
|
|
|
|
{
|
|
|
|
|
struct vcpu_id_table *idt = vcpu_e500->idt;
|
2015-09-24 08:00:23 -06:00
|
|
|
unsigned int pr, tid, ts;
|
|
|
|
|
int pid;
|
2011-12-20 08:34:34 -07:00
|
|
|
u32 val, eaddr;
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
|
|
ts = get_tlb_ts(gtlbe);
|
|
|
|
|
tid = get_tlb_tid(gtlbe);
|
|
|
|
|
|
|
|
|
|
preempt_disable();
|
|
|
|
|
|
|
|
|
|
/* One guest ID may be mapped to two shadow IDs */
|
|
|
|
|
for (pr = 0; pr < 2; pr++) {
|
|
|
|
|
/*
|
|
|
|
|
* The shadow PID can have a valid mapping on at most one
|
|
|
|
|
* host CPU. In the common case, it will be valid on this
|
|
|
|
|
* CPU, in which case we do a local invalidation of the
|
|
|
|
|
* specific address.
|
|
|
|
|
*
|
|
|
|
|
* If the shadow PID is not valid on the current host CPU,
|
|
|
|
|
* we invalidate the entire shadow PID.
|
|
|
|
|
*/
|
|
|
|
|
pid = local_sid_lookup(&idt->id[ts][tid][pr]);
|
|
|
|
|
if (pid <= 0) {
|
|
|
|
|
kvmppc_e500_id_table_reset_one(vcpu_e500, ts, tid, pr);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The guest is invalidating a 4K entry which is in a PID
|
|
|
|
|
* that has a valid shadow mapping on this host CPU. We
|
|
|
|
|
* search host TLB to invalidate it's shadow TLB entry,
|
|
|
|
|
* similar to __tlbil_va except that we need to look in AS1.
|
|
|
|
|
*/
|
|
|
|
|
val = (pid << MAS6_SPID_SHIFT) | MAS6_SAS;
|
|
|
|
|
eaddr = get_tlb_eaddr(gtlbe);
|
|
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
|
|
|
|
|
|
mtspr(SPRN_MAS6, val);
|
|
|
|
|
asm volatile("tlbsx 0, %[eaddr]" : : [eaddr] "r" (eaddr));
|
|
|
|
|
val = mfspr(SPRN_MAS1);
|
|
|
|
|
if (val & MAS1_VALID) {
|
|
|
|
|
mtspr(SPRN_MAS1, val & ~MAS1_VALID);
|
|
|
|
|
asm volatile("tlbwe");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
local_irq_restore(flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
preempt_enable();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void kvmppc_e500_tlbil_all(struct kvmppc_vcpu_e500 *vcpu_e500)
|
|
|
|
|
{
|
|
|
|
|
kvmppc_e500_id_table_reset_all(vcpu_e500);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void kvmppc_mmu_msr_notify(struct kvm_vcpu *vcpu, u32 old_msr)
|
|
|
|
|
{
|
|
|
|
|
/* Recalc shadow pid since MSR changes */
|
|
|
|
|
kvmppc_e500_recalc_shadow_pid(to_e500(vcpu));
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-07 10:47:53 -06:00
|
|
|
static void kvmppc_core_vcpu_load_e500(struct kvm_vcpu *vcpu, int cpu)
|
2009-01-03 15:23:10 -07:00
|
|
|
{
|
2011-12-20 08:34:22 -07:00
|
|
|
kvmppc_booke_vcpu_load(vcpu, cpu);
|
2011-12-20 08:34:34 -07:00
|
|
|
|
|
|
|
|
/* Shadow PID may be expired on local core */
|
|
|
|
|
kvmppc_e500_recalc_shadow_pid(to_e500(vcpu));
|
2009-01-03 15:23:10 -07:00
|
|
|
}
|
|
|
|
|
|
2013-10-07 10:47:53 -06:00
|
|
|
static void kvmppc_core_vcpu_put_e500(struct kvm_vcpu *vcpu)
|
2009-01-03 15:23:10 -07:00
|
|
|
{
|
2011-06-14 17:34:31 -06:00
|
|
|
#ifdef CONFIG_SPE
|
|
|
|
|
if (vcpu->arch.shadow_msr & MSR_SPE)
|
|
|
|
|
kvmppc_vcpu_disable_spe(vcpu);
|
|
|
|
|
#endif
|
2011-12-20 08:34:22 -07:00
|
|
|
|
|
|
|
|
kvmppc_booke_vcpu_put(vcpu);
|
2009-01-03 15:23:10 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int kvmppc_core_check_processor_compat(void)
|
|
|
|
|
{
|
|
|
|
|
int r;
|
|
|
|
|
|
|
|
|
|
if (strcmp(cur_cpu_spec->cpu_name, "e500v2") == 0)
|
|
|
|
|
r = 0;
|
|
|
|
|
else
|
|
|
|
|
r = -ENOTSUPP;
|
|
|
|
|
|
|
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
2011-12-20 08:34:34 -07:00
|
|
|
static void kvmppc_e500_tlb_setup(struct kvmppc_vcpu_e500 *vcpu_e500)
|
|
|
|
|
{
|
|
|
|
|
struct kvm_book3e_206_tlb_entry *tlbe;
|
|
|
|
|
|
|
|
|
|
/* Insert large initial mapping for guest. */
|
|
|
|
|
tlbe = get_entry(vcpu_e500, 1, 0);
|
|
|
|
|
tlbe->mas1 = MAS1_VALID | MAS1_TSIZE(BOOK3E_PAGESZ_256M);
|
|
|
|
|
tlbe->mas2 = 0;
|
|
|
|
|
tlbe->mas7_3 = E500_TLB_SUPER_PERM_MASK;
|
|
|
|
|
|
|
|
|
|
/* 4K map for serial output. Used by kernel wrapper. */
|
|
|
|
|
tlbe = get_entry(vcpu_e500, 1, 1);
|
|
|
|
|
tlbe->mas1 = MAS1_VALID | MAS1_TSIZE(BOOK3E_PAGESZ_4K);
|
|
|
|
|
tlbe->mas2 = (0xe0004500 & 0xFFFFF000) | MAS2_I | MAS2_G;
|
|
|
|
|
tlbe->mas7_3 = (0xe0004500 & 0xFFFFF000) | E500_TLB_SUPER_PERM_MASK;
|
|
|
|
|
}
|
|
|
|
|
|
2009-01-03 15:23:10 -07:00
|
|
|
int kvmppc_core_vcpu_setup(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu);
|
|
|
|
|
|
|
|
|
|
kvmppc_e500_tlb_setup(vcpu_e500);
|
|
|
|
|
|
2010-01-22 03:50:30 -07:00
|
|
|
/* Registers init */
|
|
|
|
|
vcpu->arch.pvr = mfspr(SPRN_PVR);
|
2011-03-29 15:49:10 -06:00
|
|
|
vcpu_e500->svr = mfspr(SPRN_SVR);
|
2010-01-22 03:50:30 -07:00
|
|
|
|
2011-08-10 05:57:08 -06:00
|
|
|
vcpu->arch.cpu_type = KVM_CPU_E500V2;
|
|
|
|
|
|
2009-01-03 15:23:10 -07:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-07 10:47:53 -06:00
|
|
|
static int kvmppc_core_get_sregs_e500(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_sregs *sregs)
|
2011-04-27 16:24:21 -06:00
|
|
|
{
|
|
|
|
|
struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu);
|
|
|
|
|
|
|
|
|
|
sregs->u.e.features |= KVM_SREGS_E_ARCH206_MMU | KVM_SREGS_E_SPE |
|
|
|
|
|
KVM_SREGS_E_PM;
|
|
|
|
|
sregs->u.e.impl_id = KVM_SREGS_E_IMPL_FSL;
|
|
|
|
|
|
|
|
|
|
sregs->u.e.impl.fsl.features = 0;
|
|
|
|
|
sregs->u.e.impl.fsl.svr = vcpu_e500->svr;
|
|
|
|
|
sregs->u.e.impl.fsl.hid0 = vcpu_e500->hid0;
|
|
|
|
|
sregs->u.e.impl.fsl.mcar = vcpu_e500->mcar;
|
|
|
|
|
|
|
|
|
|
sregs->u.e.ivor_high[0] = vcpu->arch.ivor[BOOKE_IRQPRIO_SPE_UNAVAIL];
|
|
|
|
|
sregs->u.e.ivor_high[1] = vcpu->arch.ivor[BOOKE_IRQPRIO_SPE_FP_DATA];
|
|
|
|
|
sregs->u.e.ivor_high[2] = vcpu->arch.ivor[BOOKE_IRQPRIO_SPE_FP_ROUND];
|
|
|
|
|
sregs->u.e.ivor_high[3] =
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_PERFORMANCE_MONITOR];
|
|
|
|
|
|
|
|
|
|
kvmppc_get_sregs_ivor(vcpu, sregs);
|
2011-12-20 08:34:34 -07:00
|
|
|
kvmppc_get_sregs_e500_tlb(vcpu, sregs);
|
2013-10-07 10:47:53 -06:00
|
|
|
return 0;
|
2011-04-27 16:24:21 -06:00
|
|
|
}
|
|
|
|
|
|
2013-10-07 10:47:53 -06:00
|
|
|
static int kvmppc_core_set_sregs_e500(struct kvm_vcpu *vcpu,
|
|
|
|
|
struct kvm_sregs *sregs)
|
2011-04-27 16:24:21 -06:00
|
|
|
{
|
|
|
|
|
struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu);
|
2011-12-20 08:34:34 -07:00
|
|
|
int ret;
|
2011-04-27 16:24:21 -06:00
|
|
|
|
|
|
|
|
if (sregs->u.e.impl_id == KVM_SREGS_E_IMPL_FSL) {
|
|
|
|
|
vcpu_e500->svr = sregs->u.e.impl.fsl.svr;
|
|
|
|
|
vcpu_e500->hid0 = sregs->u.e.impl.fsl.hid0;
|
|
|
|
|
vcpu_e500->mcar = sregs->u.e.impl.fsl.mcar;
|
|
|
|
|
}
|
|
|
|
|
|
2011-12-20 08:34:34 -07:00
|
|
|
ret = kvmppc_set_sregs_e500_tlb(vcpu, sregs);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
return ret;
|
2011-04-27 16:24:21 -06:00
|
|
|
|
|
|
|
|
if (!(sregs->u.e.features & KVM_SREGS_E_IVOR))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (sregs->u.e.features & KVM_SREGS_E_SPE) {
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_SPE_UNAVAIL] =
|
|
|
|
|
sregs->u.e.ivor_high[0];
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_SPE_FP_DATA] =
|
|
|
|
|
sregs->u.e.ivor_high[1];
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_SPE_FP_ROUND] =
|
|
|
|
|
sregs->u.e.ivor_high[2];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (sregs->u.e.features & KVM_SREGS_E_PM) {
|
|
|
|
|
vcpu->arch.ivor[BOOKE_IRQPRIO_PERFORMANCE_MONITOR] =
|
|
|
|
|
sregs->u.e.ivor_high[3];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return kvmppc_set_sregs_ivor(vcpu, sregs);
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-07 10:47:53 -06:00
|
|
|
static int kvmppc_get_one_reg_e500(struct kvm_vcpu *vcpu, u64 id,
|
|
|
|
|
union kvmppc_one_reg *val)
|
2013-04-10 18:03:07 -06:00
|
|
|
{
|
2013-04-10 18:03:08 -06:00
|
|
|
int r = kvmppc_get_one_reg_e500_tlb(vcpu, id, val);
|
|
|
|
|
return r;
|
2013-04-10 18:03:07 -06:00
|
|
|
}
|
|
|
|
|
|
2013-10-07 10:47:53 -06:00
|
|
|
static int kvmppc_set_one_reg_e500(struct kvm_vcpu *vcpu, u64 id,
|
|
|
|
|
union kvmppc_one_reg *val)
|
2013-04-10 18:03:07 -06:00
|
|
|
{
|
2013-04-10 18:03:08 -06:00
|
|
|
int r = kvmppc_get_one_reg_e500_tlb(vcpu, id, val);
|
|
|
|
|
return r;
|
2013-04-10 18:03:07 -06:00
|
|
|
}
|
|
|
|
|
|
2013-10-07 10:47:53 -06:00
|
|
|
static struct kvm_vcpu *kvmppc_core_vcpu_create_e500(struct kvm *kvm,
|
|
|
|
|
unsigned int id)
|
2009-01-03 15:23:10 -07:00
|
|
|
{
|
|
|
|
|
struct kvmppc_vcpu_e500 *vcpu_e500;
|
|
|
|
|
struct kvm_vcpu *vcpu;
|
|
|
|
|
int err;
|
|
|
|
|
|
2019-08-15 11:22:37 -06:00
|
|
|
BUILD_BUG_ON_MSG(offsetof(struct kvmppc_vcpu_e500, vcpu) != 0,
|
|
|
|
|
"struct kvm_vcpu must be at offset 0 for arch usercopy region");
|
|
|
|
|
|
2009-01-03 15:23:10 -07:00
|
|
|
vcpu_e500 = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
|
|
|
|
|
if (!vcpu_e500) {
|
|
|
|
|
err = -ENOMEM;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
vcpu = &vcpu_e500->vcpu;
|
|
|
|
|
err = kvm_vcpu_init(vcpu, kvm, id);
|
|
|
|
|
if (err)
|
|
|
|
|
goto free_vcpu;
|
|
|
|
|
|
2017-07-13 01:38:29 -06:00
|
|
|
if (kvmppc_e500_id_table_alloc(vcpu_e500) == NULL) {
|
|
|
|
|
err = -ENOMEM;
|
2011-12-20 08:34:34 -07:00
|
|
|
goto uninit_vcpu;
|
2017-07-13 01:38:29 -06:00
|
|
|
}
|
2011-12-20 08:34:34 -07:00
|
|
|
|
2009-01-03 15:23:10 -07:00
|
|
|
err = kvmppc_e500_tlb_init(vcpu_e500);
|
|
|
|
|
if (err)
|
2011-12-20 08:34:34 -07:00
|
|
|
goto uninit_id;
|
2009-01-03 15:23:10 -07:00
|
|
|
|
2010-07-29 06:47:42 -06:00
|
|
|
vcpu->arch.shared = (void*)__get_free_page(GFP_KERNEL|__GFP_ZERO);
|
2017-07-13 01:38:29 -06:00
|
|
|
if (!vcpu->arch.shared) {
|
|
|
|
|
err = -ENOMEM;
|
2010-07-29 06:47:42 -06:00
|
|
|
goto uninit_tlb;
|
2017-07-13 01:38:29 -06:00
|
|
|
}
|
2010-07-29 06:47:42 -06:00
|
|
|
|
2009-01-03 15:23:10 -07:00
|
|
|
return vcpu;
|
|
|
|
|
|
2010-07-29 06:47:42 -06:00
|
|
|
uninit_tlb:
|
|
|
|
|
kvmppc_e500_tlb_uninit(vcpu_e500);
|
2011-12-20 08:34:34 -07:00
|
|
|
uninit_id:
|
|
|
|
|
kvmppc_e500_id_table_free(vcpu_e500);
|
2009-01-03 15:23:10 -07:00
|
|
|
uninit_vcpu:
|
|
|
|
|
kvm_vcpu_uninit(vcpu);
|
|
|
|
|
free_vcpu:
|
|
|
|
|
kmem_cache_free(kvm_vcpu_cache, vcpu_e500);
|
|
|
|
|
out:
|
|
|
|
|
return ERR_PTR(err);
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-07 10:47:53 -06:00
|
|
|
static void kvmppc_core_vcpu_free_e500(struct kvm_vcpu *vcpu)
|
2009-01-03 15:23:10 -07:00
|
|
|
{
|
|
|
|
|
struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu);
|
|
|
|
|
|
2010-07-29 06:47:42 -06:00
|
|
|
free_page((unsigned long)vcpu->arch.shared);
|
2010-10-05 13:22:41 -06:00
|
|
|
kvmppc_e500_tlb_uninit(vcpu_e500);
|
2011-12-20 08:34:34 -07:00
|
|
|
kvmppc_e500_id_table_free(vcpu_e500);
|
|
|
|
|
kvm_vcpu_uninit(vcpu);
|
2009-01-03 15:23:10 -07:00
|
|
|
kmem_cache_free(kvm_vcpu_cache, vcpu_e500);
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-07 10:47:53 -06:00
|
|
|
static int kvmppc_core_init_vm_e500(struct kvm *kvm)
|
2011-12-20 08:34:26 -07:00
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-07 10:47:53 -06:00
|
|
|
static void kvmppc_core_destroy_vm_e500(struct kvm *kvm)
|
2011-12-20 08:34:26 -07:00
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-07 10:47:53 -06:00
|
|
|
static struct kvmppc_ops kvm_ops_e500 = {
|
|
|
|
|
.get_sregs = kvmppc_core_get_sregs_e500,
|
|
|
|
|
.set_sregs = kvmppc_core_set_sregs_e500,
|
|
|
|
|
.get_one_reg = kvmppc_get_one_reg_e500,
|
|
|
|
|
.set_one_reg = kvmppc_set_one_reg_e500,
|
|
|
|
|
.vcpu_load = kvmppc_core_vcpu_load_e500,
|
|
|
|
|
.vcpu_put = kvmppc_core_vcpu_put_e500,
|
|
|
|
|
.vcpu_create = kvmppc_core_vcpu_create_e500,
|
|
|
|
|
.vcpu_free = kvmppc_core_vcpu_free_e500,
|
|
|
|
|
.mmu_destroy = kvmppc_mmu_destroy_e500,
|
|
|
|
|
.init_vm = kvmppc_core_init_vm_e500,
|
|
|
|
|
.destroy_vm = kvmppc_core_destroy_vm_e500,
|
|
|
|
|
.emulate_op = kvmppc_core_emulate_op_e500,
|
|
|
|
|
.emulate_mtspr = kvmppc_core_emulate_mtspr_e500,
|
|
|
|
|
.emulate_mfspr = kvmppc_core_emulate_mfspr_e500,
|
|
|
|
|
};
|
|
|
|
|
|
2009-06-01 19:46:14 -06:00
|
|
|
static int __init kvmppc_e500_init(void)
|
2009-01-03 15:23:10 -07:00
|
|
|
{
|
2009-01-03 15:23:13 -07:00
|
|
|
int r, i;
|
|
|
|
|
unsigned long ivor[3];
|
2013-01-15 15:24:39 -07:00
|
|
|
/* Process remaining handlers above the generic first 16 */
|
|
|
|
|
unsigned long *handler = &kvmppc_booke_handler_addr[16];
|
|
|
|
|
unsigned long handler_len;
|
2009-01-03 15:23:13 -07:00
|
|
|
unsigned long max_ivor = 0;
|
2009-01-03 15:23:10 -07:00
|
|
|
|
2012-01-18 16:23:46 -07:00
|
|
|
r = kvmppc_core_check_processor_compat();
|
|
|
|
|
if (r)
|
2013-10-07 10:47:53 -06:00
|
|
|
goto err_out;
|
2012-01-18 16:23:46 -07:00
|
|
|
|
2009-01-03 15:23:10 -07:00
|
|
|
r = kvmppc_booke_init();
|
|
|
|
|
if (r)
|
2013-10-07 10:47:53 -06:00
|
|
|
goto err_out;
|
2009-01-03 15:23:10 -07:00
|
|
|
|
2009-01-03 15:23:13 -07:00
|
|
|
/* copy extra E500 exception handlers */
|
|
|
|
|
ivor[0] = mfspr(SPRN_IVOR32);
|
|
|
|
|
ivor[1] = mfspr(SPRN_IVOR33);
|
|
|
|
|
ivor[2] = mfspr(SPRN_IVOR34);
|
|
|
|
|
for (i = 0; i < 3; i++) {
|
2013-01-15 15:24:39 -07:00
|
|
|
if (ivor[i] > ivor[max_ivor])
|
|
|
|
|
max_ivor = i;
|
2009-01-03 15:23:13 -07:00
|
|
|
|
2013-01-15 15:24:39 -07:00
|
|
|
handler_len = handler[i + 1] - handler[i];
|
2009-01-03 15:23:13 -07:00
|
|
|
memcpy((void *)kvmppc_booke_handlers + ivor[i],
|
2013-01-15 15:24:39 -07:00
|
|
|
(void *)handler[i], handler_len);
|
2009-01-03 15:23:13 -07:00
|
|
|
}
|
2013-01-15 15:24:39 -07:00
|
|
|
handler_len = handler[max_ivor + 1] - handler[max_ivor];
|
|
|
|
|
flush_icache_range(kvmppc_booke_handlers, kvmppc_booke_handlers +
|
|
|
|
|
ivor[max_ivor] + handler_len);
|
2009-01-03 15:23:13 -07:00
|
|
|
|
2013-10-07 10:48:01 -06:00
|
|
|
r = kvm_init(NULL, sizeof(struct kvmppc_vcpu_e500), 0, THIS_MODULE);
|
|
|
|
|
if (r)
|
|
|
|
|
goto err_out;
|
|
|
|
|
kvm_ops_e500.owner = THIS_MODULE;
|
|
|
|
|
kvmppc_pr_ops = &kvm_ops_e500;
|
|
|
|
|
|
2013-10-07 10:47:53 -06:00
|
|
|
err_out:
|
|
|
|
|
return r;
|
2009-01-03 15:23:10 -07:00
|
|
|
}
|
|
|
|
|
|
2010-05-18 01:34:12 -06:00
|
|
|
static void __exit kvmppc_e500_exit(void)
|
2009-01-03 15:23:10 -07:00
|
|
|
{
|
2013-10-07 10:48:01 -06:00
|
|
|
kvmppc_pr_ops = NULL;
|
2009-01-03 15:23:10 -07:00
|
|
|
kvmppc_booke_exit();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
module_init(kvmppc_e500_init);
|
|
|
|
|
module_exit(kvmppc_e500_exit);
|
2013-12-09 05:53:42 -07:00
|
|
|
MODULE_ALIAS_MISCDEV(KVM_MINOR);
|
|
|
|
|
MODULE_ALIAS("devname:kvm");
|