2021-02-07 11:10:28 +08:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
|
|
|
|
/*
|
|
|
|
|
* Userspace interface for /dev/acrn_hsm - ACRN Hypervisor Service Module
|
|
|
|
|
*
|
|
|
|
|
* This file can be used by applications that need to communicate with the HSM
|
|
|
|
|
* via the ioctl interface.
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2021 Intel Corporation. All rights reserved.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef _UAPI_ACRN_H
|
|
|
|
|
#define _UAPI_ACRN_H
|
|
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
|
#include <linux/uuid.h>
|
|
|
|
|
|
virt: acrn: Introduce I/O request management
An I/O request of a User VM, which is constructed by the hypervisor, is
distributed by the ACRN Hypervisor Service Module to an I/O client
corresponding to the address range of the I/O request.
For each User VM, there is a shared 4-KByte memory region used for I/O
requests communication between the hypervisor and Service VM. An I/O
request is a 256-byte structure buffer, which is 'struct
acrn_io_request', that is filled by an I/O handler of the hypervisor
when a trapped I/O access happens in a User VM. ACRN userspace in the
Service VM first allocates a 4-KByte page and passes the GPA (Guest
Physical Address) of the buffer to the hypervisor. The buffer is used as
an array of 16 I/O request slots with each I/O request slot being 256
bytes. This array is indexed by vCPU ID.
An I/O client, which is 'struct acrn_ioreq_client', is responsible for
handling User VM I/O requests whose accessed GPA falls in a certain
range. Multiple I/O clients can be associated with each User VM. There
is a special client associated with each User VM, called the default
client, that handles all I/O requests that do not fit into the range of
any other I/O clients. The ACRN userspace acts as the default client for
each User VM.
The state transitions of a ACRN I/O request are as follows.
FREE -> PENDING -> PROCESSING -> COMPLETE -> FREE -> ...
FREE: this I/O request slot is empty
PENDING: a valid I/O request is pending in this slot
PROCESSING: the I/O request is being processed
COMPLETE: the I/O request has been processed
An I/O request in COMPLETE or FREE state is owned by the hypervisor. HSM
and ACRN userspace are in charge of processing the others.
The processing flow of I/O requests are listed as following:
a) The I/O handler of the hypervisor will fill an I/O request with
PENDING state when a trapped I/O access happens in a User VM.
b) The hypervisor makes an upcall, which is a notification interrupt, to
the Service VM.
c) The upcall handler schedules a worker to dispatch I/O requests.
d) The worker looks for the PENDING I/O requests, assigns them to
different registered clients based on the address of the I/O accesses,
updates their state to PROCESSING, and notifies the corresponding
client to handle.
e) The notified client handles the assigned I/O requests.
f) The HSM updates I/O requests states to COMPLETE and notifies the
hypervisor of the completion via hypercalls.
Cc: Davidlohr Bueso <dave@stgolabs.net>
Cc: Zhi Wang <zhi.a.wang@intel.com>
Cc: Zhenyu Wang <zhenyuw@linux.intel.com>
Cc: Yu Wang <yu1.wang@intel.com>
Cc: Reinette Chatre <reinette.chatre@intel.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Zhi Wang <zhi.a.wang@intel.com>
Reviewed-by: Reinette Chatre <reinette.chatre@intel.com>
Acked-by: Davidlohr Bueso <dbueso@suse.de>
Signed-off-by: Shuo Liu <shuo.a.liu@intel.com>
Link: https://lore.kernel.org/r/20210207031040.49576-10-shuo.a.liu@intel.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2021-02-07 11:10:31 +08:00
|
|
|
#define ACRN_IO_REQUEST_MAX 16
|
|
|
|
|
|
|
|
|
|
#define ACRN_IOREQ_STATE_PENDING 0
|
|
|
|
|
#define ACRN_IOREQ_STATE_COMPLETE 1
|
|
|
|
|
#define ACRN_IOREQ_STATE_PROCESSING 2
|
|
|
|
|
#define ACRN_IOREQ_STATE_FREE 3
|
|
|
|
|
|
|
|
|
|
#define ACRN_IOREQ_TYPE_PORTIO 0
|
|
|
|
|
#define ACRN_IOREQ_TYPE_MMIO 1
|
|
|
|
|
|
|
|
|
|
#define ACRN_IOREQ_DIR_READ 0
|
|
|
|
|
#define ACRN_IOREQ_DIR_WRITE 1
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* struct acrn_mmio_request - Info of a MMIO I/O request
|
|
|
|
|
* @direction: Access direction of this request (ACRN_IOREQ_DIR_*)
|
|
|
|
|
* @reserved: Reserved for alignment and should be 0
|
|
|
|
|
* @address: Access address of this MMIO I/O request
|
|
|
|
|
* @size: Access size of this MMIO I/O request
|
|
|
|
|
* @value: Read/write value of this MMIO I/O request
|
|
|
|
|
*/
|
|
|
|
|
struct acrn_mmio_request {
|
|
|
|
|
__u32 direction;
|
|
|
|
|
__u32 reserved;
|
|
|
|
|
__u64 address;
|
|
|
|
|
__u64 size;
|
|
|
|
|
__u64 value;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* struct acrn_pio_request - Info of a PIO I/O request
|
|
|
|
|
* @direction: Access direction of this request (ACRN_IOREQ_DIR_*)
|
|
|
|
|
* @reserved: Reserved for alignment and should be 0
|
|
|
|
|
* @address: Access address of this PIO I/O request
|
|
|
|
|
* @size: Access size of this PIO I/O request
|
|
|
|
|
* @value: Read/write value of this PIO I/O request
|
|
|
|
|
*/
|
|
|
|
|
struct acrn_pio_request {
|
|
|
|
|
__u32 direction;
|
|
|
|
|
__u32 reserved;
|
|
|
|
|
__u64 address;
|
|
|
|
|
__u64 size;
|
|
|
|
|
__u32 value;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* struct acrn_io_request - 256-byte ACRN I/O request
|
|
|
|
|
* @type: Type of this request (ACRN_IOREQ_TYPE_*).
|
|
|
|
|
* @completion_polling: Polling flag. Hypervisor will poll completion of the
|
|
|
|
|
* I/O request if this flag set.
|
|
|
|
|
* @reserved0: Reserved fields.
|
|
|
|
|
* @reqs: Union of different types of request. Byte offset: 64.
|
|
|
|
|
* @reqs.pio_request: PIO request data of the I/O request.
|
|
|
|
|
* @reqs.mmio_request: MMIO request data of the I/O request.
|
|
|
|
|
* @reqs.data: Raw data of the I/O request.
|
|
|
|
|
* @reserved1: Reserved fields.
|
|
|
|
|
* @kernel_handled: Flag indicates this request need be handled in kernel.
|
|
|
|
|
* @processed: The status of this request (ACRN_IOREQ_STATE_*).
|
|
|
|
|
*
|
|
|
|
|
* The state transitions of ACRN I/O request:
|
|
|
|
|
*
|
|
|
|
|
* FREE -> PENDING -> PROCESSING -> COMPLETE -> FREE -> ...
|
|
|
|
|
*
|
|
|
|
|
* An I/O request in COMPLETE or FREE state is owned by the hypervisor. HSM and
|
|
|
|
|
* ACRN userspace are in charge of processing the others.
|
|
|
|
|
*
|
|
|
|
|
* On basis of the states illustrated above, a typical lifecycle of ACRN IO
|
|
|
|
|
* request would look like:
|
|
|
|
|
*
|
|
|
|
|
* Flow (assume the initial state is FREE)
|
|
|
|
|
* |
|
|
|
|
|
* | Service VM vCPU 0 Service VM vCPU x User vCPU y
|
|
|
|
|
* |
|
|
|
|
|
* | hypervisor:
|
|
|
|
|
* | fills in type, addr, etc.
|
|
|
|
|
* | pauses the User VM vCPU y
|
|
|
|
|
* | sets the state to PENDING (a)
|
|
|
|
|
* | fires an upcall to Service VM
|
|
|
|
|
* |
|
|
|
|
|
* | HSM:
|
|
|
|
|
* | scans for PENDING requests
|
|
|
|
|
* | sets the states to PROCESSING (b)
|
|
|
|
|
* | assigns the requests to clients (c)
|
|
|
|
|
* V
|
|
|
|
|
* | client:
|
|
|
|
|
* | scans for the assigned requests
|
|
|
|
|
* | handles the requests (d)
|
|
|
|
|
* | HSM:
|
|
|
|
|
* | sets states to COMPLETE
|
|
|
|
|
* | notifies the hypervisor
|
|
|
|
|
* |
|
|
|
|
|
* | hypervisor:
|
|
|
|
|
* | resumes User VM vCPU y (e)
|
|
|
|
|
* |
|
|
|
|
|
* | hypervisor:
|
|
|
|
|
* | post handling (f)
|
|
|
|
|
* V sets states to FREE
|
|
|
|
|
*
|
|
|
|
|
* Note that the procedures (a) to (f) in the illustration above require to be
|
|
|
|
|
* strictly processed in the order. One vCPU cannot trigger another request of
|
|
|
|
|
* I/O emulation before completing the previous one.
|
|
|
|
|
*
|
|
|
|
|
* Atomic and barriers are required when HSM and hypervisor accessing the state
|
|
|
|
|
* of &struct acrn_io_request.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
struct acrn_io_request {
|
|
|
|
|
__u32 type;
|
|
|
|
|
__u32 completion_polling;
|
|
|
|
|
__u32 reserved0[14];
|
|
|
|
|
union {
|
|
|
|
|
struct acrn_pio_request pio_request;
|
|
|
|
|
struct acrn_mmio_request mmio_request;
|
|
|
|
|
__u64 data[8];
|
|
|
|
|
} reqs;
|
|
|
|
|
__u32 reserved1;
|
|
|
|
|
__u32 kernel_handled;
|
|
|
|
|
__u32 processed;
|
|
|
|
|
} __attribute__((aligned(256)));
|
|
|
|
|
|
|
|
|
|
struct acrn_io_request_buffer {
|
|
|
|
|
union {
|
|
|
|
|
struct acrn_io_request req_slot[ACRN_IO_REQUEST_MAX];
|
|
|
|
|
__u8 reserved[4096];
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* struct acrn_ioreq_notify - The structure of ioreq completion notification
|
|
|
|
|
* @vmid: User VM ID
|
|
|
|
|
* @reserved: Reserved and should be 0
|
|
|
|
|
* @vcpu: vCPU ID
|
|
|
|
|
*/
|
|
|
|
|
struct acrn_ioreq_notify {
|
|
|
|
|
__u16 vmid;
|
|
|
|
|
__u16 reserved;
|
|
|
|
|
__u32 vcpu;
|
|
|
|
|
};
|
|
|
|
|
|
2021-02-07 11:10:28 +08:00
|
|
|
/**
|
|
|
|
|
* struct acrn_vm_creation - Info to create a User VM
|
|
|
|
|
* @vmid: User VM ID returned from the hypervisor
|
|
|
|
|
* @reserved0: Reserved and must be 0
|
|
|
|
|
* @vcpu_num: Number of vCPU in the VM. Return from hypervisor.
|
|
|
|
|
* @reserved1: Reserved and must be 0
|
|
|
|
|
* @uuid: UUID of the VM. Pass to hypervisor directly.
|
|
|
|
|
* @vm_flag: Flag of the VM creating. Pass to hypervisor directly.
|
|
|
|
|
* @ioreq_buf: Service VM GPA of I/O request buffer. Pass to
|
|
|
|
|
* hypervisor directly.
|
|
|
|
|
* @cpu_affinity: CPU affinity of the VM. Pass to hypervisor directly.
|
|
|
|
|
* It's a bitmap which indicates CPUs used by the VM.
|
|
|
|
|
*/
|
|
|
|
|
struct acrn_vm_creation {
|
|
|
|
|
__u16 vmid;
|
|
|
|
|
__u16 reserved0;
|
|
|
|
|
__u16 vcpu_num;
|
|
|
|
|
__u16 reserved1;
|
|
|
|
|
guid_t uuid;
|
|
|
|
|
__u64 vm_flag;
|
|
|
|
|
__u64 ioreq_buf;
|
|
|
|
|
__u64 cpu_affinity;
|
|
|
|
|
};
|
|
|
|
|
|
2021-02-07 11:10:29 +08:00
|
|
|
/**
|
|
|
|
|
* struct acrn_gp_regs - General registers of a User VM
|
|
|
|
|
* @rax: Value of register RAX
|
|
|
|
|
* @rcx: Value of register RCX
|
|
|
|
|
* @rdx: Value of register RDX
|
|
|
|
|
* @rbx: Value of register RBX
|
|
|
|
|
* @rsp: Value of register RSP
|
|
|
|
|
* @rbp: Value of register RBP
|
|
|
|
|
* @rsi: Value of register RSI
|
|
|
|
|
* @rdi: Value of register RDI
|
|
|
|
|
* @r8: Value of register R8
|
|
|
|
|
* @r9: Value of register R9
|
|
|
|
|
* @r10: Value of register R10
|
|
|
|
|
* @r11: Value of register R11
|
|
|
|
|
* @r12: Value of register R12
|
|
|
|
|
* @r13: Value of register R13
|
|
|
|
|
* @r14: Value of register R14
|
|
|
|
|
* @r15: Value of register R15
|
|
|
|
|
*/
|
|
|
|
|
struct acrn_gp_regs {
|
|
|
|
|
__le64 rax;
|
|
|
|
|
__le64 rcx;
|
|
|
|
|
__le64 rdx;
|
|
|
|
|
__le64 rbx;
|
|
|
|
|
__le64 rsp;
|
|
|
|
|
__le64 rbp;
|
|
|
|
|
__le64 rsi;
|
|
|
|
|
__le64 rdi;
|
|
|
|
|
__le64 r8;
|
|
|
|
|
__le64 r9;
|
|
|
|
|
__le64 r10;
|
|
|
|
|
__le64 r11;
|
|
|
|
|
__le64 r12;
|
|
|
|
|
__le64 r13;
|
|
|
|
|
__le64 r14;
|
|
|
|
|
__le64 r15;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* struct acrn_descriptor_ptr - Segment descriptor table of a User VM.
|
|
|
|
|
* @limit: Limit field.
|
|
|
|
|
* @base: Base field.
|
|
|
|
|
* @reserved: Reserved and must be 0.
|
|
|
|
|
*/
|
|
|
|
|
struct acrn_descriptor_ptr {
|
|
|
|
|
__le16 limit;
|
|
|
|
|
__le64 base;
|
|
|
|
|
__le16 reserved[3];
|
|
|
|
|
} __attribute__ ((__packed__));
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* struct acrn_regs - Registers structure of a User VM
|
|
|
|
|
* @gprs: General registers
|
|
|
|
|
* @gdt: Global Descriptor Table
|
|
|
|
|
* @idt: Interrupt Descriptor Table
|
|
|
|
|
* @rip: Value of register RIP
|
|
|
|
|
* @cs_base: Base of code segment selector
|
|
|
|
|
* @cr0: Value of register CR0
|
|
|
|
|
* @cr4: Value of register CR4
|
|
|
|
|
* @cr3: Value of register CR3
|
|
|
|
|
* @ia32_efer: Value of IA32_EFER MSR
|
|
|
|
|
* @rflags: Value of regsiter RFLAGS
|
|
|
|
|
* @reserved_64: Reserved and must be 0
|
|
|
|
|
* @cs_ar: Attribute field of code segment selector
|
|
|
|
|
* @cs_limit: Limit field of code segment selector
|
|
|
|
|
* @reserved_32: Reserved and must be 0
|
|
|
|
|
* @cs_sel: Value of code segment selector
|
|
|
|
|
* @ss_sel: Value of stack segment selector
|
|
|
|
|
* @ds_sel: Value of data segment selector
|
|
|
|
|
* @es_sel: Value of extra segment selector
|
|
|
|
|
* @fs_sel: Value of FS selector
|
|
|
|
|
* @gs_sel: Value of GS selector
|
|
|
|
|
* @ldt_sel: Value of LDT descriptor selector
|
|
|
|
|
* @tr_sel: Value of TSS descriptor selector
|
|
|
|
|
*/
|
|
|
|
|
struct acrn_regs {
|
|
|
|
|
struct acrn_gp_regs gprs;
|
|
|
|
|
struct acrn_descriptor_ptr gdt;
|
|
|
|
|
struct acrn_descriptor_ptr idt;
|
|
|
|
|
|
|
|
|
|
__le64 rip;
|
|
|
|
|
__le64 cs_base;
|
|
|
|
|
__le64 cr0;
|
|
|
|
|
__le64 cr4;
|
|
|
|
|
__le64 cr3;
|
|
|
|
|
__le64 ia32_efer;
|
|
|
|
|
__le64 rflags;
|
|
|
|
|
__le64 reserved_64[4];
|
|
|
|
|
|
|
|
|
|
__le32 cs_ar;
|
|
|
|
|
__le32 cs_limit;
|
|
|
|
|
__le32 reserved_32[3];
|
|
|
|
|
|
|
|
|
|
__le16 cs_sel;
|
|
|
|
|
__le16 ss_sel;
|
|
|
|
|
__le16 ds_sel;
|
|
|
|
|
__le16 es_sel;
|
|
|
|
|
__le16 fs_sel;
|
|
|
|
|
__le16 gs_sel;
|
|
|
|
|
__le16 ldt_sel;
|
|
|
|
|
__le16 tr_sel;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* struct acrn_vcpu_regs - Info of vCPU registers state
|
|
|
|
|
* @vcpu_id: vCPU ID
|
|
|
|
|
* @reserved: Reserved and must be 0
|
|
|
|
|
* @vcpu_regs: vCPU registers state
|
|
|
|
|
*
|
|
|
|
|
* This structure will be passed to hypervisor directly.
|
|
|
|
|
*/
|
|
|
|
|
struct acrn_vcpu_regs {
|
|
|
|
|
__u16 vcpu_id;
|
|
|
|
|
__u16 reserved[3];
|
|
|
|
|
struct acrn_regs vcpu_regs;
|
|
|
|
|
};
|
|
|
|
|
|
2021-02-07 11:10:30 +08:00
|
|
|
#define ACRN_MEM_ACCESS_RIGHT_MASK 0x00000007U
|
|
|
|
|
#define ACRN_MEM_ACCESS_READ 0x00000001U
|
|
|
|
|
#define ACRN_MEM_ACCESS_WRITE 0x00000002U
|
|
|
|
|
#define ACRN_MEM_ACCESS_EXEC 0x00000004U
|
|
|
|
|
#define ACRN_MEM_ACCESS_RWX (ACRN_MEM_ACCESS_READ | \
|
|
|
|
|
ACRN_MEM_ACCESS_WRITE | \
|
|
|
|
|
ACRN_MEM_ACCESS_EXEC)
|
|
|
|
|
|
|
|
|
|
#define ACRN_MEM_TYPE_MASK 0x000007C0U
|
|
|
|
|
#define ACRN_MEM_TYPE_WB 0x00000040U
|
|
|
|
|
#define ACRN_MEM_TYPE_WT 0x00000080U
|
|
|
|
|
#define ACRN_MEM_TYPE_UC 0x00000100U
|
|
|
|
|
#define ACRN_MEM_TYPE_WC 0x00000200U
|
|
|
|
|
#define ACRN_MEM_TYPE_WP 0x00000400U
|
|
|
|
|
|
|
|
|
|
/* Memory mapping types */
|
|
|
|
|
#define ACRN_MEMMAP_RAM 0
|
|
|
|
|
#define ACRN_MEMMAP_MMIO 1
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* struct acrn_vm_memmap - A EPT memory mapping info for a User VM.
|
|
|
|
|
* @type: Type of the memory mapping (ACRM_MEMMAP_*).
|
|
|
|
|
* Pass to hypervisor directly.
|
|
|
|
|
* @attr: Attribute of the memory mapping.
|
|
|
|
|
* Pass to hypervisor directly.
|
|
|
|
|
* @user_vm_pa: Physical address of User VM.
|
|
|
|
|
* Pass to hypervisor directly.
|
|
|
|
|
* @service_vm_pa: Physical address of Service VM.
|
|
|
|
|
* Pass to hypervisor directly.
|
|
|
|
|
* @vma_base: VMA address of Service VM. Pass to hypervisor directly.
|
|
|
|
|
* @len: Length of the memory mapping.
|
|
|
|
|
* Pass to hypervisor directly.
|
|
|
|
|
*/
|
|
|
|
|
struct acrn_vm_memmap {
|
|
|
|
|
__u32 type;
|
|
|
|
|
__u32 attr;
|
|
|
|
|
__u64 user_vm_pa;
|
|
|
|
|
union {
|
|
|
|
|
__u64 service_vm_pa;
|
|
|
|
|
__u64 vma_base;
|
|
|
|
|
};
|
|
|
|
|
__u64 len;
|
|
|
|
|
};
|
|
|
|
|
|
2021-02-07 11:10:28 +08:00
|
|
|
/* The ioctl type, documented in ioctl-number.rst */
|
|
|
|
|
#define ACRN_IOCTL_TYPE 0xA2
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Common IOCTL IDs definition for ACRN userspace
|
|
|
|
|
*/
|
|
|
|
|
#define ACRN_IOCTL_CREATE_VM \
|
|
|
|
|
_IOWR(ACRN_IOCTL_TYPE, 0x10, struct acrn_vm_creation)
|
|
|
|
|
#define ACRN_IOCTL_DESTROY_VM \
|
|
|
|
|
_IO(ACRN_IOCTL_TYPE, 0x11)
|
|
|
|
|
#define ACRN_IOCTL_START_VM \
|
|
|
|
|
_IO(ACRN_IOCTL_TYPE, 0x12)
|
|
|
|
|
#define ACRN_IOCTL_PAUSE_VM \
|
|
|
|
|
_IO(ACRN_IOCTL_TYPE, 0x13)
|
|
|
|
|
#define ACRN_IOCTL_RESET_VM \
|
|
|
|
|
_IO(ACRN_IOCTL_TYPE, 0x15)
|
2021-02-07 11:10:29 +08:00
|
|
|
#define ACRN_IOCTL_SET_VCPU_REGS \
|
|
|
|
|
_IOW(ACRN_IOCTL_TYPE, 0x16, struct acrn_vcpu_regs)
|
2021-02-07 11:10:28 +08:00
|
|
|
|
virt: acrn: Introduce I/O request management
An I/O request of a User VM, which is constructed by the hypervisor, is
distributed by the ACRN Hypervisor Service Module to an I/O client
corresponding to the address range of the I/O request.
For each User VM, there is a shared 4-KByte memory region used for I/O
requests communication between the hypervisor and Service VM. An I/O
request is a 256-byte structure buffer, which is 'struct
acrn_io_request', that is filled by an I/O handler of the hypervisor
when a trapped I/O access happens in a User VM. ACRN userspace in the
Service VM first allocates a 4-KByte page and passes the GPA (Guest
Physical Address) of the buffer to the hypervisor. The buffer is used as
an array of 16 I/O request slots with each I/O request slot being 256
bytes. This array is indexed by vCPU ID.
An I/O client, which is 'struct acrn_ioreq_client', is responsible for
handling User VM I/O requests whose accessed GPA falls in a certain
range. Multiple I/O clients can be associated with each User VM. There
is a special client associated with each User VM, called the default
client, that handles all I/O requests that do not fit into the range of
any other I/O clients. The ACRN userspace acts as the default client for
each User VM.
The state transitions of a ACRN I/O request are as follows.
FREE -> PENDING -> PROCESSING -> COMPLETE -> FREE -> ...
FREE: this I/O request slot is empty
PENDING: a valid I/O request is pending in this slot
PROCESSING: the I/O request is being processed
COMPLETE: the I/O request has been processed
An I/O request in COMPLETE or FREE state is owned by the hypervisor. HSM
and ACRN userspace are in charge of processing the others.
The processing flow of I/O requests are listed as following:
a) The I/O handler of the hypervisor will fill an I/O request with
PENDING state when a trapped I/O access happens in a User VM.
b) The hypervisor makes an upcall, which is a notification interrupt, to
the Service VM.
c) The upcall handler schedules a worker to dispatch I/O requests.
d) The worker looks for the PENDING I/O requests, assigns them to
different registered clients based on the address of the I/O accesses,
updates their state to PROCESSING, and notifies the corresponding
client to handle.
e) The notified client handles the assigned I/O requests.
f) The HSM updates I/O requests states to COMPLETE and notifies the
hypervisor of the completion via hypercalls.
Cc: Davidlohr Bueso <dave@stgolabs.net>
Cc: Zhi Wang <zhi.a.wang@intel.com>
Cc: Zhenyu Wang <zhenyuw@linux.intel.com>
Cc: Yu Wang <yu1.wang@intel.com>
Cc: Reinette Chatre <reinette.chatre@intel.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Zhi Wang <zhi.a.wang@intel.com>
Reviewed-by: Reinette Chatre <reinette.chatre@intel.com>
Acked-by: Davidlohr Bueso <dbueso@suse.de>
Signed-off-by: Shuo Liu <shuo.a.liu@intel.com>
Link: https://lore.kernel.org/r/20210207031040.49576-10-shuo.a.liu@intel.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2021-02-07 11:10:31 +08:00
|
|
|
#define ACRN_IOCTL_NOTIFY_REQUEST_FINISH \
|
|
|
|
|
_IOW(ACRN_IOCTL_TYPE, 0x31, struct acrn_ioreq_notify)
|
|
|
|
|
#define ACRN_IOCTL_CREATE_IOREQ_CLIENT \
|
|
|
|
|
_IO(ACRN_IOCTL_TYPE, 0x32)
|
|
|
|
|
#define ACRN_IOCTL_ATTACH_IOREQ_CLIENT \
|
|
|
|
|
_IO(ACRN_IOCTL_TYPE, 0x33)
|
|
|
|
|
#define ACRN_IOCTL_DESTROY_IOREQ_CLIENT \
|
|
|
|
|
_IO(ACRN_IOCTL_TYPE, 0x34)
|
|
|
|
|
#define ACRN_IOCTL_CLEAR_VM_IOREQ \
|
|
|
|
|
_IO(ACRN_IOCTL_TYPE, 0x35)
|
|
|
|
|
|
2021-02-07 11:10:30 +08:00
|
|
|
#define ACRN_IOCTL_SET_MEMSEG \
|
|
|
|
|
_IOW(ACRN_IOCTL_TYPE, 0x41, struct acrn_vm_memmap)
|
|
|
|
|
#define ACRN_IOCTL_UNSET_MEMSEG \
|
|
|
|
|
_IOW(ACRN_IOCTL_TYPE, 0x42, struct acrn_vm_memmap)
|
|
|
|
|
|
2021-02-07 11:10:28 +08:00
|
|
|
#endif /* _UAPI_ACRN_H */
|