2 * Copyright (c) 2011 NetApp, Inc.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY NETAPP, INC ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL NETAPP, INC OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
32 #include <sys/param.h>
33 #include <sys/sysctl.h>
34 #include <sys/ioctl.h>
36 #include <sys/_iovec.h>
37 #include <sys/cpuset.h>
39 #include <x86/segments.h>
40 #include <machine/specialreg.h>
52 #include <machine/vmm.h>
53 #include <machine/vmm_dev.h>
57 #define MB (1024 * 1024UL)
58 #define GB (1024 * 1024 * 1024UL)
61 * Size of the guard region before and after the virtual address space
62 * mapping the guest physical memory. This must be a multiple of the
63 * superpage size for performance reasons.
65 #define VM_MMAP_GUARD_SIZE (4 * MB)
67 #define PROT_RW (PROT_READ | PROT_WRITE)
68 #define PROT_ALL (PROT_READ | PROT_WRITE | PROT_EXEC)
72 uint32_t lowmem_limit
;
80 #define CREATE(x) sysctlbyname("hw.vmm.create", NULL, NULL, (x), strlen((x)))
81 #define DESTROY(x) sysctlbyname("hw.vmm.destroy", NULL, NULL, (x), strlen((x)))
84 vm_device_open(const char *name
)
89 len
= strlen("/dev/vmm/") + strlen(name
) + 1;
91 assert(vmfile
!= NULL
);
92 snprintf(vmfile
, len
, "/dev/vmm/%s", name
);
94 /* Open the device file */
95 fd
= open(vmfile
, O_RDWR
, 0);
102 vm_create(const char *name
)
105 return (CREATE((char *)name
));
109 vm_open(const char *name
)
113 vm
= malloc(sizeof(struct vmctx
) + strlen(name
) + 1);
118 vm
->lowmem_limit
= 3 * GB
;
119 vm
->name
= (char *)(vm
+ 1);
120 strcpy(vm
->name
, name
);
122 if ((vm
->fd
= vm_device_open(vm
->name
)) < 0)
132 vm_destroy(struct vmctx
*vm
)
144 vm_parse_memsize(const char *optarg
, size_t *ret_memsize
)
150 optval
= strtoul(optarg
, &endptr
, 0);
151 if (*optarg
!= '\0' && *endptr
== '\0') {
153 * For the sake of backward compatibility if the memory size
154 * specified on the command line is less than a megabyte then
155 * it is interpreted as being in units of MB.
159 *ret_memsize
= optval
;
162 error
= expand_number(optarg
, ret_memsize
);
168 vm_get_lowmem_limit(struct vmctx
*ctx
)
171 return (ctx
->lowmem_limit
);
175 vm_set_lowmem_limit(struct vmctx
*ctx
, uint32_t limit
)
178 ctx
->lowmem_limit
= limit
;
182 vm_set_memflags(struct vmctx
*ctx
, int flags
)
185 ctx
->memflags
= flags
;
189 vm_get_memflags(struct vmctx
*ctx
)
192 return (ctx
->memflags
);
196 * Map segment 'segid' starting at 'off' into guest address range [gpa,gpa+len).
199 vm_mmap_memseg(struct vmctx
*ctx
, vm_paddr_t gpa
, int segid
, vm_ooffset_t off
,
200 size_t len
, int prot
)
202 struct vm_memmap memmap
;
206 memmap
.segid
= segid
;
212 if (ctx
->memflags
& VM_MEM_F_WIRED
)
213 memmap
.flags
|= VM_MEMMAP_F_WIRED
;
216 * If this mapping already exists then don't create it again. This
217 * is the common case for SYSMEM mappings created by bhyveload(8).
219 error
= vm_mmap_getnext(ctx
, &gpa
, &segid
, &off
, &len
, &prot
, &flags
);
220 if (error
== 0 && gpa
== memmap
.gpa
) {
221 if (segid
!= memmap
.segid
|| off
!= memmap
.segoff
||
222 prot
!= memmap
.prot
|| flags
!= memmap
.flags
) {
230 error
= ioctl(ctx
->fd
, VM_MMAP_MEMSEG
, &memmap
);
235 vm_mmap_getnext(struct vmctx
*ctx
, vm_paddr_t
*gpa
, int *segid
,
236 vm_ooffset_t
*segoff
, size_t *len
, int *prot
, int *flags
)
238 struct vm_memmap memmap
;
241 bzero(&memmap
, sizeof(struct vm_memmap
));
243 error
= ioctl(ctx
->fd
, VM_MMAP_GETNEXT
, &memmap
);
246 *segid
= memmap
.segid
;
247 *segoff
= memmap
.segoff
;
250 *flags
= memmap
.flags
;
256 * Return 0 if the segments are identical and non-zero otherwise.
258 * This is slightly complicated by the fact that only device memory segments
262 cmpseg(size_t len
, const char *str
, size_t len2
, const char *str2
)
266 if ((!str
&& !str2
) || (str
&& str2
&& !strcmp(str
, str2
)))
273 vm_alloc_memseg(struct vmctx
*ctx
, int segid
, size_t len
, const char *name
)
275 struct vm_memseg memseg
;
280 * If the memory segment has already been created then just return.
281 * This is the usual case for the SYSMEM segment created by userspace
282 * loaders like bhyveload(8).
284 error
= vm_get_memseg(ctx
, segid
, &memseg
.len
, memseg
.name
,
285 sizeof(memseg
.name
));
289 if (memseg
.len
!= 0) {
290 if (cmpseg(len
, name
, memseg
.len
, VM_MEMSEG_NAME(&memseg
))) {
298 bzero(&memseg
, sizeof(struct vm_memseg
));
299 memseg
.segid
= segid
;
302 n
= strlcpy(memseg
.name
, name
, sizeof(memseg
.name
));
303 if (n
>= sizeof(memseg
.name
)) {
304 errno
= ENAMETOOLONG
;
309 error
= ioctl(ctx
->fd
, VM_ALLOC_MEMSEG
, &memseg
);
314 vm_get_memseg(struct vmctx
*ctx
, int segid
, size_t *lenp
, char *namebuf
,
317 struct vm_memseg memseg
;
321 memseg
.segid
= segid
;
322 error
= ioctl(ctx
->fd
, VM_GET_MEMSEG
, &memseg
);
325 n
= strlcpy(namebuf
, memseg
.name
, bufsize
);
327 errno
= ENAMETOOLONG
;
335 setup_memory_segment(struct vmctx
*ctx
, vm_paddr_t gpa
, size_t len
, char *base
)
340 /* Map 'len' bytes starting at 'gpa' in the guest address space */
341 error
= vm_mmap_memseg(ctx
, gpa
, VM_SYSMEM
, gpa
, len
, PROT_ALL
);
345 flags
= MAP_SHARED
| MAP_FIXED
;
346 if ((ctx
->memflags
& VM_MEM_F_INCORE
) == 0)
349 /* mmap into the process address space on the host */
350 ptr
= mmap(base
+ gpa
, len
, PROT_RW
, flags
, ctx
->fd
, gpa
);
351 if (ptr
== MAP_FAILED
)
358 vm_setup_memory(struct vmctx
*ctx
, size_t memsize
, enum vm_mmap_style vms
)
362 char *baseaddr
, *ptr
;
365 assert(vms
== VM_MMAP_ALL
);
368 * If 'memsize' cannot fit entirely in the 'lowmem' segment then
369 * create another 'highmem' segment above 4GB for the remainder.
371 if (memsize
> ctx
->lowmem_limit
) {
372 ctx
->lowmem
= ctx
->lowmem_limit
;
373 ctx
->highmem
= memsize
- ctx
->lowmem_limit
;
374 objsize
= 4*GB
+ ctx
->highmem
;
376 ctx
->lowmem
= memsize
;
378 objsize
= ctx
->lowmem
;
381 error
= vm_alloc_memseg(ctx
, VM_SYSMEM
, objsize
, NULL
);
386 * Stake out a contiguous region covering the guest physical memory
387 * and the adjoining guard regions.
389 len
= VM_MMAP_GUARD_SIZE
+ objsize
+ VM_MMAP_GUARD_SIZE
;
390 flags
= MAP_PRIVATE
| MAP_ANON
| MAP_NOCORE
| MAP_ALIGNED_SUPER
;
391 ptr
= mmap(NULL
, len
, PROT_NONE
, flags
, -1, 0);
392 if (ptr
== MAP_FAILED
)
395 baseaddr
= ptr
+ VM_MMAP_GUARD_SIZE
;
396 if (ctx
->highmem
> 0) {
399 error
= setup_memory_segment(ctx
, gpa
, len
, baseaddr
);
404 if (ctx
->lowmem
> 0) {
407 error
= setup_memory_segment(ctx
, gpa
, len
, baseaddr
);
412 ctx
->baseaddr
= baseaddr
;
418 * Returns a non-NULL pointer if [gaddr, gaddr+len) is entirely contained in
419 * the lowmem or highmem regions.
421 * In particular return NULL if [gaddr, gaddr+len) falls in guest MMIO region.
422 * The instruction emulation code depends on this behavior.
425 vm_map_gpa(struct vmctx
*ctx
, vm_paddr_t gaddr
, size_t len
)
428 if (ctx
->lowmem
> 0) {
429 if (gaddr
< ctx
->lowmem
&& gaddr
+ len
<= ctx
->lowmem
)
430 return (ctx
->baseaddr
+ gaddr
);
433 if (ctx
->highmem
> 0) {
434 if (gaddr
>= 4*GB
&& gaddr
+ len
<= 4*GB
+ ctx
->highmem
)
435 return (ctx
->baseaddr
+ gaddr
);
442 vm_get_lowmem_size(struct vmctx
*ctx
)
445 return (ctx
->lowmem
);
449 vm_get_highmem_size(struct vmctx
*ctx
)
452 return (ctx
->highmem
);
456 vm_create_devmem(struct vmctx
*ctx
, int segid
, const char *name
, size_t len
)
458 char pathname
[MAXPATHLEN
];
461 int fd
, error
, flags
;
465 if (name
== NULL
|| strlen(name
) == 0) {
470 error
= vm_alloc_memseg(ctx
, segid
, len
, name
);
474 strlcpy(pathname
, "/dev/vmm.io/", sizeof(pathname
));
475 strlcat(pathname
, ctx
->name
, sizeof(pathname
));
476 strlcat(pathname
, ".", sizeof(pathname
));
477 strlcat(pathname
, name
, sizeof(pathname
));
479 fd
= open(pathname
, O_RDWR
);
484 * Stake out a contiguous region covering the device memory and the
485 * adjoining guard regions.
487 len2
= VM_MMAP_GUARD_SIZE
+ len
+ VM_MMAP_GUARD_SIZE
;
488 flags
= MAP_PRIVATE
| MAP_ANON
| MAP_NOCORE
| MAP_ALIGNED_SUPER
;
489 base
= mmap(NULL
, len2
, PROT_NONE
, flags
, -1, 0);
490 if (base
== MAP_FAILED
)
493 flags
= MAP_SHARED
| MAP_FIXED
;
494 if ((ctx
->memflags
& VM_MEM_F_INCORE
) == 0)
497 /* mmap the devmem region in the host address space */
498 ptr
= mmap(base
+ VM_MMAP_GUARD_SIZE
, len
, PROT_RW
, flags
, fd
, 0);
506 vm_set_desc(struct vmctx
*ctx
, int vcpu
, int reg
,
507 uint64_t base
, uint32_t limit
, uint32_t access
)
510 struct vm_seg_desc vmsegdesc
;
512 bzero(&vmsegdesc
, sizeof(vmsegdesc
));
513 vmsegdesc
.cpuid
= vcpu
;
514 vmsegdesc
.regnum
= reg
;
515 vmsegdesc
.desc
.base
= base
;
516 vmsegdesc
.desc
.limit
= limit
;
517 vmsegdesc
.desc
.access
= access
;
519 error
= ioctl(ctx
->fd
, VM_SET_SEGMENT_DESCRIPTOR
, &vmsegdesc
);
524 vm_get_desc(struct vmctx
*ctx
, int vcpu
, int reg
,
525 uint64_t *base
, uint32_t *limit
, uint32_t *access
)
528 struct vm_seg_desc vmsegdesc
;
530 bzero(&vmsegdesc
, sizeof(vmsegdesc
));
531 vmsegdesc
.cpuid
= vcpu
;
532 vmsegdesc
.regnum
= reg
;
534 error
= ioctl(ctx
->fd
, VM_GET_SEGMENT_DESCRIPTOR
, &vmsegdesc
);
536 *base
= vmsegdesc
.desc
.base
;
537 *limit
= vmsegdesc
.desc
.limit
;
538 *access
= vmsegdesc
.desc
.access
;
544 vm_get_seg_desc(struct vmctx
*ctx
, int vcpu
, int reg
, struct seg_desc
*seg_desc
)
548 error
= vm_get_desc(ctx
, vcpu
, reg
, &seg_desc
->base
, &seg_desc
->limit
,
554 vm_set_register(struct vmctx
*ctx
, int vcpu
, int reg
, uint64_t val
)
557 struct vm_register vmreg
;
559 bzero(&vmreg
, sizeof(vmreg
));
564 error
= ioctl(ctx
->fd
, VM_SET_REGISTER
, &vmreg
);
569 vm_get_register(struct vmctx
*ctx
, int vcpu
, int reg
, uint64_t *ret_val
)
572 struct vm_register vmreg
;
574 bzero(&vmreg
, sizeof(vmreg
));
578 error
= ioctl(ctx
->fd
, VM_GET_REGISTER
, &vmreg
);
579 *ret_val
= vmreg
.regval
;
584 vm_run(struct vmctx
*ctx
, int vcpu
, struct vm_exit
*vmexit
)
589 bzero(&vmrun
, sizeof(vmrun
));
592 error
= ioctl(ctx
->fd
, VM_RUN
, &vmrun
);
593 bcopy(&vmrun
.vm_exit
, vmexit
, sizeof(struct vm_exit
));
598 vm_suspend(struct vmctx
*ctx
, enum vm_suspend_how how
)
600 struct vm_suspend vmsuspend
;
602 bzero(&vmsuspend
, sizeof(vmsuspend
));
604 return (ioctl(ctx
->fd
, VM_SUSPEND
, &vmsuspend
));
608 vm_reinit(struct vmctx
*ctx
)
611 return (ioctl(ctx
->fd
, VM_REINIT
, 0));
615 vm_inject_exception(struct vmctx
*ctx
, int vcpu
, int vector
, int errcode_valid
,
616 uint32_t errcode
, int restart_instruction
)
618 struct vm_exception exc
;
622 exc
.error_code
= errcode
;
623 exc
.error_code_valid
= errcode_valid
;
624 exc
.restart_instruction
= restart_instruction
;
626 return (ioctl(ctx
->fd
, VM_INJECT_EXCEPTION
, &exc
));
630 vm_apicid2vcpu(struct vmctx
*ctx
, int apicid
)
633 * The apic id associated with the 'vcpu' has the same numerical value
634 * as the 'vcpu' itself.
640 vm_lapic_irq(struct vmctx
*ctx
, int vcpu
, int vector
)
642 struct vm_lapic_irq vmirq
;
644 bzero(&vmirq
, sizeof(vmirq
));
646 vmirq
.vector
= vector
;
648 return (ioctl(ctx
->fd
, VM_LAPIC_IRQ
, &vmirq
));
652 vm_lapic_local_irq(struct vmctx
*ctx
, int vcpu
, int vector
)
654 struct vm_lapic_irq vmirq
;
656 bzero(&vmirq
, sizeof(vmirq
));
658 vmirq
.vector
= vector
;
660 return (ioctl(ctx
->fd
, VM_LAPIC_LOCAL_IRQ
, &vmirq
));
664 vm_lapic_msi(struct vmctx
*ctx
, uint64_t addr
, uint64_t msg
)
666 struct vm_lapic_msi vmmsi
;
668 bzero(&vmmsi
, sizeof(vmmsi
));
672 return (ioctl(ctx
->fd
, VM_LAPIC_MSI
, &vmmsi
));
676 vm_ioapic_assert_irq(struct vmctx
*ctx
, int irq
)
678 struct vm_ioapic_irq ioapic_irq
;
680 bzero(&ioapic_irq
, sizeof(struct vm_ioapic_irq
));
681 ioapic_irq
.irq
= irq
;
683 return (ioctl(ctx
->fd
, VM_IOAPIC_ASSERT_IRQ
, &ioapic_irq
));
687 vm_ioapic_deassert_irq(struct vmctx
*ctx
, int irq
)
689 struct vm_ioapic_irq ioapic_irq
;
691 bzero(&ioapic_irq
, sizeof(struct vm_ioapic_irq
));
692 ioapic_irq
.irq
= irq
;
694 return (ioctl(ctx
->fd
, VM_IOAPIC_DEASSERT_IRQ
, &ioapic_irq
));
698 vm_ioapic_pulse_irq(struct vmctx
*ctx
, int irq
)
700 struct vm_ioapic_irq ioapic_irq
;
702 bzero(&ioapic_irq
, sizeof(struct vm_ioapic_irq
));
703 ioapic_irq
.irq
= irq
;
705 return (ioctl(ctx
->fd
, VM_IOAPIC_PULSE_IRQ
, &ioapic_irq
));
709 vm_ioapic_pincount(struct vmctx
*ctx
, int *pincount
)
712 return (ioctl(ctx
->fd
, VM_IOAPIC_PINCOUNT
, pincount
));
716 vm_isa_assert_irq(struct vmctx
*ctx
, int atpic_irq
, int ioapic_irq
)
718 struct vm_isa_irq isa_irq
;
720 bzero(&isa_irq
, sizeof(struct vm_isa_irq
));
721 isa_irq
.atpic_irq
= atpic_irq
;
722 isa_irq
.ioapic_irq
= ioapic_irq
;
724 return (ioctl(ctx
->fd
, VM_ISA_ASSERT_IRQ
, &isa_irq
));
728 vm_isa_deassert_irq(struct vmctx
*ctx
, int atpic_irq
, int ioapic_irq
)
730 struct vm_isa_irq isa_irq
;
732 bzero(&isa_irq
, sizeof(struct vm_isa_irq
));
733 isa_irq
.atpic_irq
= atpic_irq
;
734 isa_irq
.ioapic_irq
= ioapic_irq
;
736 return (ioctl(ctx
->fd
, VM_ISA_DEASSERT_IRQ
, &isa_irq
));
740 vm_isa_pulse_irq(struct vmctx
*ctx
, int atpic_irq
, int ioapic_irq
)
742 struct vm_isa_irq isa_irq
;
744 bzero(&isa_irq
, sizeof(struct vm_isa_irq
));
745 isa_irq
.atpic_irq
= atpic_irq
;
746 isa_irq
.ioapic_irq
= ioapic_irq
;
748 return (ioctl(ctx
->fd
, VM_ISA_PULSE_IRQ
, &isa_irq
));
752 vm_isa_set_irq_trigger(struct vmctx
*ctx
, int atpic_irq
,
753 enum vm_intr_trigger trigger
)
755 struct vm_isa_irq_trigger isa_irq_trigger
;
757 bzero(&isa_irq_trigger
, sizeof(struct vm_isa_irq_trigger
));
758 isa_irq_trigger
.atpic_irq
= atpic_irq
;
759 isa_irq_trigger
.trigger
= trigger
;
761 return (ioctl(ctx
->fd
, VM_ISA_SET_IRQ_TRIGGER
, &isa_irq_trigger
));
765 vm_inject_nmi(struct vmctx
*ctx
, int vcpu
)
769 bzero(&vmnmi
, sizeof(vmnmi
));
772 return (ioctl(ctx
->fd
, VM_INJECT_NMI
, &vmnmi
));
779 { "hlt_exit", VM_CAP_HALT_EXIT
},
780 { "mtrap_exit", VM_CAP_MTRAP_EXIT
},
781 { "pause_exit", VM_CAP_PAUSE_EXIT
},
782 { "unrestricted_guest", VM_CAP_UNRESTRICTED_GUEST
},
783 { "enable_invpcid", VM_CAP_ENABLE_INVPCID
},
788 vm_capability_name2type(const char *capname
)
792 for (i
= 0; capstrmap
[i
].name
!= NULL
&& capname
!= NULL
; i
++) {
793 if (strcmp(capstrmap
[i
].name
, capname
) == 0)
794 return (capstrmap
[i
].type
);
801 vm_capability_type2name(int type
)
805 for (i
= 0; capstrmap
[i
].name
!= NULL
; i
++) {
806 if (capstrmap
[i
].type
== type
)
807 return (capstrmap
[i
].name
);
814 vm_get_capability(struct vmctx
*ctx
, int vcpu
, enum vm_cap_type cap
,
818 struct vm_capability vmcap
;
820 bzero(&vmcap
, sizeof(vmcap
));
824 error
= ioctl(ctx
->fd
, VM_GET_CAPABILITY
, &vmcap
);
825 *retval
= vmcap
.capval
;
830 vm_set_capability(struct vmctx
*ctx
, int vcpu
, enum vm_cap_type cap
, int val
)
832 struct vm_capability vmcap
;
834 bzero(&vmcap
, sizeof(vmcap
));
839 return (ioctl(ctx
->fd
, VM_SET_CAPABILITY
, &vmcap
));
843 vm_assign_pptdev(struct vmctx
*ctx
, int bus
, int slot
, int func
)
845 struct vm_pptdev pptdev
;
847 bzero(&pptdev
, sizeof(pptdev
));
852 return (ioctl(ctx
->fd
, VM_BIND_PPTDEV
, &pptdev
));
856 vm_unassign_pptdev(struct vmctx
*ctx
, int bus
, int slot
, int func
)
858 struct vm_pptdev pptdev
;
860 bzero(&pptdev
, sizeof(pptdev
));
865 return (ioctl(ctx
->fd
, VM_UNBIND_PPTDEV
, &pptdev
));
869 vm_map_pptdev_mmio(struct vmctx
*ctx
, int bus
, int slot
, int func
,
870 vm_paddr_t gpa
, size_t len
, vm_paddr_t hpa
)
872 struct vm_pptdev_mmio pptmmio
;
874 bzero(&pptmmio
, sizeof(pptmmio
));
882 return (ioctl(ctx
->fd
, VM_MAP_PPTDEV_MMIO
, &pptmmio
));
886 vm_setup_pptdev_msi(struct vmctx
*ctx
, int vcpu
, int bus
, int slot
, int func
,
887 uint64_t addr
, uint64_t msg
, int numvec
)
889 struct vm_pptdev_msi pptmsi
;
891 bzero(&pptmsi
, sizeof(pptmsi
));
898 pptmsi
.numvec
= numvec
;
900 return (ioctl(ctx
->fd
, VM_PPTDEV_MSI
, &pptmsi
));
904 vm_setup_pptdev_msix(struct vmctx
*ctx
, int vcpu
, int bus
, int slot
, int func
,
905 int idx
, uint64_t addr
, uint64_t msg
, uint32_t vector_control
)
907 struct vm_pptdev_msix pptmsix
;
909 bzero(&pptmsix
, sizeof(pptmsix
));
917 pptmsix
.vector_control
= vector_control
;
919 return ioctl(ctx
->fd
, VM_PPTDEV_MSIX
, &pptmsix
);
923 vm_get_stats(struct vmctx
*ctx
, int vcpu
, struct timeval
*ret_tv
,
928 static struct vm_stats vmstats
;
930 vmstats
.cpuid
= vcpu
;
932 error
= ioctl(ctx
->fd
, VM_STATS
, &vmstats
);
935 *ret_entries
= vmstats
.num_entries
;
937 *ret_tv
= vmstats
.tv
;
938 return (vmstats
.statbuf
);
944 vm_get_stat_desc(struct vmctx
*ctx
, int index
)
946 static struct vm_stat_desc statdesc
;
948 statdesc
.index
= index
;
949 if (ioctl(ctx
->fd
, VM_STAT_DESC
, &statdesc
) == 0)
950 return (statdesc
.desc
);
956 vm_get_x2apic_state(struct vmctx
*ctx
, int vcpu
, enum x2apic_state
*state
)
959 struct vm_x2apic x2apic
;
961 bzero(&x2apic
, sizeof(x2apic
));
964 error
= ioctl(ctx
->fd
, VM_GET_X2APIC_STATE
, &x2apic
);
965 *state
= x2apic
.state
;
970 vm_set_x2apic_state(struct vmctx
*ctx
, int vcpu
, enum x2apic_state state
)
973 struct vm_x2apic x2apic
;
975 bzero(&x2apic
, sizeof(x2apic
));
977 x2apic
.state
= state
;
979 error
= ioctl(ctx
->fd
, VM_SET_X2APIC_STATE
, &x2apic
);
986 * Table 9-1. IA-32 Processor States Following Power-up, Reset or INIT
989 vcpu_reset(struct vmctx
*vmctx
, int vcpu
)
992 uint64_t rflags
, rip
, cr0
, cr4
, zero
, desc_base
, rdx
;
993 uint32_t desc_access
, desc_limit
;
999 error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_RFLAGS
, rflags
);
1004 if ((error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_RIP
, rip
)) != 0)
1008 if ((error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_CR0
, cr0
)) != 0)
1011 if ((error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_CR3
, zero
)) != 0)
1015 if ((error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_CR4
, cr4
)) != 0)
1019 * CS: present, r/w, accessed, 16-bit, byte granularity, usable
1021 desc_base
= 0xffff0000;
1022 desc_limit
= 0xffff;
1023 desc_access
= 0x0093;
1024 error
= vm_set_desc(vmctx
, vcpu
, VM_REG_GUEST_CS
,
1025 desc_base
, desc_limit
, desc_access
);
1030 if ((error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_CS
, sel
)) != 0)
1034 * SS,DS,ES,FS,GS: present, r/w, accessed, 16-bit, byte granularity
1037 desc_limit
= 0xffff;
1038 desc_access
= 0x0093;
1039 error
= vm_set_desc(vmctx
, vcpu
, VM_REG_GUEST_SS
,
1040 desc_base
, desc_limit
, desc_access
);
1044 error
= vm_set_desc(vmctx
, vcpu
, VM_REG_GUEST_DS
,
1045 desc_base
, desc_limit
, desc_access
);
1049 error
= vm_set_desc(vmctx
, vcpu
, VM_REG_GUEST_ES
,
1050 desc_base
, desc_limit
, desc_access
);
1054 error
= vm_set_desc(vmctx
, vcpu
, VM_REG_GUEST_FS
,
1055 desc_base
, desc_limit
, desc_access
);
1059 error
= vm_set_desc(vmctx
, vcpu
, VM_REG_GUEST_GS
,
1060 desc_base
, desc_limit
, desc_access
);
1065 if ((error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_SS
, sel
)) != 0)
1067 if ((error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_DS
, sel
)) != 0)
1069 if ((error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_ES
, sel
)) != 0)
1071 if ((error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_FS
, sel
)) != 0)
1073 if ((error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_GS
, sel
)) != 0)
1076 /* General purpose registers */
1078 if ((error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_RAX
, zero
)) != 0)
1080 if ((error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_RBX
, zero
)) != 0)
1082 if ((error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_RCX
, zero
)) != 0)
1084 if ((error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_RDX
, rdx
)) != 0)
1086 if ((error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_RSI
, zero
)) != 0)
1088 if ((error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_RDI
, zero
)) != 0)
1090 if ((error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_RBP
, zero
)) != 0)
1092 if ((error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_RSP
, zero
)) != 0)
1097 desc_limit
= 0xffff;
1099 error
= vm_set_desc(vmctx
, vcpu
, VM_REG_GUEST_GDTR
,
1100 desc_base
, desc_limit
, desc_access
);
1104 error
= vm_set_desc(vmctx
, vcpu
, VM_REG_GUEST_IDTR
,
1105 desc_base
, desc_limit
, desc_access
);
1111 desc_limit
= 0xffff;
1112 desc_access
= 0x0000008b;
1113 error
= vm_set_desc(vmctx
, vcpu
, VM_REG_GUEST_TR
, 0, 0, desc_access
);
1118 if ((error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_TR
, sel
)) != 0)
1123 desc_limit
= 0xffff;
1124 desc_access
= 0x00000082;
1125 error
= vm_set_desc(vmctx
, vcpu
, VM_REG_GUEST_LDTR
, desc_base
,
1126 desc_limit
, desc_access
);
1131 if ((error
= vm_set_register(vmctx
, vcpu
, VM_REG_GUEST_LDTR
, 0)) != 0)
1134 /* XXX cr2, debug registers */
1142 vm_get_gpa_pmap(struct vmctx
*ctx
, uint64_t gpa
, uint64_t *pte
, int *num
)
1145 struct vm_gpa_pte gpapte
;
1147 bzero(&gpapte
, sizeof(gpapte
));
1150 error
= ioctl(ctx
->fd
, VM_GET_GPA_PMAP
, &gpapte
);
1153 *num
= gpapte
.ptenum
;
1154 for (i
= 0; i
< gpapte
.ptenum
; i
++)
1155 pte
[i
] = gpapte
.pte
[i
];
1162 vm_get_hpet_capabilities(struct vmctx
*ctx
, uint32_t *capabilities
)
1165 struct vm_hpet_cap cap
;
1167 bzero(&cap
, sizeof(struct vm_hpet_cap
));
1168 error
= ioctl(ctx
->fd
, VM_GET_HPET_CAPABILITIES
, &cap
);
1169 if (capabilities
!= NULL
)
1170 *capabilities
= cap
.capabilities
;
1175 vm_gla2gpa(struct vmctx
*ctx
, int vcpu
, struct vm_guest_paging
*paging
,
1176 uint64_t gla
, int prot
, uint64_t *gpa
, int *fault
)
1178 struct vm_gla2gpa gg
;
1181 bzero(&gg
, sizeof(struct vm_gla2gpa
));
1185 gg
.paging
= *paging
;
1187 error
= ioctl(ctx
->fd
, VM_GLA2GPA
, &gg
);
1196 #define min(a,b) (((a) < (b)) ? (a) : (b))
1200 vm_copy_setup(struct vmctx
*ctx
, int vcpu
, struct vm_guest_paging
*paging
,
1201 uint64_t gla
, size_t len
, int prot
, struct iovec
*iov
, int iovcnt
,
1206 int error
, i
, n
, off
;
1208 for (i
= 0; i
< iovcnt
; i
++) {
1209 iov
[i
].iov_base
= 0;
1215 error
= vm_gla2gpa(ctx
, vcpu
, paging
, gla
, prot
, &gpa
, fault
);
1216 if (error
|| *fault
)
1219 off
= gpa
& PAGE_MASK
;
1220 n
= min(len
, PAGE_SIZE
- off
);
1222 va
= vm_map_gpa(ctx
, gpa
, n
);
1238 vm_copy_teardown(struct vmctx
*ctx
, int vcpu
, struct iovec
*iov
, int iovcnt
)
1245 vm_copyin(struct vmctx
*ctx
, int vcpu
, struct iovec
*iov
, void *vp
, size_t len
)
1253 assert(iov
->iov_len
);
1254 n
= min(len
, iov
->iov_len
);
1255 src
= iov
->iov_base
;
1265 vm_copyout(struct vmctx
*ctx
, int vcpu
, const void *vp
, struct iovec
*iov
,
1274 assert(iov
->iov_len
);
1275 n
= min(len
, iov
->iov_len
);
1276 dst
= iov
->iov_base
;
1286 vm_get_cpus(struct vmctx
*ctx
, int which
, cpuset_t
*cpus
)
1288 struct vm_cpuset vm_cpuset
;
1291 bzero(&vm_cpuset
, sizeof(struct vm_cpuset
));
1292 vm_cpuset
.which
= which
;
1293 vm_cpuset
.cpusetsize
= sizeof(cpuset_t
);
1294 vm_cpuset
.cpus
= cpus
;
1296 error
= ioctl(ctx
->fd
, VM_GET_CPUS
, &vm_cpuset
);
1301 vm_active_cpus(struct vmctx
*ctx
, cpuset_t
*cpus
)
1304 return (vm_get_cpus(ctx
, VM_ACTIVE_CPUS
, cpus
));
1308 vm_suspended_cpus(struct vmctx
*ctx
, cpuset_t
*cpus
)
1311 return (vm_get_cpus(ctx
, VM_SUSPENDED_CPUS
, cpus
));
1315 vm_activate_cpu(struct vmctx
*ctx
, int vcpu
)
1317 struct vm_activate_cpu ac
;
1320 bzero(&ac
, sizeof(struct vm_activate_cpu
));
1322 error
= ioctl(ctx
->fd
, VM_ACTIVATE_CPU
, &ac
);
1327 vm_get_intinfo(struct vmctx
*ctx
, int vcpu
, uint64_t *info1
, uint64_t *info2
)
1329 struct vm_intinfo vmii
;
1332 bzero(&vmii
, sizeof(struct vm_intinfo
));
1334 error
= ioctl(ctx
->fd
, VM_GET_INTINFO
, &vmii
);
1336 *info1
= vmii
.info1
;
1337 *info2
= vmii
.info2
;
1343 vm_set_intinfo(struct vmctx
*ctx
, int vcpu
, uint64_t info1
)
1345 struct vm_intinfo vmii
;
1348 bzero(&vmii
, sizeof(struct vm_intinfo
));
1351 error
= ioctl(ctx
->fd
, VM_SET_INTINFO
, &vmii
);
1356 vm_rtc_write(struct vmctx
*ctx
, int offset
, uint8_t value
)
1358 struct vm_rtc_data rtcdata
;
1361 bzero(&rtcdata
, sizeof(struct vm_rtc_data
));
1362 rtcdata
.offset
= offset
;
1363 rtcdata
.value
= value
;
1364 error
= ioctl(ctx
->fd
, VM_RTC_WRITE
, &rtcdata
);
1369 vm_rtc_read(struct vmctx
*ctx
, int offset
, uint8_t *retval
)
1371 struct vm_rtc_data rtcdata
;
1374 bzero(&rtcdata
, sizeof(struct vm_rtc_data
));
1375 rtcdata
.offset
= offset
;
1376 error
= ioctl(ctx
->fd
, VM_RTC_READ
, &rtcdata
);
1378 *retval
= rtcdata
.value
;
1383 vm_rtc_settime(struct vmctx
*ctx
, time_t secs
)
1385 struct vm_rtc_time rtctime
;
1388 bzero(&rtctime
, sizeof(struct vm_rtc_time
));
1389 rtctime
.secs
= secs
;
1390 error
= ioctl(ctx
->fd
, VM_RTC_SETTIME
, &rtctime
);
1395 vm_rtc_gettime(struct vmctx
*ctx
, time_t *secs
)
1397 struct vm_rtc_time rtctime
;
1400 bzero(&rtctime
, sizeof(struct vm_rtc_time
));
1401 error
= ioctl(ctx
->fd
, VM_RTC_GETTIME
, &rtctime
);
1403 *secs
= rtctime
.secs
;
1408 vm_restart_instruction(void *arg
, int vcpu
)
1410 struct vmctx
*ctx
= arg
;
1412 return (ioctl(ctx
->fd
, VM_RESTART_INSTRUCTION
, &vcpu
));