arm_arch_timer.h File Reference

#include <linux/clocksource.h>
#include <linux/hrtimer.h>

Include dependency graph for arm_arch_timer.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	arch_timer_offset
struct	arch_timer_vm_data
struct	arch_timer_context
struct	timer_map
struct	arch_timer_cpu

Macros
#define	vcpu_timer(v)   (&(v)->arch.timer_cpu)
#define	vcpu_get_timer(v, t)   (&vcpu_timer(v)->timers[(t)])
#define	vcpu_vtimer(v)   (&(v)->arch.timer_cpu.timers[TIMER_VTIMER])
#define	vcpu_ptimer(v)   (&(v)->arch.timer_cpu.timers[TIMER_PTIMER])
#define	vcpu_hvtimer(v)   (&(v)->arch.timer_cpu.timers[TIMER_HVTIMER])
#define	vcpu_hptimer(v)   (&(v)->arch.timer_cpu.timers[TIMER_HPTIMER])
#define	arch_timer_ctx_index(ctx)   ((ctx) - vcpu_timer((ctx)->vcpu)->timers)
#define	timer_vm_data(ctx)   (&(ctx)->vcpu->kvm->arch.timer_data)
#define	timer_irq(ctx)   (timer_vm_data(ctx)->ppi[arch_timer_ctx_index(ctx)])

Enumerations
enum	kvm_arch_timers {   TIMER_PTIMER , TIMER_VTIMER , NR_KVM_EL0_TIMERS , TIMER_HVTIMER = NR_KVM_EL0_TIMERS ,   TIMER_HPTIMER , NR_KVM_TIMERS }
enum	kvm_arch_timer_regs {   TIMER_REG_CNT , TIMER_REG_CVAL , TIMER_REG_TVAL , TIMER_REG_CTL ,   TIMER_REG_VOFF }

Functions
void	get_timer_map (struct kvm_vcpu *vcpu, struct timer_map *map)
int __init	kvm_timer_hyp_init (bool has_gic)
int	kvm_timer_enable (struct kvm_vcpu *vcpu)
void	kvm_timer_vcpu_reset (struct kvm_vcpu *vcpu)
void	kvm_timer_vcpu_init (struct kvm_vcpu *vcpu)
void	kvm_timer_sync_user (struct kvm_vcpu *vcpu)
bool	kvm_timer_should_notify_user (struct kvm_vcpu *vcpu)
void	kvm_timer_update_run (struct kvm_vcpu *vcpu)
void	kvm_timer_vcpu_terminate (struct kvm_vcpu *vcpu)
void	kvm_timer_init_vm (struct kvm *kvm)
u64	kvm_arm_timer_get_reg (struct kvm_vcpu *, u64 regid)
int	kvm_arm_timer_set_reg (struct kvm_vcpu *, u64 regid, u64 value)
int	kvm_arm_timer_set_attr (struct kvm_vcpu *vcpu, struct kvm_device_attr *attr)
int	kvm_arm_timer_get_attr (struct kvm_vcpu *vcpu, struct kvm_device_attr *attr)
int	kvm_arm_timer_has_attr (struct kvm_vcpu *vcpu, struct kvm_device_attr *attr)
u64	kvm_phys_timer_read (void)
void	kvm_timer_vcpu_load (struct kvm_vcpu *vcpu)
void	kvm_timer_vcpu_put (struct kvm_vcpu *vcpu)
void	kvm_timer_init_vhe (void)
u64	kvm_arm_timer_read_sysreg (struct kvm_vcpu *vcpu, enum kvm_arch_timers tmr, enum kvm_arch_timer_regs treg)
void	kvm_arm_timer_write_sysreg (struct kvm_vcpu *vcpu, enum kvm_arch_timers tmr, enum kvm_arch_timer_regs treg, u64 val)
u32	timer_get_ctl (struct arch_timer_context *ctxt)
u64	timer_get_cval (struct arch_timer_context *ctxt)
void	kvm_timer_cpu_up (void)
void	kvm_timer_cpu_down (void)
static bool	has_cntpoff (void)

Macro Definition Documentation

arch_timer_ctx_index

#define arch_timer_ctx_index

(

ctx

)

((ctx) - vcpu_timer((ctx)->vcpu)->timers)

Definition at line 129 of file arm_arch_timer.h.

timer_irq

#define timer_irq

(

ctx

)

(timer_vm_data(ctx)->ppi[arch_timer_ctx_index(ctx)])

Definition at line 132 of file arm_arch_timer.h.

timer_vm_data

#define timer_vm_data

(

ctx

)

(&(ctx)->vcpu->kvm->arch.timer_data)

Definition at line 131 of file arm_arch_timer.h.

vcpu_get_timer

#define vcpu_get_timer	(		v,
			t
	)		(&vcpu_timer(v)->timers[(t)])

Definition at line 123 of file arm_arch_timer.h.

vcpu_hptimer

#define vcpu_hptimer

(

v

)

(&(v)->arch.timer_cpu.timers[TIMER_HPTIMER])

Definition at line 127 of file arm_arch_timer.h.

vcpu_hvtimer

#define vcpu_hvtimer

(

v

)

(&(v)->arch.timer_cpu.timers[TIMER_HVTIMER])

Definition at line 126 of file arm_arch_timer.h.

vcpu_ptimer

#define vcpu_ptimer

(

v

)

(&(v)->arch.timer_cpu.timers[TIMER_PTIMER])

Definition at line 125 of file arm_arch_timer.h.

vcpu_timer

#define vcpu_timer

(

v

)

(&(v)->arch.timer_cpu)

Definition at line 122 of file arm_arch_timer.h.

vcpu_vtimer

#define vcpu_vtimer

(

v

)

(&(v)->arch.timer_cpu.timers[TIMER_VTIMER])

Definition at line 124 of file arm_arch_timer.h.

Enumeration Type Documentation

kvm_arch_timer_regs

enum kvm_arch_timer_regs

Enumerator
TIMER_REG_CNT
TIMER_REG_CVAL
TIMER_REG_TVAL
TIMER_REG_CTL
TIMER_REG_VOFF

Definition at line 22 of file arm_arch_timer.h.

                         {
    TIMER_REG_CNT,
    TIMER_REG_CVAL,
    TIMER_REG_TVAL,
    TIMER_REG_CTL,
    TIMER_REG_VOFF,
};

kvm_arch_timers

enum kvm_arch_timers

Enumerator
TIMER_PTIMER
TIMER_VTIMER
NR_KVM_EL0_TIMERS
TIMER_HVTIMER
TIMER_HPTIMER
NR_KVM_TIMERS

Definition at line 13 of file arm_arch_timer.h.

                     {
    TIMER_PTIMER,
    TIMER_VTIMER,
    NR_KVM_EL0_TIMERS,
    TIMER_HVTIMER = NR_KVM_EL0_TIMERS,
    TIMER_HPTIMER,
    NR_KVM_TIMERS
};

Function Documentation

get_timer_map()

void get_timer_map	(	struct kvm_vcpu *	vcpu,
		struct timer_map *	map
	)

Definition at line 178 of file arch_timer.c.

{
    if (vcpu_has_nv(vcpu)) {
        if (is_hyp_ctxt(vcpu)) {
            map->direct_vtimer = vcpu_hvtimer(vcpu);
            map->direct_ptimer = vcpu_hptimer(vcpu);
            map->emul_vtimer = vcpu_vtimer(vcpu);
            map->emul_ptimer = vcpu_ptimer(vcpu);
        } else {
            map->direct_vtimer = vcpu_vtimer(vcpu);
            map->direct_ptimer = vcpu_ptimer(vcpu);
            map->emul_vtimer = vcpu_hvtimer(vcpu);
            map->emul_ptimer = vcpu_hptimer(vcpu);
        }
    } else if (has_vhe()) {
        map->direct_vtimer = vcpu_vtimer(vcpu);
        map->direct_ptimer = vcpu_ptimer(vcpu);
        map->emul_vtimer = NULL;
        map->emul_ptimer = NULL;
    } else {
        map->direct_vtimer = vcpu_vtimer(vcpu);
        map->direct_ptimer = NULL;
        map->emul_vtimer = NULL;
        map->emul_ptimer = vcpu_ptimer(vcpu);
    }
 
    trace_kvm_get_timer_map(vcpu->vcpu_id, map);
}

Here is the caller graph for this function:

has_cntpoff()

static bool has_cntpoff ( void  )

inlinestatic

Definition at line 150 of file arm_arch_timer.h.

{
    return (has_vhe() && cpus_have_final_cap(ARM64_HAS_ECV_CNTPOFF));
}

Here is the caller graph for this function:

kvm_arm_timer_get_attr()

int kvm_arm_timer_get_attr	(	struct kvm_vcpu *	vcpu,
		struct kvm_device_attr *	attr
	)

Definition at line 1611 of file arch_timer.c.

{
    int __user *uaddr = (int __user *)(long)attr->addr;
    struct arch_timer_context *timer;
    int irq;
 
    switch (attr->attr) {
    case KVM_ARM_VCPU_TIMER_IRQ_VTIMER:
        timer = vcpu_vtimer(vcpu);
        break;
    case KVM_ARM_VCPU_TIMER_IRQ_PTIMER:
        timer = vcpu_ptimer(vcpu);
        break;
    case KVM_ARM_VCPU_TIMER_IRQ_HVTIMER:
        timer = vcpu_hvtimer(vcpu);
        break;
    case KVM_ARM_VCPU_TIMER_IRQ_HPTIMER:
        timer = vcpu_hptimer(vcpu);
        break;
    default:
        return -ENXIO;
    }
 
    irq = timer_irq(timer);
    return put_user(irq, uaddr);
}

Here is the caller graph for this function:

kvm_arm_timer_get_reg()

u64 kvm_arm_timer_get_reg	(	struct kvm_vcpu *	vcpu,
		u64	regid
	)

Definition at line 1107 of file arch_timer.c.

{
    switch (regid) {
    case KVM_REG_ARM_TIMER_CTL:
        return kvm_arm_timer_read(vcpu,
                      vcpu_vtimer(vcpu), TIMER_REG_CTL);
    case KVM_REG_ARM_TIMER_CNT:
        return kvm_arm_timer_read(vcpu,
                      vcpu_vtimer(vcpu), TIMER_REG_CNT);
    case KVM_REG_ARM_TIMER_CVAL:
        return kvm_arm_timer_read(vcpu,
                      vcpu_vtimer(vcpu), TIMER_REG_CVAL);
    case KVM_REG_ARM_PTIMER_CTL:
        return kvm_arm_timer_read(vcpu,
                      vcpu_ptimer(vcpu), TIMER_REG_CTL);
    case KVM_REG_ARM_PTIMER_CNT:
        return kvm_arm_timer_read(vcpu,
                      vcpu_ptimer(vcpu), TIMER_REG_CNT);
    case KVM_REG_ARM_PTIMER_CVAL:
        return kvm_arm_timer_read(vcpu,
                      vcpu_ptimer(vcpu), TIMER_REG_CVAL);
    }
    return (u64)-1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_arm_timer_has_attr()

int kvm_arm_timer_has_attr	(	struct kvm_vcpu *	vcpu,
		struct kvm_device_attr *	attr
	)

Definition at line 1638 of file arch_timer.c.

{
    switch (attr->attr) {
    case KVM_ARM_VCPU_TIMER_IRQ_VTIMER:
    case KVM_ARM_VCPU_TIMER_IRQ_PTIMER:
    case KVM_ARM_VCPU_TIMER_IRQ_HVTIMER:
    case KVM_ARM_VCPU_TIMER_IRQ_HPTIMER:
        return 0;
    }
 
    return -ENXIO;
}

Here is the caller graph for this function:

kvm_arm_timer_read_sysreg()

u64 kvm_arm_timer_read_sysreg	(	struct kvm_vcpu *	vcpu,
		enum kvm_arch_timers	tmr,
		enum kvm_arch_timer_regs	treg
	)

Definition at line 1167 of file arch_timer.c.

{
    struct arch_timer_context *timer;
    struct timer_map map;
    u64 val;
 
    get_timer_map(vcpu, &map);
    timer = vcpu_get_timer(vcpu, tmr);
 
    if (timer == map.emul_vtimer || timer == map.emul_ptimer)
        return kvm_arm_timer_read(vcpu, timer, treg);
 
    preempt_disable();
    timer_save_state(timer);
 
    val = kvm_arm_timer_read(vcpu, timer, treg);
 
    timer_restore_state(timer);
    preempt_enable();
 
    return val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_arm_timer_set_attr()

int kvm_arm_timer_set_attr	(	struct kvm_vcpu *	vcpu,
		struct kvm_device_attr *	attr
	)

Definition at line 1559 of file arch_timer.c.

{
    int __user *uaddr = (int __user *)(long)attr->addr;
    int irq, idx, ret = 0;
 
    if (!irqchip_in_kernel(vcpu->kvm))
        return -EINVAL;
 
    if (get_user(irq, uaddr))
        return -EFAULT;
 
    if (!(irq_is_ppi(irq)))
        return -EINVAL;
 
    mutex_lock(&vcpu->kvm->arch.config_lock);
 
    if (test_bit(KVM_ARCH_FLAG_TIMER_PPIS_IMMUTABLE,
             &vcpu->kvm->arch.flags)) {
        ret = -EBUSY;
        goto out;
    }
 
    switch (attr->attr) {
    case KVM_ARM_VCPU_TIMER_IRQ_VTIMER:
        idx = TIMER_VTIMER;
        break;
    case KVM_ARM_VCPU_TIMER_IRQ_PTIMER:
        idx = TIMER_PTIMER;
        break;
    case KVM_ARM_VCPU_TIMER_IRQ_HVTIMER:
        idx = TIMER_HVTIMER;
        break;
    case KVM_ARM_VCPU_TIMER_IRQ_HPTIMER:
        idx = TIMER_HPTIMER;
        break;
    default:
        ret = -ENXIO;
        goto out;
    }
 
    /*
     * We cannot validate the IRQ unicity before we run, so take it at
     * face value. The verdict will be given on first vcpu run, for each
     * vcpu. Yes this is late. Blame it on the stupid API.
     */
    vcpu->kvm->arch.timer_data.ppi[idx] = irq;
 
out:
    mutex_unlock(&vcpu->kvm->arch.config_lock);
    return ret;
}

Here is the caller graph for this function:

kvm_arm_timer_set_reg()

int kvm_arm_timer_set_reg	(	struct kvm_vcpu *	vcpu,
		u64	regid,
		u64	value
	)

Definition at line 1048 of file arch_timer.c.

{
    struct arch_timer_context *timer;
 
    switch (regid) {
    case KVM_REG_ARM_TIMER_CTL:
        timer = vcpu_vtimer(vcpu);
        kvm_arm_timer_write(vcpu, timer, TIMER_REG_CTL, value);
        break;
    case KVM_REG_ARM_TIMER_CNT:
        if (!test_bit(KVM_ARCH_FLAG_VM_COUNTER_OFFSET,
                  &vcpu->kvm->arch.flags)) {
            timer = vcpu_vtimer(vcpu);
            timer_set_offset(timer, kvm_phys_timer_read() - value);
        }
        break;
    case KVM_REG_ARM_TIMER_CVAL:
        timer = vcpu_vtimer(vcpu);
        kvm_arm_timer_write(vcpu, timer, TIMER_REG_CVAL, value);
        break;
    case KVM_REG_ARM_PTIMER_CTL:
        timer = vcpu_ptimer(vcpu);
        kvm_arm_timer_write(vcpu, timer, TIMER_REG_CTL, value);
        break;
    case KVM_REG_ARM_PTIMER_CNT:
        if (!test_bit(KVM_ARCH_FLAG_VM_COUNTER_OFFSET,
                  &vcpu->kvm->arch.flags)) {
            timer = vcpu_ptimer(vcpu);
            timer_set_offset(timer, kvm_phys_timer_read() - value);
        }
        break;
    case KVM_REG_ARM_PTIMER_CVAL:
        timer = vcpu_ptimer(vcpu);
        kvm_arm_timer_write(vcpu, timer, TIMER_REG_CVAL, value);
        break;
 
    default:
        return -1;
    }
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_arm_timer_write_sysreg()

void kvm_arm_timer_write_sysreg	(	struct kvm_vcpu *	vcpu,
		enum kvm_arch_timers	tmr,
		enum kvm_arch_timer_regs	treg,
		u64	val
	)

Definition at line 1219 of file arch_timer.c.

{
    struct arch_timer_context *timer;
    struct timer_map map;
 
    get_timer_map(vcpu, &map);
    timer = vcpu_get_timer(vcpu, tmr);
    if (timer == map.emul_vtimer || timer == map.emul_ptimer) {
        soft_timer_cancel(&timer->hrtimer);
        kvm_arm_timer_write(vcpu, timer, treg, val);
        timer_emulate(timer);
    } else {
        preempt_disable();
        timer_save_state(timer);
        kvm_arm_timer_write(vcpu, timer, treg, val);
        timer_restore_state(timer);
        preempt_enable();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_phys_timer_read()

u64 kvm_phys_timer_read

(

void

)

Definition at line 173 of file arch_timer.c.

{
    return timecounter->cc->read(timecounter->cc);
}

Here is the caller graph for this function:

kvm_timer_cpu_down()

void kvm_timer_cpu_down

(

void

)

Definition at line 1041 of file arch_timer.c.

{
    disable_percpu_irq(host_vtimer_irq);
    if (host_ptimer_irq)
        disable_percpu_irq(host_ptimer_irq);
}

Here is the caller graph for this function:

kvm_timer_cpu_up()

void kvm_timer_cpu_up

(

void

)

Definition at line 1034 of file arch_timer.c.

{
    enable_percpu_irq(host_vtimer_irq, host_vtimer_irq_flags);
    if (host_ptimer_irq)
        enable_percpu_irq(host_ptimer_irq, host_ptimer_irq_flags);
}

Here is the caller graph for this function:

kvm_timer_enable()

int kvm_timer_enable

(

struct kvm_vcpu *

vcpu

)

Definition at line 1506 of file arch_timer.c.

{
    struct arch_timer_cpu *timer = vcpu_timer(vcpu);
    struct timer_map map;
    int ret;
 
    if (timer->enabled)
        return 0;
 
    /* Without a VGIC we do not map virtual IRQs to physical IRQs */
    if (!irqchip_in_kernel(vcpu->kvm))
        goto no_vgic;
 
    /*
     * At this stage, we have the guarantee that the vgic is both
     * available and initialized.
     */
    if (!timer_irqs_are_valid(vcpu)) {
        kvm_debug("incorrectly configured timer irqs\n");
        return -EINVAL;
    }
 
    get_timer_map(vcpu, &map);
 
    ret = kvm_vgic_map_phys_irq(vcpu,
                    map.direct_vtimer->host_timer_irq,
                    timer_irq(map.direct_vtimer),
                    &arch_timer_irq_ops);
    if (ret)
        return ret;
 
    if (map.direct_ptimer) {
        ret = kvm_vgic_map_phys_irq(vcpu,
                        map.direct_ptimer->host_timer_irq,
                        timer_irq(map.direct_ptimer),
                        &arch_timer_irq_ops);
    }
 
    if (ret)
        return ret;
 
no_vgic:
    timer->enabled = 1;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_timer_hyp_init()

int __init kvm_timer_hyp_init

(

bool

has_gic

)

Definition at line 1367 of file arch_timer.c.

{
    struct arch_timer_kvm_info *info;
    int err;
 
    info = arch_timer_get_kvm_info();
    timecounter = &info->timecounter;
 
    if (!timecounter->cc) {
        kvm_err("kvm_arch_timer: uninitialized timecounter\n");
        return -ENODEV;
    }
 
    err = kvm_irq_init(info);
    if (err)
        return err;
 
    /* First, do the virtual EL1 timer irq */
 
    err = request_percpu_irq(host_vtimer_irq, kvm_arch_timer_handler,
                 "kvm guest vtimer", kvm_get_running_vcpus());
    if (err) {
        kvm_err("kvm_arch_timer: can't request vtimer interrupt %d (%d)\n",
            host_vtimer_irq, err);
        return err;
    }
 
    if (has_gic) {
        err = irq_set_vcpu_affinity(host_vtimer_irq,
                        kvm_get_running_vcpus());
        if (err) {
            kvm_err("kvm_arch_timer: error setting vcpu affinity\n");
            goto out_free_vtimer_irq;
        }
 
        static_branch_enable(&has_gic_active_state);
    }
 
    kvm_debug("virtual timer IRQ%d\n", host_vtimer_irq);
 
    /* Now let's do the physical EL1 timer irq */
 
    if (info->physical_irq > 0) {
        err = request_percpu_irq(host_ptimer_irq, kvm_arch_timer_handler,
                     "kvm guest ptimer", kvm_get_running_vcpus());
        if (err) {
            kvm_err("kvm_arch_timer: can't request ptimer interrupt %d (%d)\n",
                host_ptimer_irq, err);
            goto out_free_vtimer_irq;
        }
 
        if (has_gic) {
            err = irq_set_vcpu_affinity(host_ptimer_irq,
                            kvm_get_running_vcpus());
            if (err) {
                kvm_err("kvm_arch_timer: error setting vcpu affinity\n");
                goto out_free_ptimer_irq;
            }
        }
 
        kvm_debug("physical timer IRQ%d\n", host_ptimer_irq);
    } else if (has_vhe()) {
        kvm_err("kvm_arch_timer: invalid physical timer IRQ: %d\n",
            info->physical_irq);
        err = -ENODEV;
        goto out_free_vtimer_irq;
    }
 
    return 0;
 
out_free_ptimer_irq:
    if (info->physical_irq > 0)
        free_percpu_irq(host_ptimer_irq, kvm_get_running_vcpus());
out_free_vtimer_irq:
    free_percpu_irq(host_vtimer_irq, kvm_get_running_vcpus());
    return err;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_timer_init_vhe()

void kvm_timer_init_vhe

(

void

)

Definition at line 1553 of file arch_timer.c.

{
    if (cpus_have_final_cap(ARM64_HAS_ECV_CNTPOFF))
        sysreg_clear_set(cnthctl_el2, 0, CNTHCTL_ECV);
}

Here is the caller graph for this function:

kvm_timer_init_vm()

void kvm_timer_init_vm

(

struct kvm *

kvm

)

Definition at line 1028 of file arch_timer.c.

{
    for (int i = 0; i < NR_KVM_TIMERS; i++)
        kvm->arch.timer_data.ppi[i] = default_ppi[i];
}

Here is the caller graph for this function:

kvm_timer_should_notify_user()

bool kvm_timer_should_notify_user

(

struct kvm_vcpu *

vcpu

)

Definition at line 860 of file arch_timer.c.

{
    struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
    struct arch_timer_context *ptimer = vcpu_ptimer(vcpu);
    struct kvm_sync_regs *sregs = &vcpu->run->s.regs;
    bool vlevel, plevel;
 
    if (likely(irqchip_in_kernel(vcpu->kvm)))
        return false;
 
    vlevel = sregs->device_irq_level & KVM_ARM_DEV_EL1_VTIMER;
    plevel = sregs->device_irq_level & KVM_ARM_DEV_EL1_PTIMER;
 
    return kvm_timer_should_fire(vtimer) != vlevel ||
           kvm_timer_should_fire(ptimer) != plevel;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_timer_sync_user()

void kvm_timer_sync_user

(

struct kvm_vcpu *

vcpu

)

Definition at line 927 of file arch_timer.c.

{
    struct arch_timer_cpu *timer = vcpu_timer(vcpu);
 
    if (unlikely(!timer->enabled))
        return;
 
    if (unlikely(!irqchip_in_kernel(vcpu->kvm)))
        unmask_vtimer_irq_user(vcpu);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_timer_update_run()

void kvm_timer_update_run

(

struct kvm_vcpu *

vcpu

)

Definition at line 430 of file arch_timer.c.

{
    struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
    struct arch_timer_context *ptimer = vcpu_ptimer(vcpu);
    struct kvm_sync_regs *regs = &vcpu->run->s.regs;
 
    /* Populate the device bitmap with the timer states */
    regs->device_irq_level &= ~(KVM_ARM_DEV_EL1_VTIMER |
                    KVM_ARM_DEV_EL1_PTIMER);
    if (kvm_timer_should_fire(vtimer))
        regs->device_irq_level |= KVM_ARM_DEV_EL1_VTIMER;
    if (kvm_timer_should_fire(ptimer))
        regs->device_irq_level |= KVM_ARM_DEV_EL1_PTIMER;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_timer_vcpu_init()

void kvm_timer_vcpu_init

(

struct kvm_vcpu *

vcpu

)

Definition at line 1011 of file arch_timer.c.

{
    struct arch_timer_cpu *timer = vcpu_timer(vcpu);
 
    for (int i = 0; i < NR_KVM_TIMERS; i++)
        timer_context_init(vcpu, i);
 
    /* Synchronize offsets across timers of a VM if not already provided */
    if (!test_bit(KVM_ARCH_FLAG_VM_COUNTER_OFFSET, &vcpu->kvm->arch.flags)) {
        timer_set_offset(vcpu_vtimer(vcpu), kvm_phys_timer_read());
        timer_set_offset(vcpu_ptimer(vcpu), 0);
    }
 
    hrtimer_init(&timer->bg_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_HARD);
    timer->bg_timer.function = kvm_bg_timer_expire;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_timer_vcpu_load()

void kvm_timer_vcpu_load

(

struct kvm_vcpu *

vcpu

)

Definition at line 826 of file arch_timer.c.

{
    struct arch_timer_cpu *timer = vcpu_timer(vcpu);
    struct timer_map map;
 
    if (unlikely(!timer->enabled))
        return;
 
    get_timer_map(vcpu, &map);
 
    if (static_branch_likely(&has_gic_active_state)) {
        if (vcpu_has_nv(vcpu))
            kvm_timer_vcpu_load_nested_switch(vcpu, &map);
 
        kvm_timer_vcpu_load_gic(map.direct_vtimer);
        if (map.direct_ptimer)
            kvm_timer_vcpu_load_gic(map.direct_ptimer);
    } else {
        kvm_timer_vcpu_load_nogic(vcpu);
    }
 
    kvm_timer_unblocking(vcpu);
 
    timer_restore_state(map.direct_vtimer);
    if (map.direct_ptimer)
        timer_restore_state(map.direct_ptimer);
    if (map.emul_vtimer)
        timer_emulate(map.emul_vtimer);
    if (map.emul_ptimer)
        timer_emulate(map.emul_ptimer);
 
    timer_set_traps(vcpu, &map);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_timer_vcpu_put()

void kvm_timer_vcpu_put

(

struct kvm_vcpu *

vcpu

)

Definition at line 877 of file arch_timer.c.

{
    struct arch_timer_cpu *timer = vcpu_timer(vcpu);
    struct timer_map map;
 
    if (unlikely(!timer->enabled))
        return;
 
    get_timer_map(vcpu, &map);
 
    timer_save_state(map.direct_vtimer);
    if (map.direct_ptimer)
        timer_save_state(map.direct_ptimer);
 
    /*
     * Cancel soft timer emulation, because the only case where we
     * need it after a vcpu_put is in the context of a sleeping VCPU, and
     * in that case we already factor in the deadline for the physical
     * timer when scheduling the bg_timer.
     *
     * In any case, we re-schedule the hrtimer for the physical timer when
     * coming back to the VCPU thread in kvm_timer_vcpu_load().
     */
    if (map.emul_vtimer)
        soft_timer_cancel(&map.emul_vtimer->hrtimer);
    if (map.emul_ptimer)
        soft_timer_cancel(&map.emul_ptimer->hrtimer);
 
    if (kvm_vcpu_is_blocking(vcpu))
        kvm_timer_blocking(vcpu);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_timer_vcpu_reset()

void kvm_timer_vcpu_reset

(

struct kvm_vcpu *

vcpu

)

Definition at line 938 of file arch_timer.c.

{
    struct arch_timer_cpu *timer = vcpu_timer(vcpu);
    struct timer_map map;
 
    get_timer_map(vcpu, &map);
 
    /*
     * The bits in CNTV_CTL are architecturally reset to UNKNOWN for ARMv8
     * and to 0 for ARMv7.  We provide an implementation that always
     * resets the timer to be disabled and unmasked and is compliant with
     * the ARMv7 architecture.
     */
    for (int i = 0; i < nr_timers(vcpu); i++)
        timer_set_ctl(vcpu_get_timer(vcpu, i), 0);
 
    /*
     * A vcpu running at EL2 is in charge of the offset applied to
     * the virtual timer, so use the physical VM offset, and point
     * the vcpu offset to CNTVOFF_EL2.
     */
    if (vcpu_has_nv(vcpu)) {
        struct arch_timer_offset *offs = &vcpu_vtimer(vcpu)->offset;
 
        offs->vcpu_offset = &__vcpu_sys_reg(vcpu, CNTVOFF_EL2);
        offs->vm_offset = &vcpu->kvm->arch.timer_data.poffset;
    }
 
    if (timer->enabled) {
        for (int i = 0; i < nr_timers(vcpu); i++)
            kvm_timer_update_irq(vcpu, false,
                         vcpu_get_timer(vcpu, i));
 
        if (irqchip_in_kernel(vcpu->kvm)) {
            kvm_vgic_reset_mapped_irq(vcpu, timer_irq(map.direct_vtimer));
            if (map.direct_ptimer)
                kvm_vgic_reset_mapped_irq(vcpu, timer_irq(map.direct_ptimer));
        }
    }
 
    if (map.emul_vtimer)
        soft_timer_cancel(&map.emul_vtimer->hrtimer);
    if (map.emul_ptimer)
        soft_timer_cancel(&map.emul_ptimer->hrtimer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_timer_vcpu_terminate()

void kvm_timer_vcpu_terminate

(

struct kvm_vcpu *

vcpu

)

Definition at line 1445 of file arch_timer.c.

{
    struct arch_timer_cpu *timer = vcpu_timer(vcpu);
 
    soft_timer_cancel(&timer->bg_timer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

timer_get_ctl()

u32 timer_get_ctl

(

struct arch_timer_context *

ctxt

)

Definition at line 66 of file arch_timer.c.

{
    struct kvm_vcpu *vcpu = ctxt->vcpu;
 
    switch(arch_timer_ctx_index(ctxt)) {
    case TIMER_VTIMER:
        return __vcpu_sys_reg(vcpu, CNTV_CTL_EL0);
    case TIMER_PTIMER:
        return __vcpu_sys_reg(vcpu, CNTP_CTL_EL0);
    case TIMER_HVTIMER:
        return __vcpu_sys_reg(vcpu, CNTHV_CTL_EL2);
    case TIMER_HPTIMER:
        return __vcpu_sys_reg(vcpu, CNTHP_CTL_EL2);
    default:
        WARN_ON(1);
        return 0;
    }
}

Here is the caller graph for this function:

timer_get_cval()

u64 timer_get_cval

(

struct arch_timer_context *

ctxt

)

Definition at line 85 of file arch_timer.c.

{
    struct kvm_vcpu *vcpu = ctxt->vcpu;
 
    switch(arch_timer_ctx_index(ctxt)) {
    case TIMER_VTIMER:
        return __vcpu_sys_reg(vcpu, CNTV_CVAL_EL0);
    case TIMER_PTIMER:
        return __vcpu_sys_reg(vcpu, CNTP_CVAL_EL0);
    case TIMER_HVTIMER:
        return __vcpu_sys_reg(vcpu, CNTHV_CVAL_EL2);
    case TIMER_HPTIMER:
        return __vcpu_sys_reg(vcpu, CNTHP_CVAL_EL2);
    default:
        WARN_ON(1);
        return 0;
    }
}

Here is the caller graph for this function: