mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-25 21:54:06 +08:00
fe489bf450
On the x86 side, there are some optimizations and documentation updates. The big ARM/KVM change for 3.11, support for AArch64, will come through Catalin Marinas's tree. s390 and PPC have misc cleanups and bugfixes. There is a conflict due to "s390/pgtable: fix ipte notify bit" having entered 3.10 through Martin Schwidefsky's s390 tree. This pull request has additional changes on top, so this tree's version is the correct one. -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.13 (GNU/Linux) iQIcBAABAgAGBQJR0oU6AAoJEBvWZb6bTYbynnsP/RSUrrHrA8Wu1tqVfAKu+1y5 6OIihqZ9x11/YMaNofAfv86jqxFu0/j7CzMGphNdjzujqKI+Q1tGe7oiVCmKzoG+ UvSctWsz0lpllgBtnnrm5tcfmG6rrddhLtpA7m320+xCVx8KV5P4VfyHZEU+Ho8h ziPmb2mAQ65gBNX6nLHEJ3ITTgad6gt4NNbrKIYpyXuWZQJypzaRqT/vpc4md+Ed dCebMXsL1xgyb98EcnOdrWH1wV30MfucR7IpObOhXnnMKeeltqAQPvaOlKzZh4dK +QfxJfdRZVS0cepcxzx1Q2X3dgjoKQsHq1nlIyz3qu1vhtfaqBlixLZk0SguZ/R9 1S1YqucZiLRO57RD4q0Ak5oxwobu18ZoqJZ6nledNdWwDe8bz/W2wGAeVty19ky0 qstBdM9jnwXrc0qrVgZp3+s5dsx3NAm/KKZBoq4sXiDLd/yBzdEdWIVkIrU3X9wU 3X26wOmBxtsB7so/JR7ciTsQHelmLicnVeXohAEP9CjIJffB81xVXnXs0P0SYuiQ RzbSCwjPzET4JBOaHWT0Dhv0DTS/EaI97KzlN32US3Bn3WiLlS1oDCoPFoaLqd2K LxQMsXS8anAWxFvexfSuUpbJGPnKSidSQoQmJeMGBa9QhmZCht3IL16/Fb641ToN xBohzi49L9FDbpOnTYfz =1zpG -----END PGP SIGNATURE----- Merge tag 'for-linus' of git://git.kernel.org/pub/scm/virt/kvm/kvm Pull KVM fixes from Paolo Bonzini: "On the x86 side, there are some optimizations and documentation updates. The big ARM/KVM change for 3.11, support for AArch64, will come through Catalin Marinas's tree. s390 and PPC have misc cleanups and bugfixes" * tag 'for-linus' of git://git.kernel.org/pub/scm/virt/kvm/kvm: (87 commits) KVM: PPC: Ignore PIR writes KVM: PPC: Book3S PR: Invalidate SLB entries properly KVM: PPC: Book3S PR: Allow guest to use 1TB segments KVM: PPC: Book3S PR: Don't keep scanning HPTEG after we find a match KVM: PPC: Book3S PR: Fix invalidation of SLB entry 0 on guest entry KVM: PPC: Book3S PR: Fix proto-VSID calculations KVM: PPC: Guard doorbell exception with CONFIG_PPC_DOORBELL KVM: Fix RTC interrupt coalescing tracking kvm: Add a tracepoint write_tsc_offset KVM: MMU: Inform users of mmio generation wraparound KVM: MMU: document fast invalidate all mmio sptes KVM: MMU: document fast invalidate all pages KVM: MMU: document fast page fault KVM: MMU: document mmio page fault KVM: MMU: document write_flooding_count KVM: MMU: document clear_spte_count KVM: MMU: drop kvm_mmu_zap_mmio_sptes KVM: MMU: init kvm generation close to mmio wrap-around value KVM: MMU: add tracepoint for check_mmio_spte KVM: MMU: fast invalidate all mmio sptes ...
285 lines
6.8 KiB
C
285 lines
6.8 KiB
C
/*
|
|
* Copyright (C) 2012 ARM Ltd.
|
|
* Author: Marc Zyngier <marc.zyngier@arm.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include <linux/cpu.h>
|
|
#include <linux/of_irq.h>
|
|
#include <linux/kvm.h>
|
|
#include <linux/kvm_host.h>
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <clocksource/arm_arch_timer.h>
|
|
#include <asm/arch_timer.h>
|
|
|
|
#include <kvm/arm_vgic.h>
|
|
#include <kvm/arm_arch_timer.h>
|
|
|
|
static struct timecounter *timecounter;
|
|
static struct workqueue_struct *wqueue;
|
|
static unsigned int host_vtimer_irq;
|
|
|
|
static cycle_t kvm_phys_timer_read(void)
|
|
{
|
|
return timecounter->cc->read(timecounter->cc);
|
|
}
|
|
|
|
static bool timer_is_armed(struct arch_timer_cpu *timer)
|
|
{
|
|
return timer->armed;
|
|
}
|
|
|
|
/* timer_arm: as in "arm the timer", not as in ARM the company */
|
|
static void timer_arm(struct arch_timer_cpu *timer, u64 ns)
|
|
{
|
|
timer->armed = true;
|
|
hrtimer_start(&timer->timer, ktime_add_ns(ktime_get(), ns),
|
|
HRTIMER_MODE_ABS);
|
|
}
|
|
|
|
static void timer_disarm(struct arch_timer_cpu *timer)
|
|
{
|
|
if (timer_is_armed(timer)) {
|
|
hrtimer_cancel(&timer->timer);
|
|
cancel_work_sync(&timer->expired);
|
|
timer->armed = false;
|
|
}
|
|
}
|
|
|
|
static void kvm_timer_inject_irq(struct kvm_vcpu *vcpu)
|
|
{
|
|
struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
|
|
|
|
timer->cntv_ctl |= ARCH_TIMER_CTRL_IT_MASK;
|
|
kvm_vgic_inject_irq(vcpu->kvm, vcpu->vcpu_id,
|
|
timer->irq->irq,
|
|
timer->irq->level);
|
|
}
|
|
|
|
static irqreturn_t kvm_arch_timer_handler(int irq, void *dev_id)
|
|
{
|
|
struct kvm_vcpu *vcpu = *(struct kvm_vcpu **)dev_id;
|
|
|
|
/*
|
|
* We disable the timer in the world switch and let it be
|
|
* handled by kvm_timer_sync_hwstate(). Getting a timer
|
|
* interrupt at this point is a sure sign of some major
|
|
* breakage.
|
|
*/
|
|
pr_warn("Unexpected interrupt %d on vcpu %p\n", irq, vcpu);
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static void kvm_timer_inject_irq_work(struct work_struct *work)
|
|
{
|
|
struct kvm_vcpu *vcpu;
|
|
|
|
vcpu = container_of(work, struct kvm_vcpu, arch.timer_cpu.expired);
|
|
vcpu->arch.timer_cpu.armed = false;
|
|
kvm_timer_inject_irq(vcpu);
|
|
}
|
|
|
|
static enum hrtimer_restart kvm_timer_expire(struct hrtimer *hrt)
|
|
{
|
|
struct arch_timer_cpu *timer;
|
|
timer = container_of(hrt, struct arch_timer_cpu, timer);
|
|
queue_work(wqueue, &timer->expired);
|
|
return HRTIMER_NORESTART;
|
|
}
|
|
|
|
/**
|
|
* kvm_timer_flush_hwstate - prepare to move the virt timer to the cpu
|
|
* @vcpu: The vcpu pointer
|
|
*
|
|
* Disarm any pending soft timers, since the world-switch code will write the
|
|
* virtual timer state back to the physical CPU.
|
|
*/
|
|
void kvm_timer_flush_hwstate(struct kvm_vcpu *vcpu)
|
|
{
|
|
struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
|
|
|
|
/*
|
|
* We're about to run this vcpu again, so there is no need to
|
|
* keep the background timer running, as we're about to
|
|
* populate the CPU timer again.
|
|
*/
|
|
timer_disarm(timer);
|
|
}
|
|
|
|
/**
|
|
* kvm_timer_sync_hwstate - sync timer state from cpu
|
|
* @vcpu: The vcpu pointer
|
|
*
|
|
* Check if the virtual timer was armed and either schedule a corresponding
|
|
* soft timer or inject directly if already expired.
|
|
*/
|
|
void kvm_timer_sync_hwstate(struct kvm_vcpu *vcpu)
|
|
{
|
|
struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
|
|
cycle_t cval, now;
|
|
u64 ns;
|
|
|
|
if ((timer->cntv_ctl & ARCH_TIMER_CTRL_IT_MASK) ||
|
|
!(timer->cntv_ctl & ARCH_TIMER_CTRL_ENABLE))
|
|
return;
|
|
|
|
cval = timer->cntv_cval;
|
|
now = kvm_phys_timer_read() - vcpu->kvm->arch.timer.cntvoff;
|
|
|
|
BUG_ON(timer_is_armed(timer));
|
|
|
|
if (cval <= now) {
|
|
/*
|
|
* Timer has already expired while we were not
|
|
* looking. Inject the interrupt and carry on.
|
|
*/
|
|
kvm_timer_inject_irq(vcpu);
|
|
return;
|
|
}
|
|
|
|
ns = cyclecounter_cyc2ns(timecounter->cc, cval - now);
|
|
timer_arm(timer, ns);
|
|
}
|
|
|
|
void kvm_timer_vcpu_reset(struct kvm_vcpu *vcpu,
|
|
const struct kvm_irq_level *irq)
|
|
{
|
|
struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
|
|
|
|
/*
|
|
* The vcpu timer irq number cannot be determined in
|
|
* kvm_timer_vcpu_init() because it is called much before
|
|
* kvm_vcpu_set_target(). To handle this, we determine
|
|
* vcpu timer irq number when the vcpu is reset.
|
|
*/
|
|
timer->irq = irq;
|
|
}
|
|
|
|
void kvm_timer_vcpu_init(struct kvm_vcpu *vcpu)
|
|
{
|
|
struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
|
|
|
|
INIT_WORK(&timer->expired, kvm_timer_inject_irq_work);
|
|
hrtimer_init(&timer->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
|
|
timer->timer.function = kvm_timer_expire;
|
|
}
|
|
|
|
static void kvm_timer_init_interrupt(void *info)
|
|
{
|
|
enable_percpu_irq(host_vtimer_irq, 0);
|
|
}
|
|
|
|
|
|
static int kvm_timer_cpu_notify(struct notifier_block *self,
|
|
unsigned long action, void *cpu)
|
|
{
|
|
switch (action) {
|
|
case CPU_STARTING:
|
|
case CPU_STARTING_FROZEN:
|
|
kvm_timer_init_interrupt(NULL);
|
|
break;
|
|
case CPU_DYING:
|
|
case CPU_DYING_FROZEN:
|
|
disable_percpu_irq(host_vtimer_irq);
|
|
break;
|
|
}
|
|
|
|
return NOTIFY_OK;
|
|
}
|
|
|
|
static struct notifier_block kvm_timer_cpu_nb = {
|
|
.notifier_call = kvm_timer_cpu_notify,
|
|
};
|
|
|
|
static const struct of_device_id arch_timer_of_match[] = {
|
|
{ .compatible = "arm,armv7-timer", },
|
|
{ .compatible = "arm,armv8-timer", },
|
|
{},
|
|
};
|
|
|
|
int kvm_timer_hyp_init(void)
|
|
{
|
|
struct device_node *np;
|
|
unsigned int ppi;
|
|
int err;
|
|
|
|
timecounter = arch_timer_get_timecounter();
|
|
if (!timecounter)
|
|
return -ENODEV;
|
|
|
|
np = of_find_matching_node(NULL, arch_timer_of_match);
|
|
if (!np) {
|
|
kvm_err("kvm_arch_timer: can't find DT node\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
ppi = irq_of_parse_and_map(np, 2);
|
|
if (!ppi) {
|
|
kvm_err("kvm_arch_timer: no virtual timer interrupt\n");
|
|
err = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
err = request_percpu_irq(ppi, kvm_arch_timer_handler,
|
|
"kvm guest timer", kvm_get_running_vcpus());
|
|
if (err) {
|
|
kvm_err("kvm_arch_timer: can't request interrupt %d (%d)\n",
|
|
ppi, err);
|
|
goto out;
|
|
}
|
|
|
|
host_vtimer_irq = ppi;
|
|
|
|
err = register_cpu_notifier(&kvm_timer_cpu_nb);
|
|
if (err) {
|
|
kvm_err("Cannot register timer CPU notifier\n");
|
|
goto out_free;
|
|
}
|
|
|
|
wqueue = create_singlethread_workqueue("kvm_arch_timer");
|
|
if (!wqueue) {
|
|
err = -ENOMEM;
|
|
goto out_free;
|
|
}
|
|
|
|
kvm_info("%s IRQ%d\n", np->name, ppi);
|
|
on_each_cpu(kvm_timer_init_interrupt, NULL, 1);
|
|
|
|
goto out;
|
|
out_free:
|
|
free_percpu_irq(ppi, kvm_get_running_vcpus());
|
|
out:
|
|
of_node_put(np);
|
|
return err;
|
|
}
|
|
|
|
void kvm_timer_vcpu_terminate(struct kvm_vcpu *vcpu)
|
|
{
|
|
struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
|
|
|
|
timer_disarm(timer);
|
|
}
|
|
|
|
int kvm_timer_init(struct kvm *kvm)
|
|
{
|
|
if (timecounter && wqueue) {
|
|
kvm->arch.timer.cntvoff = kvm_phys_timer_read();
|
|
kvm->arch.timer.enabled = 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|