mmio.c File Reference

#include <linux/kvm_host.h>
#include <asm/kvm_emulate.h>
#include <trace/events/kvm.h>
#include "trace.h"

Include dependency graph for mmio.c:

Go to the source code of this file.

Functions
void	kvm_mmio_write_buf (void *buf, unsigned int len, unsigned long data)
unsigned long	kvm_mmio_read_buf (const void *buf, unsigned int len)
int	kvm_handle_mmio_return (struct kvm_vcpu *vcpu)
int	io_mem_abort (struct kvm_vcpu *vcpu, phys_addr_t fault_ipa)

Function Documentation

io_mem_abort()

int io_mem_abort	(	struct kvm_vcpu *	vcpu,
		phys_addr_t	fault_ipa
	)

Definition at line 123 of file mmio.c.

{
    struct kvm_run *run = vcpu->run;
    unsigned long data;
    unsigned long rt;
    int ret;
    bool is_write;
    int len;
    u8 data_buf[8];
 
    /*
     * No valid syndrome? Ask userspace for help if it has
     * volunteered to do so, and bail out otherwise.
     */
    if (!kvm_vcpu_dabt_isvalid(vcpu)) {
        trace_kvm_mmio_nisv(*vcpu_pc(vcpu), kvm_vcpu_get_esr(vcpu),
                    kvm_vcpu_get_hfar(vcpu), fault_ipa);
 
        if (test_bit(KVM_ARCH_FLAG_RETURN_NISV_IO_ABORT_TO_USER,
                 &vcpu->kvm->arch.flags)) {
            run->exit_reason = KVM_EXIT_ARM_NISV;
            run->arm_nisv.esr_iss = kvm_vcpu_dabt_iss_nisv_sanitized(vcpu);
            run->arm_nisv.fault_ipa = fault_ipa;
            return 0;
        }
 
        return -ENOSYS;
    }
 
    /*
     * Prepare MMIO operation. First decode the syndrome data we get
     * from the CPU. Then try if some in-kernel emulation feels
     * responsible, otherwise let user space do its magic.
     */
    is_write = kvm_vcpu_dabt_iswrite(vcpu);
    len = kvm_vcpu_dabt_get_as(vcpu);
    rt = kvm_vcpu_dabt_get_rd(vcpu);
 
    if (is_write) {
        data = vcpu_data_guest_to_host(vcpu, vcpu_get_reg(vcpu, rt),
                           len);
 
        trace_kvm_mmio(KVM_TRACE_MMIO_WRITE, len, fault_ipa, &data);
        kvm_mmio_write_buf(data_buf, len, data);
 
        ret = kvm_io_bus_write(vcpu, KVM_MMIO_BUS, fault_ipa, len,
                       data_buf);
    } else {
        trace_kvm_mmio(KVM_TRACE_MMIO_READ_UNSATISFIED, len,
                   fault_ipa, NULL);
 
        ret = kvm_io_bus_read(vcpu, KVM_MMIO_BUS, fault_ipa, len,
                      data_buf);
    }
 
    /* Now prepare kvm_run for the potential return to userland. */
    run->mmio.is_write  = is_write;
    run->mmio.phys_addr = fault_ipa;
    run->mmio.len       = len;
    vcpu->mmio_needed   = 1;
 
    if (!ret) {
        /* We handled the access successfully in the kernel. */
        if (!is_write)
            memcpy(run->mmio.data, data_buf, len);
        vcpu->stat.mmio_exit_kernel++;
        kvm_handle_mmio_return(vcpu);
        return 1;
    }
 
    if (is_write)
        memcpy(run->mmio.data, data_buf, len);
    vcpu->stat.mmio_exit_user++;
    run->exit_reason    = KVM_EXIT_MMIO;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_handle_mmio_return()

int kvm_handle_mmio_return

(

struct kvm_vcpu *

vcpu

)

kvm_handle_mmio_return – Handle MMIO loads after user space emulation or in-kernel IO emulation

@vcpu: The VCPU pointer

Definition at line 81 of file mmio.c.

{
    unsigned long data;
    unsigned int len;
    int mask;
 
    /* Detect an already handled MMIO return */
    if (unlikely(!vcpu->mmio_needed))
        return 0;
 
    vcpu->mmio_needed = 0;
 
    if (!kvm_vcpu_dabt_iswrite(vcpu)) {
        struct kvm_run *run = vcpu->run;
 
        len = kvm_vcpu_dabt_get_as(vcpu);
        data = kvm_mmio_read_buf(run->mmio.data, len);
 
        if (kvm_vcpu_dabt_issext(vcpu) &&
            len < sizeof(unsigned long)) {
            mask = 1U << ((len * 8) - 1);
            data = (data ^ mask) - mask;
        }
 
        if (!kvm_vcpu_dabt_issf(vcpu))
            data = data & 0xffffffff;
 
        trace_kvm_mmio(KVM_TRACE_MMIO_READ, len, run->mmio.phys_addr,
                   &data);
        data = vcpu_data_host_to_guest(vcpu, data, len);
        vcpu_set_reg(vcpu, kvm_vcpu_dabt_get_rd(vcpu), data);
    }
 
    /*
     * The MMIO instruction is emulated and should not be re-executed
     * in the guest.
     */
    kvm_incr_pc(vcpu);
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_mmio_read_buf()

unsigned long kvm_mmio_read_buf	(	const void *	buf,
		unsigned int	len
	)

Definition at line 45 of file mmio.c.

{
    unsigned long data = 0;
    union {
        u16 hword;
        u32 word;
        u64 dword;
    } tmp;
 
    switch (len) {
    case 1:
        data = *(u8 *)buf;
        break;
    case 2:
        memcpy(&tmp.hword, buf, len);
        data = tmp.hword;
        break;
    case 4:
        memcpy(&tmp.word, buf, len);
        data = tmp.word;
        break;
    case 8:
        memcpy(&tmp.dword, buf, len);
        data = tmp.dword;
        break;
    }
 
    return data;
}

Here is the caller graph for this function:

kvm_mmio_write_buf()

void kvm_mmio_write_buf	(	void *	buf,
		unsigned int	len,
		unsigned long	data
	)

Definition at line 13 of file mmio.c.

{
    void *datap = NULL;
    union {
        u8  byte;
        u16 hword;
        u32 word;
        u64 dword;
    } tmp;
 
    switch (len) {
    case 1:
        tmp.byte    = data;
        datap       = &tmp.byte;
        break;
    case 2:
        tmp.hword   = data;
        datap       = &tmp.hword;
        break;
    case 4:
        tmp.word    = data;
        datap       = &tmp.word;
        break;
    case 8:
        tmp.dword   = data;
        datap       = &tmp.dword;
        break;
    }
 
    memcpy(buf, datap, len);
}

Here is the caller graph for this function: