#include <asm/hvm/support.h>
static int hvmemul_do_io(
- int is_mmio, paddr_t addr, unsigned long count, int size,
+ int is_mmio, paddr_t addr, unsigned long *reps, int size,
paddr_t value, int dir, int df, int value_is_ptr, unsigned long *val)
{
struct vcpu *curr = current;
vcpu_iodata_t *vio = get_ioreq(curr);
ioreq_t *p = &vio->vp_ioreq;
+ int rc;
switch ( curr->arch.hvm_vcpu.io_state )
{
p->type = is_mmio ? IOREQ_TYPE_COPY : IOREQ_TYPE_PIO;
p->size = size;
p->addr = addr;
- p->count = count;
+ p->count = *reps;
p->df = df;
p->data = value;
p->io_count++;
- if ( is_mmio
- ? (hvm_mmio_intercept(p) || hvm_buffered_io_intercept(p))
- : hvm_portio_intercept(p) )
+ if ( is_mmio )
+ {
+ rc = hvm_mmio_intercept(p);
+ if ( rc == X86EMUL_UNHANDLEABLE )
+ rc = hvm_buffered_io_intercept(p);
+ }
+ else
+ {
+ rc = hvm_portio_intercept(p);
+ }
+
+ switch ( rc )
{
+ case X86EMUL_OKAY:
+ *reps = p->count;
p->state = STATE_IORESP_READY;
hvm_io_assist();
if ( val != NULL )
*val = curr->arch.hvm_vcpu.io_data;
curr->arch.hvm_vcpu.io_state = HVMIO_none;
- return X86EMUL_OKAY;
+ break;
+ case X86EMUL_UNHANDLEABLE:
+ hvm_send_assist_req(curr);
+ rc = (val != NULL) ? X86EMUL_RETRY : X86EMUL_OKAY;
+ break;
+ case X86EMUL_RETRY:
+ break;
+ default:
+ BUG();
}
- hvm_send_assist_req(curr);
- return (val != NULL) ? X86EMUL_RETRY : X86EMUL_OKAY;
+ return rc;
}
static int hvmemul_do_pio(
- unsigned long port, unsigned long count, int size,
+ unsigned long port, unsigned long *reps, int size,
paddr_t value, int dir, int df, int value_is_ptr, unsigned long *val)
{
- return hvmemul_do_io(0, port, count, size, value,
+ return hvmemul_do_io(0, port, reps, size, value,
dir, df, value_is_ptr, val);
}
static int hvmemul_do_mmio(
- paddr_t gpa, unsigned long count, int size,
+ paddr_t gpa, unsigned long *reps, int size,
paddr_t value, int dir, int df, int value_is_ptr, unsigned long *val)
{
- return hvmemul_do_io(1, gpa, count, size, value,
+ return hvmemul_do_io(1, gpa, reps, size, value,
dir, df, value_is_ptr, val);
}
struct hvm_emulate_ctxt *hvmemul_ctxt)
{
struct vcpu *curr = current;
- unsigned long addr;
+ unsigned long addr, reps = 1;
uint32_t pfec = PFEC_page_present;
paddr_t gpa;
int rc;
return X86EMUL_UNHANDLEABLE;
gpa = (((paddr_t)curr->arch.hvm_vcpu.mmio_gpfn << PAGE_SHIFT) | off);
if ( (off + bytes) <= PAGE_SIZE )
- return hvmemul_do_mmio(gpa, 1, bytes, 0, IOREQ_READ, 0, 0, val);
+ return hvmemul_do_mmio(gpa, &reps, bytes, 0,
+ IOREQ_READ, 0, 0, val);
}
if ( (seg != x86_seg_none) &&
if ( rc != X86EMUL_OKAY )
return rc;
- return hvmemul_do_mmio(gpa, 1, bytes, 0, IOREQ_READ, 0, 0, val);
+ return hvmemul_do_mmio(gpa, &reps, bytes, 0, IOREQ_READ, 0, 0, val);
}
return X86EMUL_OKAY;
struct hvm_emulate_ctxt *hvmemul_ctxt =
container_of(ctxt, struct hvm_emulate_ctxt, ctxt);
struct vcpu *curr = current;
- unsigned long addr;
+ unsigned long addr, reps = 1;
uint32_t pfec = PFEC_page_present | PFEC_write_access;
paddr_t gpa;
int rc;
unsigned int off = addr & (PAGE_SIZE - 1);
gpa = (((paddr_t)curr->arch.hvm_vcpu.mmio_gpfn << PAGE_SHIFT) | off);
if ( (off + bytes) <= PAGE_SIZE )
- return hvmemul_do_mmio(gpa, 1, bytes, val, IOREQ_WRITE,
- 0, 0, NULL);
+ return hvmemul_do_mmio(gpa, &reps, bytes, val,
+ IOREQ_WRITE, 0, 0, NULL);
}
if ( (seg != x86_seg_none) &&
if ( rc != X86EMUL_OKAY )
return rc;
- return hvmemul_do_mmio(gpa, 1, bytes, val, IOREQ_WRITE, 0, 0, NULL);
+ return hvmemul_do_mmio(gpa, &reps, bytes, val,
+ IOREQ_WRITE, 0, 0, NULL);
}
return X86EMUL_OKAY;
if ( rc != X86EMUL_OKAY )
return rc;
- return hvmemul_do_pio(src_port, *reps, bytes_per_rep, gpa, IOREQ_READ,
+ return hvmemul_do_pio(src_port, reps, bytes_per_rep, gpa, IOREQ_READ,
!!(ctxt->regs->eflags & X86_EFLAGS_DF), 1, NULL);
}
if ( rc != X86EMUL_OKAY )
return rc;
- return hvmemul_do_pio(dst_port, *reps, bytes_per_rep, gpa, IOREQ_WRITE,
+ return hvmemul_do_pio(dst_port, reps, bytes_per_rep, gpa, IOREQ_WRITE,
!!(ctxt->regs->eflags & X86_EFLAGS_DF), 1, NULL);
}
(void)gfn_to_mfn_current(sgpa >> PAGE_SHIFT, &p2mt);
if ( !p2m_is_ram(p2mt) )
return hvmemul_do_mmio(
- sgpa, *reps, bytes_per_rep, dgpa, IOREQ_READ,
+ sgpa, reps, bytes_per_rep, dgpa, IOREQ_READ,
!!(ctxt->regs->eflags & X86_EFLAGS_DF), 1, NULL);
(void)gfn_to_mfn_current(dgpa >> PAGE_SHIFT, &p2mt);
if ( p2m_is_ram(p2mt) )
return X86EMUL_UNHANDLEABLE;
return hvmemul_do_mmio(
- dgpa, *reps, bytes_per_rep, sgpa, IOREQ_WRITE,
+ dgpa, reps, bytes_per_rep, sgpa, IOREQ_WRITE,
!!(ctxt->regs->eflags & X86_EFLAGS_DF), 1, NULL);
}
unsigned long *val,
struct x86_emulate_ctxt *ctxt)
{
- return hvmemul_do_pio(port, 1, bytes, 0, IOREQ_READ, 0, 0, val);
+ unsigned long reps = 1;
+ return hvmemul_do_pio(port, &reps, bytes, 0, IOREQ_READ, 0, 0, val);
}
static int hvmemul_write_io(
unsigned long val,
struct x86_emulate_ctxt *ctxt)
{
- return hvmemul_do_pio(port, 1, bytes, val, IOREQ_WRITE, 0, 0, NULL);
+ unsigned long reps = 1;
+ return hvmemul_do_pio(port, &reps, bytes, val, IOREQ_WRITE, 0, 0, NULL);
}
static int hvmemul_read_cr(
return h->hpet.mc64;
}
-static unsigned long hpet_read(
- struct vcpu *v, unsigned long addr, unsigned long length)
+static int hpet_read(
+ struct vcpu *v, unsigned long addr, unsigned long length,
+ unsigned long *pval)
{
HPETState *h = &v->domain->arch.hvm_domain.pl_time.vhpet;
unsigned long result;
addr &= HPET_MMAP_SIZE-1;
if ( hpet_check_access_length(addr, length) != 0 )
- return ~0UL;
+ {
+ result = ~0ul;
+ goto out;
+ }
spin_lock(&h->lock);
spin_unlock(&h->lock);
- return result;
+ out:
+ *pval = result;
+ return X86EMUL_OKAY;
}
static void hpet_stop_timer(HPETState *h, unsigned int tn)
return new;
}
-static void hpet_write(
+static int hpet_write(
struct vcpu *v, unsigned long addr,
unsigned long length, unsigned long val)
{
addr &= HPET_MMAP_SIZE-1;
if ( hpet_check_access_length(addr, length) != 0 )
- return;
+ goto out;
spin_lock(&h->lock);
}
spin_unlock(&h->lock);
+
+ out:
+ return X86EMUL_OKAY;
}
static int hpet_range(struct vcpu *v, unsigned long addr)
}
spin_unlock(&hd->pbuf_lock);
- return 1;
+ return X86EMUL_OKAY;
}
int hvm_domain_initialise(struct domain *d)
if ( bytes != 1 )
{
gdprintk(XENLOG_WARNING, "PIT bad access\n");
- return 1;
+ return X86EMUL_OKAY;
}
if ( dir == IOREQ_WRITE )
gdprintk(XENLOG_WARNING, "PIT: read A1:A0=3!\n");
}
- return 1;
+ return X86EMUL_OKAY;
}
static void speaker_ioport_write(
{
struct PITState *vpit = vcpu_vpit(current);
- if ( bytes != 1 )
- {
- gdprintk(XENLOG_WARNING, "PIT_SPEAKER bad access\n");
- return 1;
- }
+ BUG_ON(bytes != 1);
spin_lock(&vpit->lock);
spin_unlock(&vpit->lock);
- return 1;
+ return X86EMUL_OKAY;
}
int pv_pit_handler(int port, int data, int write)
&vioapic_mmio_handler
};
-static inline void hvm_mmio_access(struct vcpu *v,
- ioreq_t *p,
- hvm_mmio_read_t read_handler,
- hvm_mmio_write_t write_handler)
+static int hvm_mmio_access(struct vcpu *v,
+ ioreq_t *p,
+ hvm_mmio_read_t read_handler,
+ hvm_mmio_write_t write_handler)
{
unsigned long data;
+ int rc = X86EMUL_OKAY, i, sign = p->df ? -1 : 1;
if ( !p->data_is_ptr )
{
if ( p->dir == IOREQ_READ )
- p->data = read_handler(v, p->addr, p->size);
- else /* p->dir == IOREQ_WRITE */
- write_handler(v, p->addr, p->size, p->data);
+ {
+ rc = read_handler(v, p->addr, p->size, &data);
+ p->data = data;
+ }
+ else /* p->dir == IOREQ_WRITE */
+ rc = write_handler(v, p->addr, p->size, p->data);
+ return rc;
}
- else
- {
- int i, sign = (p->df) ? -1 : 1;
- if ( p->dir == IOREQ_READ )
+ if ( p->dir == IOREQ_READ )
+ {
+ for ( i = 0; i < p->count; i++ )
{
- for ( i = 0; i < p->count; i++ )
- {
- data = read_handler(
- v,
- p->addr + (sign * i * p->size),
- p->size);
- (void)hvm_copy_to_guest_phys(
- p->data + (sign * i * p->size),
- &data,
- p->size);
- }
+ rc = read_handler(
+ v,
+ p->addr + (sign * i * p->size),
+ p->size, &data);
+ if ( rc != X86EMUL_OKAY )
+ break;
+ (void)hvm_copy_to_guest_phys(
+ p->data + (sign * i * p->size),
+ &data,
+ p->size);
}
- else
+ }
+ else
+ {
+ for ( i = 0; i < p->count; i++ )
{
- for ( i = 0; i < p->count; i++ )
- {
- (void)hvm_copy_from_guest_phys(
- &data,
- p->data + (sign * i * p->size),
- p->size);
- write_handler(
- v,
- p->addr + (sign * i * p->size),
- p->size, data);
- }
+ (void)hvm_copy_from_guest_phys(
+ &data,
+ p->data + (sign * i * p->size),
+ p->size);
+ rc = write_handler(
+ v,
+ p->addr + (sign * i * p->size),
+ p->size, data);
+ if ( rc != X86EMUL_OKAY )
+ break;
}
}
+
+ if ( (p->count = i) != 0 )
+ rc = X86EMUL_OKAY;
+
+ return rc;
}
int hvm_mmio_intercept(ioreq_t *p)
int i;
for ( i = 0; i < HVM_MMIO_HANDLER_NR; i++ )
- {
if ( hvm_mmio_handlers[i]->check_handler(v, p->addr) )
- {
- hvm_mmio_access(v, p,
- hvm_mmio_handlers[i]->read_handler,
- hvm_mmio_handlers[i]->write_handler);
- return 1;
- }
- }
+ return hvm_mmio_access(
+ v, p,
+ hvm_mmio_handlers[i]->read_handler,
+ hvm_mmio_handlers[i]->write_handler);
- return 0;
+ return X86EMUL_UNHANDLEABLE;
}
static int process_portio_intercept(portio_action_t action, ioreq_t *p)
{
- int rc = 1, i, sign = p->df ? -1 : 1;
+ int rc = X86EMUL_OKAY, i, sign = p->df ? -1 : 1;
uint32_t data;
- if ( p->dir == IOREQ_READ )
+ if ( !p->data_is_ptr )
{
- if ( !p->data_is_ptr )
+ if ( p->dir == IOREQ_READ )
{
rc = action(IOREQ_READ, p->addr, p->size, &data);
p->data = data;
}
else
{
- for ( i = 0; i < p->count; i++ )
- {
- rc = action(IOREQ_READ, p->addr, p->size, &data);
- (void)hvm_copy_to_guest_phys(p->data + sign*i*p->size,
- &data, p->size);
- }
+ data = p->data;
+ rc = action(IOREQ_WRITE, p->addr, p->size, &data);
}
+ return rc;
}
- else /* p->dir == IOREQ_WRITE */
+
+ if ( p->dir == IOREQ_READ )
{
- if ( !p->data_is_ptr )
+ for ( i = 0; i < p->count; i++ )
{
- data = p->data;
- rc = action(IOREQ_WRITE, p->addr, p->size, &data);
+ rc = action(IOREQ_READ, p->addr, p->size, &data);
+ if ( rc != X86EMUL_OKAY )
+ break;
+ (void)hvm_copy_to_guest_phys(p->data + sign*i*p->size,
+ &data, p->size);
}
- else
+ }
+ else /* p->dir == IOREQ_WRITE */
+ {
+ for ( i = 0; i < p->count; i++ )
{
- for ( i = 0; i < p->count; i++ )
- {
- data = 0;
- (void)hvm_copy_from_guest_phys(&data, p->data + sign*i*p->size,
- p->size);
- rc = action(IOREQ_WRITE, p->addr, p->size, &data);
- }
+ data = 0;
+ (void)hvm_copy_from_guest_phys(&data, p->data + sign*i*p->size,
+ p->size);
+ rc = action(IOREQ_WRITE, p->addr, p->size, &data);
+ if ( rc != X86EMUL_OKAY )
+ break;
}
}
+ if ( (p->count = i) != 0 )
+ rc = X86EMUL_OKAY;
+
return rc;
}
unsigned long addr, size;
if ( (type == HVM_PORTIO) && (dpci_ioport_intercept(p)) )
- return 1;
+ return X86EMUL_OKAY;
for ( i = 0; i < handler->num_slot; i++ )
{
}
}
- return 0;
+ return X86EMUL_UNHANDLEABLE;
}
-int register_io_handler(
+void register_io_handler(
struct domain *d, unsigned long addr, unsigned long size,
void *action, int type)
{
else
handler->hdl_list[num].action.mmio = action;
handler->num_slot++;
-
- return 1;
}
+
/*
* Local variables:
* mode: C
void dpci_ioport_read(uint32_t mport, ioreq_t *p)
{
- uint64_t i;
- uint64_t z_data;
- uint64_t length = (p->count * p->size);
+ int i, sign = p->df ? -1 : 1;
+ uint32_t data = 0;
- for ( i = 0; i < length; i += p->size )
+ for ( i = 0; i < p->count; i++ )
{
- z_data = ~0ULL;
-
switch ( p->size )
{
case 1:
- z_data = (uint64_t)inb(mport);
+ data = inb(mport);
break;
case 2:
- z_data = (uint64_t)inw(mport);
+ data = inw(mport);
break;
case 4:
- z_data = (uint64_t)inl(mport);
+ data = inl(mport);
break;
default:
- gdprintk(XENLOG_ERR, "Error: unable to handle size: %"
- PRId64 "\n", p->size);
- return;
+ BUG();
}
- p->data = z_data;
- if ( p->data_is_ptr &&
- hvm_copy_to_guest_phys(p->data + i, (void *)&z_data,
- (int)p->size) )
- {
- gdprintk(XENLOG_ERR, "Error: couldn't copy to hvm phys\n");
- return;
- }
+ if ( p->data_is_ptr )
+ (void)hvm_copy_to_guest_phys(
+ p->data + (sign * i * p->size), &data, p->size);
+ else
+ p->data = data;
}
}
void dpci_ioport_write(uint32_t mport, ioreq_t *p)
{
- uint64_t i;
- uint64_t z_data = 0;
- uint64_t length = (p->count * p->size);
+ int i, sign = p->df ? -1 : 1;
+ uint32_t data;
- for ( i = 0; i < length; i += p->size )
+ for ( i = 0; i < p->count; i++ )
{
- z_data = p->data;
- if ( p->data_is_ptr &&
- hvm_copy_from_guest_phys((void *)&z_data,
- p->data + i, (int)p->size) )
- {
- gdprintk(XENLOG_ERR, "Error: couldn't copy from hvm phys\n");
- return;
- }
+ data = p->data;
+ if ( p->data_is_ptr )
+ (void)hvm_copy_from_guest_phys(
+ &data, p->data + (sign * i & p->size), p->size);
switch ( p->size )
{
case 1:
- outb((uint8_t) z_data, mport);
+ outb(data, mport);
break;
case 2:
- outw((uint16_t) z_data, mport);
+ outw(data, mport);
break;
case 4:
- outl((uint32_t) z_data, mport);
+ outl(data, mport);
break;
default:
- gdprintk(XENLOG_ERR, "Error: unable to handle size: %"
- PRId64 "\n", p->size);
- break;
+ BUG();
}
}
}
spin_unlock(&s->lock);
- return 1;
+ return X86EMUL_OKAY;
}
if ( bytes != 4 )
{
gdprintk(XENLOG_WARNING, "HVM_PMT bad access\n");
- return 1;
+ return X86EMUL_OKAY;
}
if ( dir == IOREQ_READ )
pmt_update_time(s);
*val = s->pm.tmr_val;
spin_unlock(&s->lock);
- return 1;
+ return X86EMUL_OKAY;
}
- return 0;
+ return X86EMUL_UNHANDLEABLE;
}
static int pmtimer_save(struct domain *d, hvm_domain_context_t *h)
if ( bytes != 1 )
{
gdprintk(XENLOG_WARNING, "HVM_RTC bas access\n");
- return 1;
+ return X86EMUL_OKAY;
}
if ( dir == IOREQ_WRITE )
{
if ( rtc_ioport_write(vrtc, port, (uint8_t)*val) )
- return 1;
+ return X86EMUL_OKAY;
}
else if ( vrtc->hw.cmos_index < RTC_CMOS_SIZE )
{
*val = rtc_ioport_read(vrtc, port);
- return 1;
+ return X86EMUL_OKAY;
}
- return 0;
+ return X86EMUL_UNHANDLEABLE;
}
void rtc_migrate_timers(struct vcpu *v)
}
}
-int stdvga_intercept_pio(
+static int stdvga_intercept_pio(
int dir, uint32_t port, uint32_t bytes, uint32_t *val)
{
struct hvm_hw_stdvga *s = ¤t->domain->arch.hvm_domain.stdvga;
- if ( dir == IOREQ_READ )
- return 0;
-
- spin_lock(&s->lock);
- stdvga_out(port, bytes, *val);
- spin_unlock(&s->lock);
+ if ( dir == IOREQ_WRITE )
+ {
+ spin_lock(&s->lock);
+ stdvga_out(port, bytes, *val);
+ spin_unlock(&s->lock);
+ }
- return 0; /* propagate to external ioemu */
+ return X86EMUL_UNHANDLEABLE; /* propagate to external ioemu */
}
#define GET_PLANE(data, p) (((data) >> ((p) * 8)) & 0xff)
return 1;
}
-int stdvga_intercept_mmio(ioreq_t *p)
+static int stdvga_intercept_mmio(ioreq_t *p)
{
struct domain *d = current->domain;
struct hvm_hw_stdvga *s = &d->arch.hvm_domain.stdvga;
if ( p->size > 8 )
{
gdprintk(XENLOG_WARNING, "invalid mmio size %d\n", (int)p->size);
- return 0;
+ return X86EMUL_UNHANDLEABLE;
}
spin_lock(&s->lock);
spin_unlock(&s->lock);
- return rc;
+ return rc ? X86EMUL_OKAY : X86EMUL_UNHANDLEABLE;
}
void stdvga_init(struct domain *d)
return result;
}
-static unsigned long vioapic_read(struct vcpu *v,
- unsigned long addr,
- unsigned long length)
+static int vioapic_read(
+ struct vcpu *v, unsigned long addr,
+ unsigned long length, unsigned long *pval)
{
struct hvm_hw_vioapic *vioapic = domain_vioapic(v->domain);
uint32_t result;
break;
}
- return result;
+ *pval = result;
+ return X86EMUL_OKAY;
}
static void vioapic_write_redirent(
- struct hvm_hw_vioapic *vioapic, unsigned int idx, int top_word, uint32_t val)
+ struct hvm_hw_vioapic *vioapic, unsigned int idx,
+ int top_word, uint32_t val)
{
struct domain *d = vioapic_domain(vioapic);
struct hvm_irq *hvm_irq = &d->arch.hvm_domain.irq;
}
}
-static void vioapic_write(struct vcpu *v,
- unsigned long addr,
- unsigned long length,
- unsigned long val)
+static int vioapic_write(
+ struct vcpu *v, unsigned long addr,
+ unsigned long length, unsigned long val)
{
struct hvm_hw_vioapic *vioapic = domain_vioapic(v->domain);
default:
break;
}
+
+ return X86EMUL_OKAY;
}
static int vioapic_range(struct vcpu *v, unsigned long addr)
}
}
-static unsigned long vlapic_read(struct vcpu *v, unsigned long address,
- unsigned long len)
+static int vlapic_read(
+ struct vcpu *v, unsigned long address,
+ unsigned long len, unsigned long *pval)
{
unsigned int alignment;
unsigned int tmp;
- unsigned long result;
+ unsigned long result = 0;
struct vlapic *vlapic = vcpu_vlapic(v);
unsigned int offset = address - vlapic_base_address(vlapic);
if ( offset > (APIC_TDCR + 0x3) )
- return 0;
+ goto out;
alignment = offset & 0x3;
HVM_DBG_LOG(DBG_LEVEL_VLAPIC, "offset 0x%x with length 0x%lx, "
"and the result is 0x%lx", offset, len, result);
- return result;
+ out:
+ *pval = result;
+ return X86EMUL_OKAY;
unaligned_exit_and_crash:
gdprintk(XENLOG_ERR, "Unaligned LAPIC read len=0x%lx at offset=0x%x.\n",
len, offset);
exit_and_crash:
domain_crash(v->domain);
- return 0;
+ return X86EMUL_OKAY;
}
void vlapic_pt_cb(struct vcpu *v, void *data)
*(s_time_t *)data = hvm_get_guest_time(v);
}
-static void vlapic_write(struct vcpu *v, unsigned long address,
- unsigned long len, unsigned long val)
+static int vlapic_write(struct vcpu *v, unsigned long address,
+ unsigned long len, unsigned long val)
{
struct vlapic *vlapic = vcpu_vlapic(v);
unsigned int offset = address - vlapic_base_address(vlapic);
val = (uint32_t)val;
if ( len != 4 )
{
- unsigned int tmp;
+ unsigned long tmp;
unsigned char alignment;
gdprintk(XENLOG_INFO, "Notice: Local APIC write with len = %lx\n",len);
alignment = offset & 0x3;
- tmp = vlapic_read(v, offset & ~0x3, 4);
+ (void)vlapic_read(v, offset & ~0x3, 4, &tmp);
switch ( len )
{
break;
}
- return;
+ return X86EMUL_OKAY;
unaligned_exit_and_crash:
gdprintk(XENLOG_ERR, "Unaligned LAPIC write len=0x%lx at offset=0x%x.\n",
len, offset);
exit_and_crash:
domain_crash(v->domain);
+ return X86EMUL_OKAY;
}
static int vlapic_range(struct vcpu *v, unsigned long addr)
if ( bytes != 1 )
{
gdprintk(XENLOG_WARNING, "PIC_IO bad access size %d\n", bytes);
- return 1;
+ return X86EMUL_OKAY;
}
vpic = ¤t->domain->arch.hvm_domain.vpic[port >> 7];
else
*val = (uint8_t)vpic_ioport_read(vpic, port);
- return 1;
+ return X86EMUL_OKAY;
}
static int vpic_intercept_elcr_io(
struct hvm_hw_vpic *vpic;
uint32_t data;
- if ( bytes != 1 )
- {
- gdprintk(XENLOG_WARNING, "PIC_IO bad access size %d\n", bytes);
- return 1;
- }
+ BUG_ON(bytes != 1);
vpic = ¤t->domain->arch.hvm_domain.vpic[port & 1];
*val = vpic->elcr & vpic_elcr_mask(vpic);
}
- return 1;
+ return X86EMUL_OKAY;
}
static int vpic_save(struct domain *d, hvm_domain_context_t *h)
#define HVM_PORTIO 0
#define HVM_BUFFERED_IO 2
-typedef unsigned long (*hvm_mmio_read_t)(struct vcpu *v,
- unsigned long addr,
- unsigned long length);
-typedef void (*hvm_mmio_write_t)(struct vcpu *v,
+typedef int (*hvm_mmio_read_t)(struct vcpu *v,
unsigned long addr,
unsigned long length,
- unsigned long val);
+ unsigned long *val);
+typedef int (*hvm_mmio_write_t)(struct vcpu *v,
+ unsigned long addr,
+ unsigned long length,
+ unsigned long val);
typedef int (*hvm_mmio_check_t)(struct vcpu *v, unsigned long addr);
typedef int (*portio_action_t)(
};
int hvm_io_intercept(ioreq_t *p, int type);
-int register_io_handler(
+void register_io_handler(
struct domain *d, unsigned long addr, unsigned long size,
void *action, int type);
int hvm_mmio_intercept(ioreq_t *p);
int hvm_buffered_io_send(ioreq_t *p);
-static inline int register_portio_handler(
+static inline void register_portio_handler(
struct domain *d, unsigned long addr,
unsigned long size, portio_action_t action)
{
- return register_io_handler(d, addr, size, action, HVM_PORTIO);
+ register_io_handler(d, addr, size, action, HVM_PORTIO);
}
-static inline int register_buffered_io_handler(
+static inline void register_buffered_io_handler(
struct domain *d, unsigned long addr,
unsigned long size, mmio_action_t action)
{
- return register_io_handler(d, addr, size, action, HVM_BUFFERED_IO);
+ register_io_handler(d, addr, size, action, HVM_BUFFERED_IO);
}
void send_timeoffset_req(unsigned long timeoff);
projects / xen.git / commitdiff