2021-02-07 03:10:27 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
|
|
|
|
|
|
|
#ifndef __ACRN_HSM_DRV_H
|
|
|
|
#define __ACRN_HSM_DRV_H
|
|
|
|
|
2021-02-07 03:10:28 +00:00
|
|
|
#include <linux/acrn.h>
|
|
|
|
#include <linux/dev_printk.h>
|
|
|
|
#include <linux/miscdevice.h>
|
2021-02-07 03:10:27 +00:00
|
|
|
#include <linux/types.h>
|
|
|
|
|
2021-02-07 03:10:28 +00:00
|
|
|
#include "hypercall.h"
|
|
|
|
|
|
|
|
extern struct miscdevice acrn_dev;
|
|
|
|
|
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 03:10:31 +00:00
|
|
|
#define ACRN_NAME_LEN 16
|
2021-02-07 03:10:30 +00:00
|
|
|
#define ACRN_MEM_MAPPING_MAX 256
|
|
|
|
|
|
|
|
#define ACRN_MEM_REGION_ADD 0
|
|
|
|
#define ACRN_MEM_REGION_DEL 2
|
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 03:10:31 +00:00
|
|
|
|
|
|
|
struct acrn_vm;
|
|
|
|
struct acrn_ioreq_client;
|
|
|
|
|
2021-02-07 03:10:30 +00:00
|
|
|
/**
|
|
|
|
* struct vm_memory_region_op - Hypervisor memory operation
|
|
|
|
* @type: Operation type (ACRN_MEM_REGION_*)
|
|
|
|
* @attr: Memory attribute (ACRN_MEM_TYPE_* | ACRN_MEM_ACCESS_*)
|
|
|
|
* @user_vm_pa: Physical address of User VM to be mapped.
|
|
|
|
* @service_vm_pa: Physical address of Service VM to be mapped.
|
|
|
|
* @size: Size of this region.
|
|
|
|
*
|
|
|
|
* Structure containing needed information that is provided to ACRN Hypervisor
|
|
|
|
* to manage the EPT mappings of a single memory region of the User VM. Several
|
|
|
|
* &struct vm_memory_region_op can be batched to ACRN Hypervisor, see &struct
|
|
|
|
* vm_memory_region_batch.
|
|
|
|
*/
|
|
|
|
struct vm_memory_region_op {
|
|
|
|
u32 type;
|
|
|
|
u32 attr;
|
|
|
|
u64 user_vm_pa;
|
|
|
|
u64 service_vm_pa;
|
|
|
|
u64 size;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct vm_memory_region_batch - A batch of vm_memory_region_op.
|
|
|
|
* @vmid: A User VM ID.
|
|
|
|
* @reserved: Reserved.
|
|
|
|
* @regions_num: The number of vm_memory_region_op.
|
|
|
|
* @regions_gpa: Physical address of a vm_memory_region_op array.
|
|
|
|
*
|
|
|
|
* HC_VM_SET_MEMORY_REGIONS uses this structure to manage EPT mappings of
|
|
|
|
* multiple memory regions of a User VM. A &struct vm_memory_region_batch
|
|
|
|
* contains multiple &struct vm_memory_region_op for batch processing in the
|
|
|
|
* ACRN Hypervisor.
|
|
|
|
*/
|
|
|
|
struct vm_memory_region_batch {
|
|
|
|
u16 vmid;
|
|
|
|
u16 reserved[3];
|
|
|
|
u32 regions_num;
|
|
|
|
u64 regions_gpa;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct vm_memory_mapping - Memory map between a User VM and the Service VM
|
|
|
|
* @pages: Pages in Service VM kernel.
|
|
|
|
* @npages: Number of pages.
|
|
|
|
* @service_vm_va: Virtual address in Service VM kernel.
|
|
|
|
* @user_vm_pa: Physical address in User VM.
|
|
|
|
* @size: Size of this memory region.
|
|
|
|
*
|
|
|
|
* HSM maintains memory mappings between a User VM GPA and the Service VM
|
|
|
|
* kernel VA for accelerating the User VM GPA translation.
|
|
|
|
*/
|
|
|
|
struct vm_memory_mapping {
|
|
|
|
struct page **pages;
|
|
|
|
int npages;
|
|
|
|
void *service_vm_va;
|
|
|
|
u64 user_vm_pa;
|
|
|
|
size_t size;
|
|
|
|
};
|
|
|
|
|
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 03:10:31 +00:00
|
|
|
/**
|
|
|
|
* struct acrn_ioreq_buffer - Data for setting the ioreq buffer of User VM
|
|
|
|
* @ioreq_buf: The GPA of the IO request shared buffer of a VM
|
|
|
|
*
|
|
|
|
* The parameter for the HC_SET_IOREQ_BUFFER hypercall used to set up
|
|
|
|
* the shared I/O request buffer between Service VM and ACRN hypervisor.
|
|
|
|
*/
|
|
|
|
struct acrn_ioreq_buffer {
|
|
|
|
u64 ioreq_buf;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct acrn_ioreq_range {
|
|
|
|
struct list_head list;
|
|
|
|
u32 type;
|
|
|
|
u64 start;
|
|
|
|
u64 end;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define ACRN_IOREQ_CLIENT_DESTROYING 0U
|
|
|
|
typedef int (*ioreq_handler_t)(struct acrn_ioreq_client *client,
|
|
|
|
struct acrn_io_request *req);
|
|
|
|
/**
|
|
|
|
* struct acrn_ioreq_client - Structure of I/O client.
|
|
|
|
* @name: Client name
|
|
|
|
* @vm: The VM that the client belongs to
|
|
|
|
* @list: List node for this acrn_ioreq_client
|
|
|
|
* @is_default: If this client is the default one
|
|
|
|
* @flags: Flags (ACRN_IOREQ_CLIENT_*)
|
|
|
|
* @range_list: I/O ranges
|
|
|
|
* @range_lock: Lock to protect range_list
|
|
|
|
* @ioreqs_map: The pending I/O requests bitmap.
|
|
|
|
* @handler: I/O requests handler of this client
|
|
|
|
* @thread: The thread which executes the handler
|
|
|
|
* @wq: The wait queue for the handler thread parking
|
|
|
|
* @priv: Data for the thread
|
|
|
|
*/
|
|
|
|
struct acrn_ioreq_client {
|
|
|
|
char name[ACRN_NAME_LEN];
|
|
|
|
struct acrn_vm *vm;
|
|
|
|
struct list_head list;
|
|
|
|
bool is_default;
|
|
|
|
unsigned long flags;
|
|
|
|
struct list_head range_list;
|
|
|
|
rwlock_t range_lock;
|
|
|
|
DECLARE_BITMAP(ioreqs_map, ACRN_IO_REQUEST_MAX);
|
|
|
|
ioreq_handler_t handler;
|
|
|
|
struct task_struct *thread;
|
|
|
|
wait_queue_head_t wq;
|
|
|
|
void *priv;
|
|
|
|
};
|
|
|
|
|
2021-02-07 03:10:27 +00:00
|
|
|
#define ACRN_INVALID_VMID (0xffffU)
|
|
|
|
|
2021-02-07 03:10:28 +00:00
|
|
|
#define ACRN_VM_FLAG_DESTROYED 0U
|
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 03:10:31 +00:00
|
|
|
#define ACRN_VM_FLAG_CLEARING_IOREQ 1U
|
|
|
|
extern struct list_head acrn_vm_list;
|
|
|
|
extern rwlock_t acrn_vm_list_lock;
|
2021-02-07 03:10:27 +00:00
|
|
|
/**
|
|
|
|
* struct acrn_vm - Properties of ACRN User VM.
|
2021-02-07 03:10:30 +00:00
|
|
|
* @list: Entry within global list of all VMs.
|
|
|
|
* @vmid: User VM ID.
|
|
|
|
* @vcpu_num: Number of virtual CPUs in the VM.
|
|
|
|
* @flags: Flags (ACRN_VM_FLAG_*) of the VM. This is VM
|
|
|
|
* flag management in HSM which is different
|
|
|
|
* from the &acrn_vm_creation.vm_flag.
|
|
|
|
* @regions_mapping_lock: Lock to protect &acrn_vm.regions_mapping and
|
|
|
|
* &acrn_vm.regions_mapping_count.
|
|
|
|
* @regions_mapping: Memory mappings of this VM.
|
|
|
|
* @regions_mapping_count: Number of memory mapping of this VM.
|
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 03:10:31 +00:00
|
|
|
* @ioreq_clients_lock: Lock to protect ioreq_clients and default_client
|
|
|
|
* @ioreq_clients: The I/O request clients list of this VM
|
|
|
|
* @default_client: The default I/O request client
|
|
|
|
* @ioreq_buf: I/O request shared buffer
|
|
|
|
* @ioreq_page: The page of the I/O request shared buffer
|
2021-02-07 03:10:32 +00:00
|
|
|
* @pci_conf_addr: Address of a PCI configuration access emulation
|
2021-02-07 03:10:34 +00:00
|
|
|
* @monitor_page: Page of interrupt statistics of User VM
|
2021-02-07 03:10:37 +00:00
|
|
|
* @ioeventfds_lock: Lock to protect ioeventfds list
|
|
|
|
* @ioeventfds: List to link all hsm_ioeventfd
|
|
|
|
* @ioeventfd_client: I/O client for ioeventfds of the VM
|
2021-02-07 03:10:38 +00:00
|
|
|
* @irqfds_lock: Lock to protect irqfds list
|
|
|
|
* @irqfds: List to link all hsm_irqfd
|
|
|
|
* @irqfd_wq: Workqueue for irqfd async shutdown
|
2021-02-07 03:10:27 +00:00
|
|
|
*/
|
|
|
|
struct acrn_vm {
|
2021-02-07 03:10:30 +00:00
|
|
|
struct list_head list;
|
|
|
|
u16 vmid;
|
|
|
|
int vcpu_num;
|
|
|
|
unsigned long flags;
|
|
|
|
struct mutex regions_mapping_lock;
|
|
|
|
struct vm_memory_mapping regions_mapping[ACRN_MEM_MAPPING_MAX];
|
|
|
|
int regions_mapping_count;
|
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 03:10:31 +00:00
|
|
|
spinlock_t ioreq_clients_lock;
|
|
|
|
struct list_head ioreq_clients;
|
|
|
|
struct acrn_ioreq_client *default_client;
|
|
|
|
struct acrn_io_request_buffer *ioreq_buf;
|
|
|
|
struct page *ioreq_page;
|
2021-02-07 03:10:32 +00:00
|
|
|
u32 pci_conf_addr;
|
2021-02-07 03:10:34 +00:00
|
|
|
struct page *monitor_page;
|
2021-02-07 03:10:37 +00:00
|
|
|
struct mutex ioeventfds_lock;
|
|
|
|
struct list_head ioeventfds;
|
|
|
|
struct acrn_ioreq_client *ioeventfd_client;
|
2021-02-07 03:10:38 +00:00
|
|
|
struct mutex irqfds_lock;
|
|
|
|
struct list_head irqfds;
|
|
|
|
struct workqueue_struct *irqfd_wq;
|
2021-02-07 03:10:27 +00:00
|
|
|
};
|
|
|
|
|
2021-02-07 03:10:28 +00:00
|
|
|
struct acrn_vm *acrn_vm_create(struct acrn_vm *vm,
|
|
|
|
struct acrn_vm_creation *vm_param);
|
|
|
|
int acrn_vm_destroy(struct acrn_vm *vm);
|
2021-02-07 03:10:30 +00:00
|
|
|
int acrn_mm_region_add(struct acrn_vm *vm, u64 user_gpa, u64 service_gpa,
|
|
|
|
u64 size, u32 mem_type, u32 mem_access_right);
|
|
|
|
int acrn_mm_region_del(struct acrn_vm *vm, u64 user_gpa, u64 size);
|
|
|
|
int acrn_vm_memseg_map(struct acrn_vm *vm, struct acrn_vm_memmap *memmap);
|
|
|
|
int acrn_vm_memseg_unmap(struct acrn_vm *vm, struct acrn_vm_memmap *memmap);
|
|
|
|
int acrn_vm_ram_map(struct acrn_vm *vm, struct acrn_vm_memmap *memmap);
|
|
|
|
void acrn_vm_all_ram_unmap(struct acrn_vm *vm);
|
2021-02-07 03:10:28 +00: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 03:10:31 +00:00
|
|
|
int acrn_ioreq_init(struct acrn_vm *vm, u64 buf_vma);
|
|
|
|
void acrn_ioreq_deinit(struct acrn_vm *vm);
|
|
|
|
int acrn_ioreq_intr_setup(void);
|
|
|
|
void acrn_ioreq_intr_remove(void);
|
|
|
|
void acrn_ioreq_request_clear(struct acrn_vm *vm);
|
|
|
|
int acrn_ioreq_client_wait(struct acrn_ioreq_client *client);
|
|
|
|
int acrn_ioreq_request_default_complete(struct acrn_vm *vm, u16 vcpu);
|
|
|
|
struct acrn_ioreq_client *acrn_ioreq_client_create(struct acrn_vm *vm,
|
|
|
|
ioreq_handler_t handler,
|
|
|
|
void *data, bool is_default,
|
|
|
|
const char *name);
|
|
|
|
void acrn_ioreq_client_destroy(struct acrn_ioreq_client *client);
|
2021-02-07 03:10:36 +00:00
|
|
|
int acrn_ioreq_range_add(struct acrn_ioreq_client *client,
|
|
|
|
u32 type, u64 start, u64 end);
|
|
|
|
void acrn_ioreq_range_del(struct acrn_ioreq_client *client,
|
|
|
|
u32 type, u64 start, u64 end);
|
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 03:10:31 +00:00
|
|
|
|
2021-02-07 03:10:34 +00:00
|
|
|
int acrn_msi_inject(struct acrn_vm *vm, u64 msi_addr, u64 msi_data);
|
|
|
|
|
2021-02-07 03:10:37 +00:00
|
|
|
int acrn_ioeventfd_init(struct acrn_vm *vm);
|
|
|
|
int acrn_ioeventfd_config(struct acrn_vm *vm, struct acrn_ioeventfd *args);
|
|
|
|
void acrn_ioeventfd_deinit(struct acrn_vm *vm);
|
|
|
|
|
2021-02-07 03:10:38 +00:00
|
|
|
int acrn_irqfd_init(struct acrn_vm *vm);
|
|
|
|
int acrn_irqfd_config(struct acrn_vm *vm, struct acrn_irqfd *args);
|
|
|
|
void acrn_irqfd_deinit(struct acrn_vm *vm);
|
|
|
|
|
2021-02-07 03:10:27 +00:00
|
|
|
#endif /* __ACRN_HSM_DRV_H */
|