2011-05-13 04:54:01 +00:00
|
|
|
/*-
|
2023-05-10 15:40:58 +00:00
|
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
2017-11-26 02:00:33 +00:00
|
|
|
*
|
2011-05-13 04:54:01 +00:00
|
|
|
* Copyright (c) 2011 NetApp, Inc.
|
|
|
|
|
* All rights reserved.
|
|
|
|
|
*
|
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
|
* are met:
|
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
|
*
|
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY NETAPP, INC ``AS IS'' AND
|
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL NETAPP, INC OR CONTRIBUTORS BE LIABLE
|
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef _VMMAPI_H_
|
|
|
|
|
#define _VMMAPI_H_
|
|
|
|
|
|
2022-07-11 19:25:43 +00:00
|
|
|
#include <sys/cdefs.h>
|
2014-05-31 23:37:34 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
|
#include <sys/cpuset.h>
|
2022-06-30 21:21:57 +00:00
|
|
|
#include <machine/vmm.h>
|
Initial support for bhyve save and restore.
Save and restore (also known as suspend and resume) permits a snapshot
to be taken of a guest's state that can later be resumed. In the
current implementation, bhyve(8) creates a UNIX domain socket that is
used by bhyvectl(8) to send a request to save a snapshot (and
optionally exit after the snapshot has been taken). A snapshot
currently consists of two files: the first holds a copy of guest RAM,
and the second file holds other guest state such as vCPU register
values and device model state.
To resume a guest, bhyve(8) must be started with a matching pair of
command line arguments to instantiate the same set of device models as
well as a pointer to the saved snapshot.
While the current implementation is useful for several uses cases, it
has a few limitations. The file format for saving the guest state is
tied to the ABI of internal bhyve structures and is not
self-describing (in that it does not communicate the set of device
models present in the system). In addition, the state saved for some
device models closely matches the internal data structures which might
prove a challenge for compatibility of snapshot files across a range
of bhyve versions. The file format also does not currently support
versioning of individual chunks of state. As a result, the current
file format is not a fixed binary format and future revisions to save
and restore will break binary compatiblity of snapshot files. The
goal is to move to a more flexible format that adds versioning,
etc. and at that point to commit to providing a reasonable level of
compatibility. As a result, the current implementation is not enabled
by default. It can be enabled via the WITH_BHYVE_SNAPSHOT=yes option
for userland builds, and the kernel option BHYVE_SHAPSHOT.
Submitted by: Mihai Tiganus, Flavius Anton, Darius Mihai
Submitted by: Elena Mihailescu, Mihai Carabas, Sergiu Weisz
Relnotes: yes
Sponsored by: University Politehnica of Bucharest
Sponsored by: Matthew Grooms (student scholarships)
Sponsored by: iXsystems
Differential Revision: https://reviews.freebsd.org/D19495
2020-05-05 00:02:04 +00:00
|
|
|
#include <machine/vmm_dev.h>
|
2014-05-31 23:37:34 +00:00
|
|
|
|
2020-05-15 15:54:22 +00:00
|
|
|
#include <stdbool.h>
|
|
|
|
|
|
2015-01-18 03:08:30 +00:00
|
|
|
/*
|
|
|
|
|
* API version for out-of-tree consumers like grub-bhyve for making compile
|
|
|
|
|
* time decisions.
|
|
|
|
|
*/
|
2023-03-24 18:49:06 +00:00
|
|
|
#define VMMAPI_VERSION 0200 /* 2 digit major followed by 2 digit minor */
|
2015-01-18 03:08:30 +00:00
|
|
|
|
2014-05-26 18:21:08 +00:00
|
|
|
struct iovec;
|
2023-03-24 18:49:06 +00:00
|
|
|
struct vcpu;
|
2011-05-13 04:54:01 +00:00
|
|
|
struct vmctx;
|
Initial support for bhyve save and restore.
Save and restore (also known as suspend and resume) permits a snapshot
to be taken of a guest's state that can later be resumed. In the
current implementation, bhyve(8) creates a UNIX domain socket that is
used by bhyvectl(8) to send a request to save a snapshot (and
optionally exit after the snapshot has been taken). A snapshot
currently consists of two files: the first holds a copy of guest RAM,
and the second file holds other guest state such as vCPU register
values and device model state.
To resume a guest, bhyve(8) must be started with a matching pair of
command line arguments to instantiate the same set of device models as
well as a pointer to the saved snapshot.
While the current implementation is useful for several uses cases, it
has a few limitations. The file format for saving the guest state is
tied to the ABI of internal bhyve structures and is not
self-describing (in that it does not communicate the set of device
models present in the system). In addition, the state saved for some
device models closely matches the internal data structures which might
prove a challenge for compatibility of snapshot files across a range
of bhyve versions. The file format also does not currently support
versioning of individual chunks of state. As a result, the current
file format is not a fixed binary format and future revisions to save
and restore will break binary compatiblity of snapshot files. The
goal is to move to a more flexible format that adds versioning,
etc. and at that point to commit to providing a reasonable level of
compatibility. As a result, the current implementation is not enabled
by default. It can be enabled via the WITH_BHYVE_SNAPSHOT=yes option
for userland builds, and the kernel option BHYVE_SHAPSHOT.
Submitted by: Mihai Tiganus, Flavius Anton, Darius Mihai
Submitted by: Elena Mihailescu, Mihai Carabas, Sergiu Weisz
Relnotes: yes
Sponsored by: University Politehnica of Bucharest
Sponsored by: Matthew Grooms (student scholarships)
Sponsored by: iXsystems
Differential Revision: https://reviews.freebsd.org/D19495
2020-05-05 00:02:04 +00:00
|
|
|
struct vm_snapshot_meta;
|
2012-09-25 19:08:51 +00:00
|
|
|
enum x2apic_state;
|
2011-05-13 04:54:01 +00:00
|
|
|
|
2013-03-18 22:38:30 +00:00
|
|
|
/*
|
|
|
|
|
* Different styles of mapping the memory assigned to a VM into the address
|
|
|
|
|
* space of the controlling process.
|
|
|
|
|
*/
|
|
|
|
|
enum vm_mmap_style {
|
|
|
|
|
VM_MMAP_NONE, /* no mapping */
|
|
|
|
|
VM_MMAP_ALL, /* fully and statically mapped */
|
|
|
|
|
VM_MMAP_SPARSE, /* mappings created on-demand */
|
|
|
|
|
};
|
|
|
|
|
|
2015-06-18 06:00:17 +00:00
|
|
|
/*
|
|
|
|
|
* 'flags' value passed to 'vm_set_memflags()'.
|
|
|
|
|
*/
|
2014-05-13 16:40:27 +00:00
|
|
|
#define VM_MEM_F_INCORE 0x01 /* include guest memory in core file */
|
2015-06-18 06:00:17 +00:00
|
|
|
#define VM_MEM_F_WIRED 0x02 /* guest memory is wired */
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Identifiers for memory segments:
|
|
|
|
|
* - vm_setup_memory() uses VM_SYSMEM for the system memory segment.
|
|
|
|
|
* - the remaining identifiers can be used to create devmem segments.
|
|
|
|
|
*/
|
|
|
|
|
enum {
|
|
|
|
|
VM_SYSMEM,
|
|
|
|
|
VM_BOOTROM,
|
|
|
|
|
VM_FRAMEBUFFER,
|
2022-03-10 10:28:06 +00:00
|
|
|
VM_PCIROM,
|
2015-06-18 06:00:17 +00:00
|
|
|
};
|
|
|
|
|
|
2022-07-11 19:25:43 +00:00
|
|
|
__BEGIN_DECLS
|
2015-06-18 06:00:17 +00:00
|
|
|
/*
|
|
|
|
|
* Get the length and name of the memory segment identified by 'segid'.
|
|
|
|
|
* Note that system memory segments are identified with a nul name.
|
|
|
|
|
*
|
|
|
|
|
* Returns 0 on success and non-zero otherwise.
|
|
|
|
|
*/
|
|
|
|
|
int vm_get_memseg(struct vmctx *ctx, int ident, size_t *lenp, char *name,
|
|
|
|
|
size_t namesiz);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Iterate over the guest address space. This function finds an address range
|
|
|
|
|
* that starts at an address >= *gpa.
|
|
|
|
|
*
|
|
|
|
|
* Returns 0 if the next address range was found and non-zero otherwise.
|
|
|
|
|
*/
|
|
|
|
|
int vm_mmap_getnext(struct vmctx *ctx, vm_paddr_t *gpa, int *segid,
|
|
|
|
|
vm_ooffset_t *segoff, size_t *len, int *prot, int *flags);
|
Initial support for bhyve save and restore.
Save and restore (also known as suspend and resume) permits a snapshot
to be taken of a guest's state that can later be resumed. In the
current implementation, bhyve(8) creates a UNIX domain socket that is
used by bhyvectl(8) to send a request to save a snapshot (and
optionally exit after the snapshot has been taken). A snapshot
currently consists of two files: the first holds a copy of guest RAM,
and the second file holds other guest state such as vCPU register
values and device model state.
To resume a guest, bhyve(8) must be started with a matching pair of
command line arguments to instantiate the same set of device models as
well as a pointer to the saved snapshot.
While the current implementation is useful for several uses cases, it
has a few limitations. The file format for saving the guest state is
tied to the ABI of internal bhyve structures and is not
self-describing (in that it does not communicate the set of device
models present in the system). In addition, the state saved for some
device models closely matches the internal data structures which might
prove a challenge for compatibility of snapshot files across a range
of bhyve versions. The file format also does not currently support
versioning of individual chunks of state. As a result, the current
file format is not a fixed binary format and future revisions to save
and restore will break binary compatiblity of snapshot files. The
goal is to move to a more flexible format that adds versioning,
etc. and at that point to commit to providing a reasonable level of
compatibility. As a result, the current implementation is not enabled
by default. It can be enabled via the WITH_BHYVE_SNAPSHOT=yes option
for userland builds, and the kernel option BHYVE_SHAPSHOT.
Submitted by: Mihai Tiganus, Flavius Anton, Darius Mihai
Submitted by: Elena Mihailescu, Mihai Carabas, Sergiu Weisz
Relnotes: yes
Sponsored by: University Politehnica of Bucharest
Sponsored by: Matthew Grooms (student scholarships)
Sponsored by: iXsystems
Differential Revision: https://reviews.freebsd.org/D19495
2020-05-05 00:02:04 +00:00
|
|
|
|
|
|
|
|
int vm_get_guestmem_from_ctx(struct vmctx *ctx, char **guest_baseaddr,
|
|
|
|
|
size_t *lowmem_size, size_t *highmem_size);
|
|
|
|
|
|
2015-06-18 06:00:17 +00:00
|
|
|
/*
|
|
|
|
|
* Create a device memory segment identified by 'segid'.
|
|
|
|
|
*
|
|
|
|
|
* Returns a pointer to the memory segment on success and MAP_FAILED otherwise.
|
|
|
|
|
*/
|
|
|
|
|
void *vm_create_devmem(struct vmctx *ctx, int segid, const char *name,
|
|
|
|
|
size_t len);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Map the memory segment identified by 'segid' into the guest address space
|
|
|
|
|
* at [gpa,gpa+len) with protection 'prot'.
|
|
|
|
|
*/
|
|
|
|
|
int vm_mmap_memseg(struct vmctx *ctx, vm_paddr_t gpa, int segid,
|
|
|
|
|
vm_ooffset_t segoff, size_t len, int prot);
|
2014-05-13 16:40:27 +00:00
|
|
|
|
2021-03-18 16:08:52 +00:00
|
|
|
int vm_munmap_memseg(struct vmctx *ctx, vm_paddr_t gpa, size_t len);
|
|
|
|
|
|
2011-05-13 04:54:01 +00:00
|
|
|
int vm_create(const char *name);
|
|
|
|
|
struct vmctx *vm_open(const char *name);
|
2022-06-30 21:21:57 +00:00
|
|
|
void vm_close(struct vmctx *ctx);
|
2011-05-13 04:54:01 +00:00
|
|
|
void vm_destroy(struct vmctx *ctx);
|
2022-10-24 21:31:11 +00:00
|
|
|
int vm_limit_rights(struct vmctx *ctx);
|
2023-03-24 18:49:06 +00:00
|
|
|
struct vcpu *vm_vcpu_open(struct vmctx *ctx, int vcpuid);
|
|
|
|
|
void vm_vcpu_close(struct vcpu *vcpu);
|
|
|
|
|
int vcpu_id(struct vcpu *vcpu);
|
2013-10-09 03:56:07 +00:00
|
|
|
int vm_parse_memsize(const char *optarg, size_t *memsize);
|
2013-03-18 22:38:30 +00:00
|
|
|
int vm_setup_memory(struct vmctx *ctx, size_t len, enum vm_mmap_style s);
|
|
|
|
|
void *vm_map_gpa(struct vmctx *ctx, vm_paddr_t gaddr, size_t len);
|
Initial support for bhyve save and restore.
Save and restore (also known as suspend and resume) permits a snapshot
to be taken of a guest's state that can later be resumed. In the
current implementation, bhyve(8) creates a UNIX domain socket that is
used by bhyvectl(8) to send a request to save a snapshot (and
optionally exit after the snapshot has been taken). A snapshot
currently consists of two files: the first holds a copy of guest RAM,
and the second file holds other guest state such as vCPU register
values and device model state.
To resume a guest, bhyve(8) must be started with a matching pair of
command line arguments to instantiate the same set of device models as
well as a pointer to the saved snapshot.
While the current implementation is useful for several uses cases, it
has a few limitations. The file format for saving the guest state is
tied to the ABI of internal bhyve structures and is not
self-describing (in that it does not communicate the set of device
models present in the system). In addition, the state saved for some
device models closely matches the internal data structures which might
prove a challenge for compatibility of snapshot files across a range
of bhyve versions. The file format also does not currently support
versioning of individual chunks of state. As a result, the current
file format is not a fixed binary format and future revisions to save
and restore will break binary compatiblity of snapshot files. The
goal is to move to a more flexible format that adds versioning,
etc. and at that point to commit to providing a reasonable level of
compatibility. As a result, the current implementation is not enabled
by default. It can be enabled via the WITH_BHYVE_SNAPSHOT=yes option
for userland builds, and the kernel option BHYVE_SHAPSHOT.
Submitted by: Mihai Tiganus, Flavius Anton, Darius Mihai
Submitted by: Elena Mihailescu, Mihai Carabas, Sergiu Weisz
Relnotes: yes
Sponsored by: University Politehnica of Bucharest
Sponsored by: Matthew Grooms (student scholarships)
Sponsored by: iXsystems
Differential Revision: https://reviews.freebsd.org/D19495
2020-05-05 00:02:04 +00:00
|
|
|
/* inverse operation to vm_map_gpa - extract guest address from host pointer */
|
|
|
|
|
vm_paddr_t vm_rev_map_gpa(struct vmctx *ctx, void *addr);
|
2013-10-05 21:22:35 +00:00
|
|
|
int vm_get_gpa_pmap(struct vmctx *, uint64_t gpa, uint64_t *pte, int *num);
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_gla2gpa(struct vcpu *vcpu, struct vm_guest_paging *paging,
|
2015-05-06 16:25:20 +00:00
|
|
|
uint64_t gla, int prot, uint64_t *gpa, int *fault);
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_gla2gpa_nofault(struct vcpu *vcpu,
|
2018-02-26 19:19:05 +00:00
|
|
|
struct vm_guest_paging *paging, uint64_t gla, int prot,
|
|
|
|
|
uint64_t *gpa, int *fault);
|
2013-03-18 22:38:30 +00:00
|
|
|
uint32_t vm_get_lowmem_limit(struct vmctx *ctx);
|
|
|
|
|
void vm_set_lowmem_limit(struct vmctx *ctx, uint32_t limit);
|
2014-05-13 16:40:27 +00:00
|
|
|
void vm_set_memflags(struct vmctx *ctx, int flags);
|
2015-06-18 06:00:17 +00:00
|
|
|
int vm_get_memflags(struct vmctx *ctx);
|
2022-03-18 05:26:54 +00:00
|
|
|
const char *vm_get_name(struct vmctx *ctx);
|
2014-06-24 02:02:51 +00:00
|
|
|
size_t vm_get_lowmem_size(struct vmctx *ctx);
|
|
|
|
|
size_t vm_get_highmem_size(struct vmctx *ctx);
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_set_desc(struct vcpu *vcpu, int reg,
|
2011-05-13 04:54:01 +00:00
|
|
|
uint64_t base, uint32_t limit, uint32_t access);
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_get_desc(struct vcpu *vcpu, int reg,
|
2011-05-13 04:54:01 +00:00
|
|
|
uint64_t *base, uint32_t *limit, uint32_t *access);
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_get_seg_desc(struct vcpu *vcpu, int reg, struct seg_desc *seg_desc);
|
|
|
|
|
int vm_set_register(struct vcpu *vcpu, int reg, uint64_t val);
|
|
|
|
|
int vm_get_register(struct vcpu *vcpu, int reg, uint64_t *retval);
|
|
|
|
|
int vm_set_register_set(struct vcpu *vcpu, unsigned int count,
|
2018-02-22 00:39:25 +00:00
|
|
|
const int *regnums, uint64_t *regvals);
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_get_register_set(struct vcpu *vcpu, unsigned int count,
|
2018-02-22 00:39:25 +00:00
|
|
|
const int *regnums, uint64_t *regvals);
|
2023-05-24 01:13:33 +00:00
|
|
|
int vm_run(struct vcpu *vcpu, struct vm_run *vmrun);
|
2014-04-28 22:06:40 +00:00
|
|
|
int vm_suspend(struct vmctx *ctx, enum vm_suspend_how how);
|
2014-06-07 21:36:52 +00:00
|
|
|
int vm_reinit(struct vmctx *ctx);
|
2012-08-04 02:38:05 +00:00
|
|
|
int vm_apicid2vcpu(struct vmctx *ctx, int apicid);
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_inject_exception(struct vcpu *vcpu, int vector,
|
2015-01-18 03:08:30 +00:00
|
|
|
int errcode_valid, uint32_t errcode, int restart_instruction);
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_lapic_irq(struct vcpu *vcpu, int vector);
|
|
|
|
|
int vm_lapic_local_irq(struct vcpu *vcpu, int vector);
|
2013-12-16 19:59:31 +00:00
|
|
|
int vm_lapic_msi(struct vmctx *ctx, uint64_t addr, uint64_t msg);
|
2013-11-12 22:51:03 +00:00
|
|
|
int vm_ioapic_assert_irq(struct vmctx *ctx, int irq);
|
|
|
|
|
int vm_ioapic_deassert_irq(struct vmctx *ctx, int irq);
|
2013-11-23 03:56:03 +00:00
|
|
|
int vm_ioapic_pulse_irq(struct vmctx *ctx, int irq);
|
2014-01-29 14:56:48 +00:00
|
|
|
int vm_ioapic_pincount(struct vmctx *ctx, int *pincount);
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_readwrite_kernemu_device(struct vcpu *vcpu,
|
2020-05-15 15:54:22 +00:00
|
|
|
vm_paddr_t gpa, bool write, int size, uint64_t *value);
|
2014-04-14 19:00:20 +00:00
|
|
|
int vm_isa_assert_irq(struct vmctx *ctx, int atpic_irq, int ioapic_irq);
|
2014-03-11 16:56:00 +00:00
|
|
|
int vm_isa_deassert_irq(struct vmctx *ctx, int atpic_irq, int ioapic_irq);
|
|
|
|
|
int vm_isa_pulse_irq(struct vmctx *ctx, int atpic_irq, int ioapic_irq);
|
2014-05-15 14:16:55 +00:00
|
|
|
int vm_isa_set_irq_trigger(struct vmctx *ctx, int atpic_irq,
|
|
|
|
|
enum vm_intr_trigger trigger);
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_inject_nmi(struct vcpu *vcpu);
|
2011-05-13 04:54:01 +00:00
|
|
|
int vm_capability_name2type(const char *capname);
|
2012-10-12 17:39:28 +00:00
|
|
|
const char *vm_capability_type2name(int type);
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_get_capability(struct vcpu *vcpu, enum vm_cap_type cap,
|
2011-05-13 04:54:01 +00:00
|
|
|
int *retval);
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_set_capability(struct vcpu *vcpu, enum vm_cap_type cap,
|
2011-05-13 04:54:01 +00:00
|
|
|
int val);
|
|
|
|
|
int vm_assign_pptdev(struct vmctx *ctx, int bus, int slot, int func);
|
|
|
|
|
int vm_unassign_pptdev(struct vmctx *ctx, int bus, int slot, int func);
|
|
|
|
|
int vm_map_pptdev_mmio(struct vmctx *ctx, int bus, int slot, int func,
|
|
|
|
|
vm_paddr_t gpa, size_t len, vm_paddr_t hpa);
|
2021-03-18 16:08:52 +00:00
|
|
|
int vm_unmap_pptdev_mmio(struct vmctx *ctx, int bus, int slot, int func,
|
|
|
|
|
vm_paddr_t gpa, size_t len);
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_setup_pptdev_msi(struct vmctx *ctx, int bus, int slot,
|
2013-12-18 03:58:51 +00:00
|
|
|
int func, uint64_t addr, uint64_t msg, int numvec);
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_setup_pptdev_msix(struct vmctx *ctx, int bus, int slot,
|
2013-12-18 03:58:51 +00:00
|
|
|
int func, int idx, uint64_t addr, uint64_t msg,
|
|
|
|
|
uint32_t vector_control);
|
2020-11-24 23:18:52 +00:00
|
|
|
int vm_disable_pptdev_msix(struct vmctx *ctx, int bus, int slot, int func);
|
2011-05-13 04:54:01 +00:00
|
|
|
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_get_intinfo(struct vcpu *vcpu, uint64_t *i1, uint64_t *i2);
|
|
|
|
|
int vm_set_intinfo(struct vcpu *vcpu, uint64_t exit_intinfo);
|
2014-07-19 20:59:08 +00:00
|
|
|
|
2011-05-13 04:54:01 +00:00
|
|
|
/*
|
|
|
|
|
* Return a pointer to the statistics buffer. Note that this is not MT-safe.
|
|
|
|
|
*/
|
2023-03-24 18:49:06 +00:00
|
|
|
uint64_t *vm_get_stats(struct vcpu *vcpu, struct timeval *ret_tv,
|
2011-05-13 04:54:01 +00:00
|
|
|
int *ret_entries);
|
|
|
|
|
const char *vm_get_stat_desc(struct vmctx *ctx, int index);
|
|
|
|
|
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_get_x2apic_state(struct vcpu *vcpu, enum x2apic_state *s);
|
|
|
|
|
int vm_set_x2apic_state(struct vcpu *vcpu, enum x2apic_state s);
|
2012-09-25 19:08:51 +00:00
|
|
|
|
2013-11-25 19:04:51 +00:00
|
|
|
int vm_get_hpet_capabilities(struct vmctx *ctx, uint32_t *capabilities);
|
|
|
|
|
|
2014-05-26 18:21:08 +00:00
|
|
|
/*
|
|
|
|
|
* Translate the GLA range [gla,gla+len) into GPA segments in 'iov'.
|
2016-05-01 19:37:33 +00:00
|
|
|
* The 'iovcnt' should be big enough to accommodate all GPA segments.
|
2015-05-06 16:25:20 +00:00
|
|
|
*
|
|
|
|
|
* retval fault Interpretation
|
|
|
|
|
* 0 0 Success
|
|
|
|
|
* 0 1 An exception was injected into the guest
|
|
|
|
|
* EFAULT N/A Error
|
2014-05-26 18:21:08 +00:00
|
|
|
*/
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_copy_setup(struct vcpu *vcpu, struct vm_guest_paging *pg,
|
2015-05-06 16:25:20 +00:00
|
|
|
uint64_t gla, size_t len, int prot, struct iovec *iov, int iovcnt,
|
|
|
|
|
int *fault);
|
2022-11-18 18:01:44 +00:00
|
|
|
void vm_copyin(struct iovec *guest_iov, void *host_dst, size_t len);
|
|
|
|
|
void vm_copyout(const void *host_src, struct iovec *guest_iov, size_t len);
|
|
|
|
|
void vm_copy_teardown(struct iovec *iov, int iovcnt);
|
2014-05-24 23:12:30 +00:00
|
|
|
|
2014-12-30 22:19:34 +00:00
|
|
|
/* RTC */
|
|
|
|
|
int vm_rtc_write(struct vmctx *ctx, int offset, uint8_t value);
|
|
|
|
|
int vm_rtc_read(struct vmctx *ctx, int offset, uint8_t *retval);
|
|
|
|
|
int vm_rtc_settime(struct vmctx *ctx, time_t secs);
|
|
|
|
|
int vm_rtc_gettime(struct vmctx *ctx, time_t *secs);
|
|
|
|
|
|
2011-05-13 04:54:01 +00:00
|
|
|
/* Reset vcpu register state */
|
2023-03-24 18:49:06 +00:00
|
|
|
int vcpu_reset(struct vcpu *vcpu);
|
2011-05-13 04:54:01 +00:00
|
|
|
|
2014-05-31 23:37:34 +00:00
|
|
|
int vm_active_cpus(struct vmctx *ctx, cpuset_t *cpus);
|
|
|
|
|
int vm_suspended_cpus(struct vmctx *ctx, cpuset_t *cpus);
|
2018-04-06 22:03:43 +00:00
|
|
|
int vm_debug_cpus(struct vmctx *ctx, cpuset_t *cpus);
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_activate_cpu(struct vcpu *vcpu);
|
|
|
|
|
int vm_suspend_all_cpus(struct vmctx *ctx);
|
|
|
|
|
int vm_suspend_cpu(struct vcpu *vcpu);
|
|
|
|
|
int vm_resume_all_cpus(struct vmctx *ctx);
|
|
|
|
|
int vm_resume_cpu(struct vcpu *vcpu);
|
|
|
|
|
int vm_restart_instruction(struct vcpu *vcpu);
|
2014-05-31 23:37:34 +00:00
|
|
|
|
Add the ability to control the CPU topology of created VMs
from userland without the need to use sysctls, it allows the old
sysctls to continue to function, but deprecates them at
FreeBSD_version 1200060 (Relnotes for deprecate).
The command line of bhyve is maintained in a backwards compatible way.
The API of libvmmapi is maintained in a backwards compatible way.
The sysctl's are maintained in a backwards compatible way.
Added command option looks like:
bhyve -c [[cpus=]n][,sockets=n][,cores=n][,threads=n][,maxcpus=n]
The optional parts can be specified in any order, but only a single
integer invokes the backwards compatible parse. [,maxcpus=n] is
hidden by #ifdef until kernel support is added, though the api
is put in place.
bhyvectl --get-cpu-topology option added.
Reviewed by: grehan (maintainer, earlier version),
Reviewed by: bcr (manpages)
Approved by: bde (mentor), phk (mentor)
Tested by: Oleg Ginzburg <olevole@olevole.ru> (cbsd)
MFC after: 1 week
Relnotes: Y
Differential Revision: https://reviews.freebsd.org/D9930
2018-04-08 19:24:49 +00:00
|
|
|
/* CPU topology */
|
|
|
|
|
int vm_set_topology(struct vmctx *ctx, uint16_t sockets, uint16_t cores,
|
|
|
|
|
uint16_t threads, uint16_t maxcpus);
|
|
|
|
|
int vm_get_topology(struct vmctx *ctx, uint16_t *sockets, uint16_t *cores,
|
|
|
|
|
uint16_t *threads, uint16_t *maxcpus);
|
|
|
|
|
|
2011-05-13 04:54:01 +00:00
|
|
|
/*
|
|
|
|
|
* FreeBSD specific APIs
|
|
|
|
|
*/
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_setup_freebsd_registers(struct vcpu *vcpu,
|
2011-05-13 04:54:01 +00:00
|
|
|
uint64_t rip, uint64_t cr3, uint64_t gdtbase,
|
|
|
|
|
uint64_t rsp);
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_setup_freebsd_registers_i386(struct vcpu *vcpu,
|
2014-02-05 04:39:03 +00:00
|
|
|
uint32_t eip, uint32_t gdtbase,
|
|
|
|
|
uint32_t esp);
|
2011-05-13 04:54:01 +00:00
|
|
|
void vm_setup_freebsd_gdt(uint64_t *gdtr);
|
Initial support for bhyve save and restore.
Save and restore (also known as suspend and resume) permits a snapshot
to be taken of a guest's state that can later be resumed. In the
current implementation, bhyve(8) creates a UNIX domain socket that is
used by bhyvectl(8) to send a request to save a snapshot (and
optionally exit after the snapshot has been taken). A snapshot
currently consists of two files: the first holds a copy of guest RAM,
and the second file holds other guest state such as vCPU register
values and device model state.
To resume a guest, bhyve(8) must be started with a matching pair of
command line arguments to instantiate the same set of device models as
well as a pointer to the saved snapshot.
While the current implementation is useful for several uses cases, it
has a few limitations. The file format for saving the guest state is
tied to the ABI of internal bhyve structures and is not
self-describing (in that it does not communicate the set of device
models present in the system). In addition, the state saved for some
device models closely matches the internal data structures which might
prove a challenge for compatibility of snapshot files across a range
of bhyve versions. The file format also does not currently support
versioning of individual chunks of state. As a result, the current
file format is not a fixed binary format and future revisions to save
and restore will break binary compatiblity of snapshot files. The
goal is to move to a more flexible format that adds versioning,
etc. and at that point to commit to providing a reasonable level of
compatibility. As a result, the current implementation is not enabled
by default. It can be enabled via the WITH_BHYVE_SNAPSHOT=yes option
for userland builds, and the kernel option BHYVE_SHAPSHOT.
Submitted by: Mihai Tiganus, Flavius Anton, Darius Mihai
Submitted by: Elena Mihailescu, Mihai Carabas, Sergiu Weisz
Relnotes: yes
Sponsored by: University Politehnica of Bucharest
Sponsored by: Matthew Grooms (student scholarships)
Sponsored by: iXsystems
Differential Revision: https://reviews.freebsd.org/D19495
2020-05-05 00:02:04 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Save and restore
|
|
|
|
|
*/
|
2023-03-24 18:49:06 +00:00
|
|
|
int vm_snapshot_req(struct vmctx *ctx, struct vm_snapshot_meta *meta);
|
Initial support for bhyve save and restore.
Save and restore (also known as suspend and resume) permits a snapshot
to be taken of a guest's state that can later be resumed. In the
current implementation, bhyve(8) creates a UNIX domain socket that is
used by bhyvectl(8) to send a request to save a snapshot (and
optionally exit after the snapshot has been taken). A snapshot
currently consists of two files: the first holds a copy of guest RAM,
and the second file holds other guest state such as vCPU register
values and device model state.
To resume a guest, bhyve(8) must be started with a matching pair of
command line arguments to instantiate the same set of device models as
well as a pointer to the saved snapshot.
While the current implementation is useful for several uses cases, it
has a few limitations. The file format for saving the guest state is
tied to the ABI of internal bhyve structures and is not
self-describing (in that it does not communicate the set of device
models present in the system). In addition, the state saved for some
device models closely matches the internal data structures which might
prove a challenge for compatibility of snapshot files across a range
of bhyve versions. The file format also does not currently support
versioning of individual chunks of state. As a result, the current
file format is not a fixed binary format and future revisions to save
and restore will break binary compatiblity of snapshot files. The
goal is to move to a more flexible format that adds versioning,
etc. and at that point to commit to providing a reasonable level of
compatibility. As a result, the current implementation is not enabled
by default. It can be enabled via the WITH_BHYVE_SNAPSHOT=yes option
for userland builds, and the kernel option BHYVE_SHAPSHOT.
Submitted by: Mihai Tiganus, Flavius Anton, Darius Mihai
Submitted by: Elena Mihailescu, Mihai Carabas, Sergiu Weisz
Relnotes: yes
Sponsored by: University Politehnica of Bucharest
Sponsored by: Matthew Grooms (student scholarships)
Sponsored by: iXsystems
Differential Revision: https://reviews.freebsd.org/D19495
2020-05-05 00:02:04 +00:00
|
|
|
int vm_restore_time(struct vmctx *ctx);
|
2022-10-24 21:31:11 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Deprecated interfaces, do not use them in new code.
|
|
|
|
|
*/
|
|
|
|
|
int vm_get_device_fd(struct vmctx *ctx);
|
|
|
|
|
const cap_ioctl_t *vm_get_ioctls(size_t *len);
|
|
|
|
|
|
2022-07-11 19:25:43 +00:00
|
|
|
__END_DECLS
|
Initial support for bhyve save and restore.
Save and restore (also known as suspend and resume) permits a snapshot
to be taken of a guest's state that can later be resumed. In the
current implementation, bhyve(8) creates a UNIX domain socket that is
used by bhyvectl(8) to send a request to save a snapshot (and
optionally exit after the snapshot has been taken). A snapshot
currently consists of two files: the first holds a copy of guest RAM,
and the second file holds other guest state such as vCPU register
values and device model state.
To resume a guest, bhyve(8) must be started with a matching pair of
command line arguments to instantiate the same set of device models as
well as a pointer to the saved snapshot.
While the current implementation is useful for several uses cases, it
has a few limitations. The file format for saving the guest state is
tied to the ABI of internal bhyve structures and is not
self-describing (in that it does not communicate the set of device
models present in the system). In addition, the state saved for some
device models closely matches the internal data structures which might
prove a challenge for compatibility of snapshot files across a range
of bhyve versions. The file format also does not currently support
versioning of individual chunks of state. As a result, the current
file format is not a fixed binary format and future revisions to save
and restore will break binary compatiblity of snapshot files. The
goal is to move to a more flexible format that adds versioning,
etc. and at that point to commit to providing a reasonable level of
compatibility. As a result, the current implementation is not enabled
by default. It can be enabled via the WITH_BHYVE_SNAPSHOT=yes option
for userland builds, and the kernel option BHYVE_SHAPSHOT.
Submitted by: Mihai Tiganus, Flavius Anton, Darius Mihai
Submitted by: Elena Mihailescu, Mihai Carabas, Sergiu Weisz
Relnotes: yes
Sponsored by: University Politehnica of Bucharest
Sponsored by: Matthew Grooms (student scholarships)
Sponsored by: iXsystems
Differential Revision: https://reviews.freebsd.org/D19495
2020-05-05 00:02:04 +00:00
|
|
|
|
2011-05-13 04:54:01 +00:00
|
|
|
#endif /* _VMMAPI_H_ */
|
