hv

type AddressSpace struct {
	// contains filtered or unexported fields
}

type Arm64GICInfo struct {
	Version              Arm64GICVersion
	DistributorBase      uint64
	DistributorSize      uint64
	RedistributorBase    uint64
	RedistributorSize    uint64
	CpuInterfaceBase     uint64
	CpuInterfaceSize     uint64
	ItsBase              uint64
	ItsSize              uint64
	MaintenanceInterrupt Arm64Interrupt
}

type Arm64GICProvider interface {
	Arm64GICInfo() (Arm64GICInfo, bool)
}

type Arm64GICVersion int

type Arm64Interrupt struct {
	Type  uint32
	Num   uint32
	Flags uint32
}

type CpuArchitecture string

type Device interface {
	Init(vm VirtualMachine) error
}

type DeviceConfig struct {
	ID      string
	Base    uint64
	Size    uint64
	IRQLine uint32
}

type DeviceSnapshot interface {
}

type DeviceSnapshotter interface {
	Device

	DeviceId() string

	CaptureSnapshot() (DeviceSnapshot, error)
	RestoreSnapshot(snap DeviceSnapshot) error
}

type DeviceTemplate interface {
	Create(vm VirtualMachine) (Device, error)
}

type ExitContext interface {
	SetExitTimeslice(id timeslice.TimesliceID)
}

type Hypervisor interface {
	io.Closer

	Architecture() CpuArchitecture

	NewVirtualMachine(config VMConfig) (VirtualMachine, error)
}

type MMIOAllocation struct {
	Name string // Device name
	Base uint64 // Allocated base address
	Size uint64 // Allocated size (may be larger than requested due to alignment)
}

type MMIOAllocationRequest struct {
	Name      string // Device name for debugging/logging
	Size      uint64 // Required size in bytes
	Alignment uint64 // Required alignment (power of 2, e.g., 0x1000 for 4KB)
}

type MMIORegion struct {
	Address uint64
	Size    uint64
}

type MemoryMappedIODevice interface {
	Device

	MMIORegions() []MMIORegion

	ReadMMIO(ctx ExitContext, addr uint64, data []byte) error
	WriteMMIO(ctx ExitContext, addr uint64, data []byte) error
}

type MemoryRegion interface {
	io.ReaderAt
	io.WriterAt

	Size() uint64
}

type Register uint64

type Register64 uint64

type RegisterValue interface {
	// contains filtered or unexported methods
}

type RunConfig interface {
	Run(ctx context.Context, vcpu VirtualCPU) error
}

type SimpleMMIODevice struct {
	Regions []MMIORegion

	ReadFunc  func(ctx ExitContext, addr uint64, data []byte) error
	WriteFunc func(ctx ExitContext, addr uint64, data []byte) error
}

type SimpleVMConfig struct {
	NumCPUs          int
	MemSize          uint64
	MemBase          uint64
	InterruptSupport bool
	VMLoader         VMLoader

	CreateVM           func(vm VirtualMachine) error
	CreateVMWithMemory func(vm VirtualMachine) error
	CreateVCPU         func(vCpu VirtualCPU) error
}

type SimpleX86IOPortDevice struct {
	Ports []uint16

	ReadFunc  func(ctx ExitContext, port uint16, data []byte) error
	WriteFunc func(ctx ExitContext, port uint16, data []byte) error
}

type Snapshot interface {
	io.Closer
}

type VMCallbacks interface {
	OnCreateVM(vm VirtualMachine) error
	OnCreateVMWithMemory(vm VirtualMachine) error
	OnCreateVCPU(vCpu VirtualCPU) error
}

type VMConfig interface {
	CPUCount() int
	MemorySize() uint64
	MemoryBase() uint64
	NeedsInterruptSupport() bool
	Callbacks() VMCallbacks
	Loader() VMLoader
}

type VMConfigHash [32]byte

type VMLoader interface {
	Load(vm VirtualMachine) error
}

type VirtualCPU interface {
	VirtualMachine() VirtualMachine
	ID() int

	SetRegisters(regs map[Register]RegisterValue) error
	GetRegisters(regs map[Register]RegisterValue) error

	Run(ctx context.Context) error
}

type VirtualCPUAmd64 interface {
	VirtualCPU

	SetProtectedMode() error
	SetLongModeWithSelectors(
		pagingBase uint64,
		addrSpaceSize int,
		codeSelector, dataSelector uint16,
	) error
}

type VirtualCPUDebug interface {
	VirtualCPU

	EnableTrace(maxEntries int) error
	GetTraceBuffer() ([]string, error)
}

type VirtualMachine interface {
	io.ReaderAt
	io.WriterAt

	io.Closer

	Hypervisor() Hypervisor

	MemorySize() uint64
	MemoryBase() uint64

	Run(ctx context.Context, cfg RunConfig) error

	SetIRQ(irqLine uint32, level bool) error

	VirtualCPUCall(id int, f func(vcpu VirtualCPU) error) error

	AddDevice(dev Device) error
	AddDeviceFromTemplate(template DeviceTemplate) (Device, error)

	AllocateMemory(physAddr, size uint64) (MemoryRegion, error)

	// AllocateMMIO requests an MMIO region from the VM's physical address allocator.
	// The region is allocated above RAM to avoid conflicts. Returns the allocated
	// base address and size.
	AllocateMMIO(req MMIOAllocationRequest) (MMIOAllocation, error)

	// RegisterFixedMMIO registers a pre-determined MMIO region (for legacy devices
	// like GIC, UART, HPET, IO-APIC). Returns error if the region conflicts with
	// RAM or other allocations.
	RegisterFixedMMIO(name string, base, size uint64) error

	// GetAllocatedMMIORegions returns all dynamically allocated MMIO regions.
	// Used for E820 map and device tree generation.
	GetAllocatedMMIORegions() []MMIOAllocation

	CaptureSnapshot() (Snapshot, error)
	RestoreSnapshot(snap Snapshot) error
}

type VirtualMachineAmd64 interface {
	VirtualMachine

	SetIRQ(irqLine uint32, level bool) error
}

type X86IOPortDevice interface {
	Device

	IOPorts() []uint16

	ReadIOPort(ctx ExitContext, port uint16, data []byte) error
	WriteIOPort(ctx ExitContext, port uint16, data []byte) error
}