| // Copyright 2017 The Fuchsia Authors |
| // |
| // Use of this source code is governed by a MIT-style |
| // license that can be found in the LICENSE file or at |
| // https://opensource.org/licenses/MIT |
| |
| #include <zircon/syscalls/hypervisor.h> |
| |
| #include <object/guest_dispatcher.h> |
| #include <object/handle_owner.h> |
| #include <object/handles.h> |
| #include <object/port_dispatcher.h> |
| #include <object/process_dispatcher.h> |
| #include <object/resources.h> |
| #include <object/vcpu_dispatcher.h> |
| #include <object/vm_object_dispatcher.h> |
| |
| #include <fbl/ref_ptr.h> |
| |
| #include "syscalls_priv.h" |
| |
| zx_status_t sys_guest_create(zx_handle_t resource, uint32_t options, zx_handle_t physmem_vmo, |
| user_ptr<zx_handle_t> out) { |
| if (options != 0u) |
| return ZX_ERR_INVALID_ARGS; |
| |
| zx_status_t status = validate_resource(resource, ZX_RSRC_KIND_HYPERVISOR); |
| if (status != ZX_OK) |
| return status; |
| |
| auto up = ProcessDispatcher::GetCurrent(); |
| fbl::RefPtr<VmObjectDispatcher> physmem; |
| zx_rights_t rights = ZX_RIGHT_READ | ZX_RIGHT_WRITE | ZX_RIGHT_EXECUTE; |
| status = up->GetDispatcherWithRights(physmem_vmo, rights, &physmem); |
| if (status != ZX_OK) |
| return status; |
| |
| fbl::RefPtr<Dispatcher> dispatcher; |
| status = GuestDispatcher::Create(physmem->vmo(), &dispatcher, &rights); |
| if (status != ZX_OK) |
| return status; |
| |
| HandleOwner handle(MakeHandle(fbl::move(dispatcher), rights)); |
| if (!handle) |
| return ZX_ERR_NO_MEMORY; |
| status = out.copy_to_user(up->MapHandleToValue(handle)); |
| if (status != ZX_OK) |
| return ZX_ERR_INVALID_ARGS; |
| |
| up->AddHandle(fbl::move(handle)); |
| return ZX_OK; |
| } |
| |
| zx_status_t sys_guest_set_trap(zx_handle_t guest_handle, uint32_t kind, zx_vaddr_t addr, size_t len, |
| zx_handle_t port_handle, uint64_t key) { |
| auto up = ProcessDispatcher::GetCurrent(); |
| |
| fbl::RefPtr<GuestDispatcher> guest; |
| zx_status_t status = up->GetDispatcherWithRights(guest_handle, ZX_RIGHT_WRITE, &guest); |
| if (status != ZX_OK) |
| return status; |
| |
| fbl::RefPtr<PortDispatcher> port; |
| if (port_handle != ZX_HANDLE_INVALID) { |
| status = up->GetDispatcherWithRights(port_handle, ZX_RIGHT_WRITE, &port); |
| if (status != ZX_OK) |
| return status; |
| } |
| |
| return guest->SetTrap(kind, addr, len, fbl::move(port), key); |
| } |
| |
| zx_status_t sys_vcpu_create(zx_handle_t guest_handle, uint32_t options, |
| user_ptr<const zx_vcpu_create_args_t> _args, |
| user_ptr<zx_handle_t> out) { |
| if (options != 0u) |
| return ZX_ERR_INVALID_ARGS; |
| |
| auto up = ProcessDispatcher::GetCurrent(); |
| fbl::RefPtr<GuestDispatcher> guest; |
| zx_status_t status = up->GetDispatcherWithRights(guest_handle, ZX_RIGHT_WRITE, &guest); |
| if (status != ZX_OK) |
| return status; |
| |
| zx_vcpu_create_args_t args; |
| status = _args.copy_from_user(&args); |
| if (status != ZX_OK) |
| return status; |
| |
| #if ARCH_X86_64 |
| fbl::RefPtr<VmObjectDispatcher> apic; |
| status = up->GetDispatcherWithRights(args.apic_vmo, ZX_RIGHT_READ | ZX_RIGHT_WRITE, &apic); |
| if (status != ZX_OK) |
| return status; |
| |
| fbl::RefPtr<Dispatcher> dispatcher; |
| zx_rights_t rights; |
| status = VcpuDispatcher::Create(guest, args.ip, args.cr3, apic->vmo(), &dispatcher, &rights); |
| if (status != ZX_OK) |
| return status; |
| |
| HandleOwner handle(MakeHandle(fbl::move(dispatcher), rights)); |
| if (!handle) |
| return ZX_ERR_NO_MEMORY; |
| status = out.copy_to_user(up->MapHandleToValue(handle)); |
| if (status != ZX_OK) |
| return ZX_ERR_INVALID_ARGS; |
| |
| up->AddHandle(fbl::move(handle)); |
| return ZX_OK; |
| #else // ARCH_X86_64 |
| return ZX_ERR_NOT_SUPPORTED; |
| #endif |
| } |
| |
| zx_status_t sys_vcpu_resume(zx_handle_t vcpu_handle, user_ptr<zx_port_packet_t> _packet) { |
| auto up = ProcessDispatcher::GetCurrent(); |
| |
| fbl::RefPtr<VcpuDispatcher> vcpu; |
| zx_status_t status = up->GetDispatcherWithRights(vcpu_handle, ZX_RIGHT_EXECUTE, &vcpu); |
| if (status != ZX_OK) |
| return status; |
| |
| zx_port_packet packet; |
| status = vcpu->Resume(&packet); |
| if (status != ZX_OK) |
| return status; |
| |
| status = _packet.copy_to_user(packet); |
| if (status != ZX_OK) |
| return ZX_ERR_INVALID_ARGS; |
| |
| return ZX_OK; |
| } |
| |
| zx_status_t sys_vcpu_interrupt(zx_handle_t vcpu_handle, uint32_t vector) { |
| auto up = ProcessDispatcher::GetCurrent(); |
| |
| fbl::RefPtr<VcpuDispatcher> vcpu; |
| zx_status_t status = up->GetDispatcherWithRights(vcpu_handle, ZX_RIGHT_SIGNAL, &vcpu); |
| if (status != ZX_OK) |
| return status; |
| |
| return vcpu->Interrupt(vector); |
| } |
| |
| zx_status_t sys_vcpu_read_state(zx_handle_t vcpu_handle, uint32_t kind, |
| user_ptr<void> _buffer, uint32_t len) { |
| auto up = ProcessDispatcher::GetCurrent(); |
| |
| fbl::RefPtr<VcpuDispatcher> vcpu; |
| zx_status_t status = up->GetDispatcherWithRights(vcpu_handle, ZX_RIGHT_READ, &vcpu); |
| if (status != ZX_OK) |
| return status; |
| |
| alignas(alignof(zx_vcpu_state_t)) uint8_t buffer[sizeof(zx_vcpu_state_t)]; |
| if (len > sizeof(buffer)) |
| return ZX_ERR_INVALID_ARGS; |
| status = vcpu->ReadState(kind, buffer, len); |
| if (status != ZX_OK) |
| return status; |
| status = _buffer.copy_array_to_user(buffer, len); |
| if (status != ZX_OK) |
| return ZX_ERR_INVALID_ARGS; |
| return ZX_OK; |
| } |
| |
| zx_status_t sys_vcpu_write_state(zx_handle_t vcpu_handle, uint32_t kind, |
| user_ptr<const void> _buffer, uint32_t len) { |
| auto up = ProcessDispatcher::GetCurrent(); |
| |
| fbl::RefPtr<VcpuDispatcher> vcpu; |
| zx_status_t status = up->GetDispatcherWithRights(vcpu_handle, ZX_RIGHT_WRITE, &vcpu); |
| if (status != ZX_OK) |
| return status; |
| |
| uint8_t buffer[sizeof(zx_vcpu_state_t)]; |
| if (len > sizeof(buffer)) |
| return ZX_ERR_INVALID_ARGS; |
| status = _buffer.copy_array_from_user(buffer, len); |
| if (status != ZX_OK) |
| return ZX_ERR_INVALID_ARGS; |
| return vcpu->WriteState(kind, buffer, len); |
| } |