Home | History | Annotate | Line # | Download | only in nvmm
nvmm.c revision 1.22 
      1 /*	$NetBSD: nvmm.c,v 1.22 2019/07/06 05:13:10 maxv Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 2018-2019 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Maxime Villard.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29  * POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 #include <sys/cdefs.h>
     33 __KERNEL_RCSID(0, "$NetBSD: nvmm.c,v 1.22 2019/07/06 05:13:10 maxv Exp $");
     34 
     35 #include <sys/param.h>
     36 #include <sys/systm.h>
     37 #include <sys/kernel.h>
     38 
     39 #include <sys/cpu.h>
     40 #include <sys/conf.h>
     41 #include <sys/kmem.h>
     42 #include <sys/module.h>
     43 #include <sys/proc.h>
     44 #include <sys/mman.h>
     45 #include <sys/file.h>
     46 #include <sys/filedesc.h>
     47 #include <sys/kauth.h>
     48 
     49 #include <uvm/uvm.h>
     50 #include <uvm/uvm_page.h>
     51 
     52 #include "ioconf.h"
     53 
     54 #include <dev/nvmm/nvmm.h>
     55 #include <dev/nvmm/nvmm_internal.h>
     56 #include <dev/nvmm/nvmm_ioctl.h>
     57 
     58 static struct nvmm_machine machines[NVMM_MAX_MACHINES];
     59 static volatile unsigned int nmachines __cacheline_aligned;
     60 
     61 static const struct nvmm_impl *nvmm_impl_list[] = {
     62 	&nvmm_x86_svm,	/* x86 AMD SVM */
     63 	&nvmm_x86_vmx	/* x86 Intel VMX */
     64 };
     65 
     66 static const struct nvmm_impl *nvmm_impl = NULL;
     67 
     68 static struct nvmm_owner root_owner;
     69 
     70 /* -------------------------------------------------------------------------- */
     71 
     72 static int
     73 nvmm_machine_alloc(struct nvmm_machine **ret)
     74 {
     75 	struct nvmm_machine *mach;
     76 	size_t i;
     77 
     78 	for (i = 0; i < NVMM_MAX_MACHINES; i++) {
     79 		mach = &machines[i];
     80 
     81 		rw_enter(&mach->lock, RW_WRITER);
     82 		if (mach->present) {
     83 			rw_exit(&mach->lock);
     84 			continue;
     85 		}
     86 
     87 		mach->present = true;
     88 		mach->time = time_second;
     89 		*ret = mach;
     90 		atomic_inc_uint(&nmachines);
     91 		return 0;
     92 	}
     93 
     94 	return ENOBUFS;
     95 }
     96 
     97 static void
     98 nvmm_machine_free(struct nvmm_machine *mach)
     99 {
    100 	KASSERT(rw_write_held(&mach->lock));
    101 	KASSERT(mach->present);
    102 	mach->present = false;
    103 	atomic_dec_uint(&nmachines);
    104 }
    105 
    106 static int
    107 nvmm_machine_get(struct nvmm_owner *owner, nvmm_machid_t machid,
    108     struct nvmm_machine **ret, bool writer)
    109 {
    110 	struct nvmm_machine *mach;
    111 	krw_t op = writer ? RW_WRITER : RW_READER;
    112 
    113 	if (machid >= NVMM_MAX_MACHINES) {
    114 		return EINVAL;
    115 	}
    116 	mach = &machines[machid];
    117 
    118 	rw_enter(&mach->lock, op);
    119 	if (!mach->present) {
    120 		rw_exit(&mach->lock);
    121 		return ENOENT;
    122 	}
    123 	if (owner != &root_owner && mach->owner != owner) {
    124 		rw_exit(&mach->lock);
    125 		return EPERM;
    126 	}
    127 	*ret = mach;
    128 
    129 	return 0;
    130 }
    131 
    132 static void
    133 nvmm_machine_put(struct nvmm_machine *mach)
    134 {
    135 	rw_exit(&mach->lock);
    136 }
    137 
    138 /* -------------------------------------------------------------------------- */
    139 
    140 static int
    141 nvmm_vcpu_alloc(struct nvmm_machine *mach, nvmm_cpuid_t cpuid,
    142     struct nvmm_cpu **ret)
    143 {
    144 	struct nvmm_cpu *vcpu;
    145 
    146 	if (cpuid >= NVMM_MAX_VCPUS) {
    147 		return EINVAL;
    148 	}
    149 	vcpu = &mach->cpus[cpuid];
    150 
    151 	mutex_enter(&vcpu->lock);
    152 	if (vcpu->present) {
    153 		mutex_exit(&vcpu->lock);
    154 		return EBUSY;
    155 	}
    156 
    157 	vcpu->present = true;
    158 	vcpu->comm = NULL;
    159 	vcpu->hcpu_last = -1;
    160 	*ret = vcpu;
    161 	return 0;
    162 }
    163 
    164 static void
    165 nvmm_vcpu_free(struct nvmm_machine *mach, struct nvmm_cpu *vcpu)
    166 {
    167 	KASSERT(mutex_owned(&vcpu->lock));
    168 	vcpu->present = false;
    169 	if (vcpu->comm != NULL) {
    170 		uvm_deallocate(kernel_map, (vaddr_t)vcpu->comm, PAGE_SIZE);
    171 	}
    172 }
    173 
    174 static int
    175 nvmm_vcpu_get(struct nvmm_machine *mach, nvmm_cpuid_t cpuid,
    176     struct nvmm_cpu **ret)
    177 {
    178 	struct nvmm_cpu *vcpu;
    179 
    180 	if (cpuid >= NVMM_MAX_VCPUS) {
    181 		return EINVAL;
    182 	}
    183 	vcpu = &mach->cpus[cpuid];
    184 
    185 	mutex_enter(&vcpu->lock);
    186 	if (!vcpu->present) {
    187 		mutex_exit(&vcpu->lock);
    188 		return ENOENT;
    189 	}
    190 	*ret = vcpu;
    191 
    192 	return 0;
    193 }
    194 
    195 static void
    196 nvmm_vcpu_put(struct nvmm_cpu *vcpu)
    197 {
    198 	mutex_exit(&vcpu->lock);
    199 }
    200 
    201 /* -------------------------------------------------------------------------- */
    202 
    203 static void
    204 nvmm_kill_machines(struct nvmm_owner *owner)
    205 {
    206 	struct nvmm_machine *mach;
    207 	struct nvmm_cpu *vcpu;
    208 	size_t i, j;
    209 	int error;
    210 
    211 	for (i = 0; i < NVMM_MAX_MACHINES; i++) {
    212 		mach = &machines[i];
    213 
    214 		rw_enter(&mach->lock, RW_WRITER);
    215 		if (!mach->present || mach->owner != owner) {
    216 			rw_exit(&mach->lock);
    217 			continue;
    218 		}
    219 
    220 		/* Kill it. */
    221 		for (j = 0; j < NVMM_MAX_VCPUS; j++) {
    222 			error = nvmm_vcpu_get(mach, j, &vcpu);
    223 			if (error)
    224 				continue;
    225 			(*nvmm_impl->vcpu_destroy)(mach, vcpu);
    226 			nvmm_vcpu_free(mach, vcpu);
    227 			nvmm_vcpu_put(vcpu);
    228 		}
    229 		(*nvmm_impl->machine_destroy)(mach);
    230 		uvmspace_free(mach->vm);
    231 
    232 		/* Drop the kernel UOBJ refs. */
    233 		for (j = 0; j < NVMM_MAX_HMAPPINGS; j++) {
    234 			if (!mach->hmap[j].present)
    235 				continue;
    236 			uao_detach(mach->hmap[j].uobj);
    237 		}
    238 
    239 		nvmm_machine_free(mach);
    240 
    241 		rw_exit(&mach->lock);
    242 	}
    243 }
    244 
    245 /* -------------------------------------------------------------------------- */
    246 
    247 static int
    248 nvmm_capability(struct nvmm_owner *owner, struct nvmm_ioc_capability *args)
    249 {
    250 	args->cap.version = NVMM_CAPABILITY_VERSION;
    251 	args->cap.state_size = nvmm_impl->state_size;
    252 	args->cap.max_machines = NVMM_MAX_MACHINES;
    253 	args->cap.max_vcpus = NVMM_MAX_VCPUS;
    254 	args->cap.max_ram = NVMM_MAX_RAM;
    255 
    256 	(*nvmm_impl->capability)(&args->cap);
    257 
    258 	return 0;
    259 }
    260 
    261 static int
    262 nvmm_machine_create(struct nvmm_owner *owner,
    263     struct nvmm_ioc_machine_create *args)
    264 {
    265 	struct nvmm_machine *mach;
    266 	int error;
    267 
    268 	error = nvmm_machine_alloc(&mach);
    269 	if (error)
    270 		return error;
    271 
    272 	/* Curproc owns the machine. */
    273 	mach->owner = owner;
    274 
    275 	/* Zero out the host mappings. */
    276 	memset(&mach->hmap, 0, sizeof(mach->hmap));
    277 
    278 	/* Create the machine vmspace. */
    279 	mach->gpa_begin = 0;
    280 	mach->gpa_end = NVMM_MAX_RAM;
    281 	mach->vm = uvmspace_alloc(0, mach->gpa_end - mach->gpa_begin, false);
    282 
    283 	/* Create the comm uobj. */
    284 	mach->commuobj = uao_create(NVMM_MAX_VCPUS * PAGE_SIZE, 0);
    285 
    286 	(*nvmm_impl->machine_create)(mach);
    287 
    288 	args->machid = mach->machid;
    289 	nvmm_machine_put(mach);
    290 
    291 	return 0;
    292 }
    293 
    294 static int
    295 nvmm_machine_destroy(struct nvmm_owner *owner,
    296     struct nvmm_ioc_machine_destroy *args)
    297 {
    298 	struct nvmm_machine *mach;
    299 	struct nvmm_cpu *vcpu;
    300 	int error;
    301 	size_t i;
    302 
    303 	error = nvmm_machine_get(owner, args->machid, &mach, true);
    304 	if (error)
    305 		return error;
    306 
    307 	for (i = 0; i < NVMM_MAX_VCPUS; i++) {
    308 		error = nvmm_vcpu_get(mach, i, &vcpu);
    309 		if (error)
    310 			continue;
    311 
    312 		(*nvmm_impl->vcpu_destroy)(mach, vcpu);
    313 		nvmm_vcpu_free(mach, vcpu);
    314 		nvmm_vcpu_put(vcpu);
    315 	}
    316 
    317 	(*nvmm_impl->machine_destroy)(mach);
    318 
    319 	/* Free the machine vmspace. */
    320 	uvmspace_free(mach->vm);
    321 
    322 	/* Drop the kernel UOBJ refs. */
    323 	for (i = 0; i < NVMM_MAX_HMAPPINGS; i++) {
    324 		if (!mach->hmap[i].present)
    325 			continue;
    326 		uao_detach(mach->hmap[i].uobj);
    327 	}
    328 
    329 	nvmm_machine_free(mach);
    330 	nvmm_machine_put(mach);
    331 
    332 	return 0;
    333 }
    334 
    335 static int
    336 nvmm_machine_configure(struct nvmm_owner *owner,
    337     struct nvmm_ioc_machine_configure *args)
    338 {
    339 	struct nvmm_machine *mach;
    340 	size_t allocsz;
    341 	uint64_t op;
    342 	void *data;
    343 	int error;
    344 
    345 	op = NVMM_MACH_CONF_MD(args->op);
    346 	if (__predict_false(op >= nvmm_impl->conf_max)) {
    347 		return EINVAL;
    348 	}
    349 
    350 	allocsz = nvmm_impl->conf_sizes[op];
    351 	data = kmem_alloc(allocsz, KM_SLEEP);
    352 
    353 	error = nvmm_machine_get(owner, args->machid, &mach, true);
    354 	if (error) {
    355 		kmem_free(data, allocsz);
    356 		return error;
    357 	}
    358 
    359 	error = copyin(args->conf, data, allocsz);
    360 	if (error) {
    361 		goto out;
    362 	}
    363 
    364 	error = (*nvmm_impl->machine_configure)(mach, op, data);
    365 
    366 out:
    367 	nvmm_machine_put(mach);
    368 	kmem_free(data, allocsz);
    369 	return error;
    370 }
    371 
    372 static int
    373 nvmm_vcpu_create(struct nvmm_owner *owner, struct nvmm_ioc_vcpu_create *args)
    374 {
    375 	struct nvmm_machine *mach;
    376 	struct nvmm_cpu *vcpu;
    377 	int error;
    378 
    379 	error = nvmm_machine_get(owner, args->machid, &mach, false);
    380 	if (error)
    381 		return error;
    382 
    383 	error = nvmm_vcpu_alloc(mach, args->cpuid, &vcpu);
    384 	if (error)
    385 		goto out;
    386 
    387 	/* Allocate the comm page. */
    388 	uao_reference(mach->commuobj);
    389 	error = uvm_map(kernel_map, (vaddr_t *)&vcpu->comm, PAGE_SIZE,
    390 	    mach->commuobj, args->cpuid * PAGE_SIZE, 0, UVM_MAPFLAG(UVM_PROT_RW,
    391 	    UVM_PROT_RW, UVM_INH_SHARE, UVM_ADV_RANDOM, 0));
    392 	if (error) {
    393 		uao_detach(mach->commuobj);
    394 		nvmm_vcpu_free(mach, vcpu);
    395 		nvmm_vcpu_put(vcpu);
    396 		goto out;
    397 	}
    398 	error = uvm_map_pageable(kernel_map, (vaddr_t)vcpu->comm,
    399 	    (vaddr_t)vcpu->comm + PAGE_SIZE, false, 0);
    400 	if (error) {
    401 		nvmm_vcpu_free(mach, vcpu);
    402 		nvmm_vcpu_put(vcpu);
    403 		goto out;
    404 	}
    405 	memset(vcpu->comm, 0, PAGE_SIZE);
    406 
    407 	error = (*nvmm_impl->vcpu_create)(mach, vcpu);
    408 	if (error) {
    409 		nvmm_vcpu_free(mach, vcpu);
    410 		nvmm_vcpu_put(vcpu);
    411 		goto out;
    412 	}
    413 
    414 	nvmm_vcpu_put(vcpu);
    415 
    416 out:
    417 	nvmm_machine_put(mach);
    418 	return error;
    419 }
    420 
    421 static int
    422 nvmm_vcpu_destroy(struct nvmm_owner *owner, struct nvmm_ioc_vcpu_destroy *args)
    423 {
    424 	struct nvmm_machine *mach;
    425 	struct nvmm_cpu *vcpu;
    426 	int error;
    427 
    428 	error = nvmm_machine_get(owner, args->machid, &mach, false);
    429 	if (error)
    430 		return error;
    431 
    432 	error = nvmm_vcpu_get(mach, args->cpuid, &vcpu);
    433 	if (error)
    434 		goto out;
    435 
    436 	(*nvmm_impl->vcpu_destroy)(mach, vcpu);
    437 	nvmm_vcpu_free(mach, vcpu);
    438 	nvmm_vcpu_put(vcpu);
    439 
    440 out:
    441 	nvmm_machine_put(mach);
    442 	return error;
    443 }
    444 
    445 static int
    446 nvmm_vcpu_setstate(struct nvmm_owner *owner,
    447     struct nvmm_ioc_vcpu_setstate *args)
    448 {
    449 	struct nvmm_machine *mach;
    450 	struct nvmm_cpu *vcpu;
    451 	int error;
    452 
    453 	error = nvmm_machine_get(owner, args->machid, &mach, false);
    454 	if (error)
    455 		return error;
    456 
    457 	error = nvmm_vcpu_get(mach, args->cpuid, &vcpu);
    458 	if (error)
    459 		goto out;
    460 
    461 	(*nvmm_impl->vcpu_setstate)(vcpu);
    462 	nvmm_vcpu_put(vcpu);
    463 
    464 out:
    465 	nvmm_machine_put(mach);
    466 	return error;
    467 }
    468 
    469 static int
    470 nvmm_vcpu_getstate(struct nvmm_owner *owner,
    471     struct nvmm_ioc_vcpu_getstate *args)
    472 {
    473 	struct nvmm_machine *mach;
    474 	struct nvmm_cpu *vcpu;
    475 	int error;
    476 
    477 	error = nvmm_machine_get(owner, args->machid, &mach, false);
    478 	if (error)
    479 		return error;
    480 
    481 	error = nvmm_vcpu_get(mach, args->cpuid, &vcpu);
    482 	if (error)
    483 		goto out;
    484 
    485 	(*nvmm_impl->vcpu_getstate)(vcpu);
    486 	nvmm_vcpu_put(vcpu);
    487 
    488 out:
    489 	nvmm_machine_put(mach);
    490 	return error;
    491 }
    492 
    493 static int
    494 nvmm_vcpu_inject(struct nvmm_owner *owner, struct nvmm_ioc_vcpu_inject *args)
    495 {
    496 	struct nvmm_machine *mach;
    497 	struct nvmm_cpu *vcpu;
    498 	int error;
    499 
    500 	error = nvmm_machine_get(owner, args->machid, &mach, false);
    501 	if (error)
    502 		return error;
    503 
    504 	error = nvmm_vcpu_get(mach, args->cpuid, &vcpu);
    505 	if (error)
    506 		goto out;
    507 
    508 	error = (*nvmm_impl->vcpu_inject)(vcpu);
    509 	nvmm_vcpu_put(vcpu);
    510 
    511 out:
    512 	nvmm_machine_put(mach);
    513 	return error;
    514 }
    515 
    516 static int
    517 nvmm_do_vcpu_run(struct nvmm_machine *mach, struct nvmm_cpu *vcpu,
    518     struct nvmm_exit *exit)
    519 {
    520 	struct vmspace *vm = mach->vm;
    521 	int ret;
    522 
    523 	while (1) {
    524 		ret = (*nvmm_impl->vcpu_run)(mach, vcpu, exit);
    525 		if (__predict_false(ret != 0)) {
    526 			return ret;
    527 		}
    528 
    529 		if (__predict_true(exit->reason != NVMM_EXIT_MEMORY)) {
    530 			break;
    531 		}
    532 		if (exit->u.mem.gpa >= mach->gpa_end) {
    533 			break;
    534 		}
    535 		if (uvm_fault(&vm->vm_map, exit->u.mem.gpa, exit->u.mem.prot)) {
    536 			break;
    537 		}
    538 	}
    539 
    540 	return 0;
    541 }
    542 
    543 static int
    544 nvmm_vcpu_run(struct nvmm_owner *owner, struct nvmm_ioc_vcpu_run *args)
    545 {
    546 	struct nvmm_machine *mach;
    547 	struct nvmm_cpu *vcpu;
    548 	int error;
    549 
    550 	error = nvmm_machine_get(owner, args->machid, &mach, false);
    551 	if (error)
    552 		return error;
    553 
    554 	error = nvmm_vcpu_get(mach, args->cpuid, &vcpu);
    555 	if (error)
    556 		goto out;
    557 
    558 	error = nvmm_do_vcpu_run(mach, vcpu, &args->exit);
    559 	nvmm_vcpu_put(vcpu);
    560 
    561 out:
    562 	nvmm_machine_put(mach);
    563 	return error;
    564 }
    565 
    566 /* -------------------------------------------------------------------------- */
    567 
    568 static struct uvm_object *
    569 nvmm_hmapping_getuobj(struct nvmm_machine *mach, uintptr_t hva, size_t size,
    570    size_t *off)
    571 {
    572 	struct nvmm_hmapping *hmapping;
    573 	size_t i;
    574 
    575 	for (i = 0; i < NVMM_MAX_HMAPPINGS; i++) {
    576 		hmapping = &mach->hmap[i];
    577 		if (!hmapping->present) {
    578 			continue;
    579 		}
    580 		if (hva >= hmapping->hva &&
    581 		    hva + size <= hmapping->hva + hmapping->size) {
    582 			*off = hva - hmapping->hva;
    583 			return hmapping->uobj;
    584 		}
    585 	}
    586 
    587 	return NULL;
    588 }
    589 
    590 static int
    591 nvmm_hmapping_validate(struct nvmm_machine *mach, uintptr_t hva, size_t size)
    592 {
    593 	struct nvmm_hmapping *hmapping;
    594 	size_t i;
    595 
    596 	if ((hva % PAGE_SIZE) != 0 || (size % PAGE_SIZE) != 0) {
    597 		return EINVAL;
    598 	}
    599 	if (hva == 0) {
    600 		return EINVAL;
    601 	}
    602 
    603 	for (i = 0; i < NVMM_MAX_HMAPPINGS; i++) {
    604 		hmapping = &mach->hmap[i];
    605 		if (!hmapping->present) {
    606 			continue;
    607 		}
    608 
    609 		if (hva >= hmapping->hva &&
    610 		    hva + size <= hmapping->hva + hmapping->size) {
    611 			break;
    612 		}
    613 
    614 		if (hva >= hmapping->hva &&
    615 		    hva < hmapping->hva + hmapping->size) {
    616 			return EEXIST;
    617 		}
    618 		if (hva + size > hmapping->hva &&
    619 		    hva + size <= hmapping->hva + hmapping->size) {
    620 			return EEXIST;
    621 		}
    622 		if (hva <= hmapping->hva &&
    623 		    hva + size >= hmapping->hva + hmapping->size) {
    624 			return EEXIST;
    625 		}
    626 	}
    627 
    628 	return 0;
    629 }
    630 
    631 static struct nvmm_hmapping *
    632 nvmm_hmapping_alloc(struct nvmm_machine *mach)
    633 {
    634 	struct nvmm_hmapping *hmapping;
    635 	size_t i;
    636 
    637 	for (i = 0; i < NVMM_MAX_HMAPPINGS; i++) {
    638 		hmapping = &mach->hmap[i];
    639 		if (!hmapping->present) {
    640 			hmapping->present = true;
    641 			return hmapping;
    642 		}
    643 	}
    644 
    645 	return NULL;
    646 }
    647 
    648 static int
    649 nvmm_hmapping_free(struct nvmm_machine *mach, uintptr_t hva, size_t size)
    650 {
    651 	struct vmspace *vmspace = curproc->p_vmspace;
    652 	struct nvmm_hmapping *hmapping;
    653 	size_t i;
    654 
    655 	for (i = 0; i < NVMM_MAX_HMAPPINGS; i++) {
    656 		hmapping = &mach->hmap[i];
    657 		if (!hmapping->present || hmapping->hva != hva ||
    658 		    hmapping->size != size) {
    659 			continue;
    660 		}
    661 
    662 		uvm_unmap(&vmspace->vm_map, hmapping->hva,
    663 		    hmapping->hva + hmapping->size);
    664 		uao_detach(hmapping->uobj);
    665 
    666 		hmapping->uobj = NULL;
    667 		hmapping->present = false;
    668 
    669 		return 0;
    670 	}
    671 
    672 	return ENOENT;
    673 }
    674 
    675 static int
    676 nvmm_hva_map(struct nvmm_owner *owner, struct nvmm_ioc_hva_map *args)
    677 {
    678 	struct vmspace *vmspace = curproc->p_vmspace;
    679 	struct nvmm_machine *mach;
    680 	struct nvmm_hmapping *hmapping;
    681 	vaddr_t uva;
    682 	int error;
    683 
    684 	error = nvmm_machine_get(owner, args->machid, &mach, true);
    685 	if (error)
    686 		return error;
    687 
    688 	error = nvmm_hmapping_validate(mach, args->hva, args->size);
    689 	if (error)
    690 		goto out;
    691 
    692 	hmapping = nvmm_hmapping_alloc(mach);
    693 	if (hmapping == NULL) {
    694 		error = ENOBUFS;
    695 		goto out;
    696 	}
    697 
    698 	hmapping->hva = args->hva;
    699 	hmapping->size = args->size;
    700 	hmapping->uobj = uao_create(hmapping->size, 0);
    701 	uva = hmapping->hva;
    702 
    703 	/* Take a reference for the user. */
    704 	uao_reference(hmapping->uobj);
    705 
    706 	/* Map the uobj into the user address space, as pageable. */
    707 	error = uvm_map(&vmspace->vm_map, &uva, hmapping->size, hmapping->uobj,
    708 	    0, 0, UVM_MAPFLAG(UVM_PROT_RW, UVM_PROT_RW, UVM_INH_SHARE,
    709 	    UVM_ADV_RANDOM, UVM_FLAG_FIXED|UVM_FLAG_UNMAP));
    710 	if (error) {
    711 		uao_detach(hmapping->uobj);
    712 	}
    713 
    714 out:
    715 	nvmm_machine_put(mach);
    716 	return error;
    717 }
    718 
    719 static int
    720 nvmm_hva_unmap(struct nvmm_owner *owner, struct nvmm_ioc_hva_unmap *args)
    721 {
    722 	struct nvmm_machine *mach;
    723 	int error;
    724 
    725 	error = nvmm_machine_get(owner, args->machid, &mach, true);
    726 	if (error)
    727 		return error;
    728 
    729 	error = nvmm_hmapping_free(mach, args->hva, args->size);
    730 
    731 	nvmm_machine_put(mach);
    732 	return error;
    733 }
    734 
    735 /* -------------------------------------------------------------------------- */
    736 
    737 static int
    738 nvmm_gpa_map(struct nvmm_owner *owner, struct nvmm_ioc_gpa_map *args)
    739 {
    740 	struct nvmm_machine *mach;
    741 	struct uvm_object *uobj;
    742 	gpaddr_t gpa;
    743 	size_t off;
    744 	int error;
    745 
    746 	error = nvmm_machine_get(owner, args->machid, &mach, false);
    747 	if (error)
    748 		return error;
    749 
    750 	if ((args->prot & ~(PROT_READ|PROT_WRITE|PROT_EXEC)) != 0) {
    751 		error = EINVAL;
    752 		goto out;
    753 	}
    754 
    755 	if ((args->gpa % PAGE_SIZE) != 0 || (args->size % PAGE_SIZE) != 0 ||
    756 	    (args->hva % PAGE_SIZE) != 0) {
    757 		error = EINVAL;
    758 		goto out;
    759 	}
    760 	if (args->hva == 0) {
    761 		error = EINVAL;
    762 		goto out;
    763 	}
    764 	if (args->gpa < mach->gpa_begin || args->gpa >= mach->gpa_end) {
    765 		error = EINVAL;
    766 		goto out;
    767 	}
    768 	if (args->gpa + args->size <= args->gpa) {
    769 		error = EINVAL;
    770 		goto out;
    771 	}
    772 	if (args->gpa + args->size > mach->gpa_end) {
    773 		error = EINVAL;
    774 		goto out;
    775 	}
    776 	gpa = args->gpa;
    777 
    778 	uobj = nvmm_hmapping_getuobj(mach, args->hva, args->size, &off);
    779 	if (uobj == NULL) {
    780 		error = EINVAL;
    781 		goto out;
    782 	}
    783 
    784 	/* Take a reference for the machine. */
    785 	uao_reference(uobj);
    786 
    787 	/* Map the uobj into the machine address space, as pageable. */
    788 	error = uvm_map(&mach->vm->vm_map, &gpa, args->size, uobj, off, 0,
    789 	    UVM_MAPFLAG(args->prot, UVM_PROT_RWX, UVM_INH_NONE,
    790 	    UVM_ADV_RANDOM, UVM_FLAG_FIXED|UVM_FLAG_UNMAP));
    791 	if (error) {
    792 		uao_detach(uobj);
    793 		goto out;
    794 	}
    795 	if (gpa != args->gpa) {
    796 		uao_detach(uobj);
    797 		printf("[!] uvm_map problem\n");
    798 		error = EINVAL;
    799 		goto out;
    800 	}
    801 
    802 out:
    803 	nvmm_machine_put(mach);
    804 	return error;
    805 }
    806 
    807 static int
    808 nvmm_gpa_unmap(struct nvmm_owner *owner, struct nvmm_ioc_gpa_unmap *args)
    809 {
    810 	struct nvmm_machine *mach;
    811 	gpaddr_t gpa;
    812 	int error;
    813 
    814 	error = nvmm_machine_get(owner, args->machid, &mach, false);
    815 	if (error)
    816 		return error;
    817 
    818 	if ((args->gpa % PAGE_SIZE) != 0 || (args->size % PAGE_SIZE) != 0) {
    819 		error = EINVAL;
    820 		goto out;
    821 	}
    822 	if (args->gpa < mach->gpa_begin || args->gpa >= mach->gpa_end) {
    823 		error = EINVAL;
    824 		goto out;
    825 	}
    826 	if (args->gpa + args->size <= args->gpa) {
    827 		error = EINVAL;
    828 		goto out;
    829 	}
    830 	if (args->gpa + args->size >= mach->gpa_end) {
    831 		error = EINVAL;
    832 		goto out;
    833 	}
    834 	gpa = args->gpa;
    835 
    836 	/* Unmap the memory from the machine. */
    837 	uvm_unmap(&mach->vm->vm_map, gpa, gpa + args->size);
    838 
    839 out:
    840 	nvmm_machine_put(mach);
    841 	return error;
    842 }
    843 
    844 /* -------------------------------------------------------------------------- */
    845 
    846 static int
    847 nvmm_ctl_mach_info(struct nvmm_ioc_ctl *args)
    848 {
    849 	struct nvmm_ctl_mach_info ctl;
    850 	struct nvmm_machine *mach;
    851 	struct nvmm_cpu *vcpu;
    852 	int error;
    853 	size_t i;
    854 
    855 	if (args->size != sizeof(ctl))
    856 		return EINVAL;
    857 	error = copyin(args->data, &ctl, sizeof(ctl));
    858 	if (error)
    859 		return error;
    860 
    861 	error = nvmm_machine_get(&root_owner, ctl.machid, &mach, true);
    862 	if (error)
    863 		return error;
    864 
    865 	ctl.nvcpus = 0;
    866 	for (i = 0; i < NVMM_MAX_VCPUS; i++) {
    867 		error = nvmm_vcpu_get(mach, i, &vcpu);
    868 		if (error)
    869 			continue;
    870 		ctl.nvcpus++;
    871 		nvmm_vcpu_put(vcpu);
    872 	}
    873 	ctl.pid = mach->owner->pid;
    874 	ctl.time = mach->time;
    875 
    876 	nvmm_machine_put(mach);
    877 
    878 	error = copyout(&ctl, args->data, sizeof(ctl));
    879 	if (error)
    880 		return error;
    881 
    882 	return 0;
    883 }
    884 
    885 static int
    886 nvmm_ctl(struct nvmm_owner *owner, struct nvmm_ioc_ctl *args)
    887 {
    888 	int error;
    889 
    890 	error = kauth_authorize_device(curlwp->l_cred, KAUTH_DEVICE_NVMM_CTL,
    891 	    NULL, NULL, NULL, NULL);
    892 	if (error)
    893 		return error;
    894 
    895 	switch (args->op) {
    896 	case NVMM_CTL_MACH_INFO:
    897 		return nvmm_ctl_mach_info(args);
    898 	default:
    899 		return EINVAL;
    900 	}
    901 }
    902 
    903 /* -------------------------------------------------------------------------- */
    904 
    905 static int
    906 nvmm_init(void)
    907 {
    908 	size_t i, n;
    909 
    910 	for (i = 0; i < __arraycount(nvmm_impl_list); i++) {
    911 		if (!(*nvmm_impl_list[i]->ident)()) {
    912 			continue;
    913 		}
    914 		nvmm_impl = nvmm_impl_list[i];
    915 		break;
    916 	}
    917 	if (nvmm_impl == NULL) {
    918 		printf("[!] No implementation found\n");
    919 		return ENOTSUP;
    920 	}
    921 
    922 	for (i = 0; i < NVMM_MAX_MACHINES; i++) {
    923 		machines[i].machid = i;
    924 		rw_init(&machines[i].lock);
    925 		for (n = 0; n < NVMM_MAX_VCPUS; n++) {
    926 			machines[i].cpus[n].present = false;
    927 			machines[i].cpus[n].cpuid = n;
    928 			mutex_init(&machines[i].cpus[n].lock, MUTEX_DEFAULT,
    929 			    IPL_NONE);
    930 		}
    931 	}
    932 
    933 	(*nvmm_impl->init)();
    934 
    935 	return 0;
    936 }
    937 
    938 static void
    939 nvmm_fini(void)
    940 {
    941 	size_t i, n;
    942 
    943 	for (i = 0; i < NVMM_MAX_MACHINES; i++) {
    944 		rw_destroy(&machines[i].lock);
    945 		for (n = 0; n < NVMM_MAX_VCPUS; n++) {
    946 			mutex_destroy(&machines[i].cpus[n].lock);
    947 		}
    948 	}
    949 
    950 	(*nvmm_impl->fini)();
    951 }
    952 
    953 /* -------------------------------------------------------------------------- */
    954 
    955 static dev_type_open(nvmm_open);
    956 
    957 const struct cdevsw nvmm_cdevsw = {
    958 	.d_open = nvmm_open,
    959 	.d_close = noclose,
    960 	.d_read = noread,
    961 	.d_write = nowrite,
    962 	.d_ioctl = noioctl,
    963 	.d_stop = nostop,
    964 	.d_tty = notty,
    965 	.d_poll = nopoll,
    966 	.d_mmap = nommap,
    967 	.d_kqfilter = nokqfilter,
    968 	.d_discard = nodiscard,
    969 	.d_flag = D_OTHER | D_MPSAFE
    970 };
    971 
    972 static int nvmm_ioctl(file_t *, u_long, void *);
    973 static int nvmm_close(file_t *);
    974 static int nvmm_mmap(file_t *, off_t *, size_t, int, int *, int *,
    975     struct uvm_object **, int *);
    976 
    977 const struct fileops nvmm_fileops = {
    978 	.fo_read = fbadop_read,
    979 	.fo_write = fbadop_write,
    980 	.fo_ioctl = nvmm_ioctl,
    981 	.fo_fcntl = fnullop_fcntl,
    982 	.fo_poll = fnullop_poll,
    983 	.fo_stat = fbadop_stat,
    984 	.fo_close = nvmm_close,
    985 	.fo_kqfilter = fnullop_kqfilter,
    986 	.fo_restart = fnullop_restart,
    987 	.fo_mmap = nvmm_mmap,
    988 };
    989 
    990 static int
    991 nvmm_open(dev_t dev, int flags, int type, struct lwp *l)
    992 {
    993 	struct nvmm_owner *owner;
    994 	struct file *fp;
    995 	int error, fd;
    996 
    997 	if (minor(dev) != 0)
    998 		return EXDEV;
    999 	error = fd_allocfile(&fp, &fd);
   1000 	if (error)
   1001 		return error;
   1002 
   1003 	owner = kmem_alloc(sizeof(*owner), KM_SLEEP);
   1004 	owner->pid = l->l_proc->p_pid;
   1005 
   1006 	return fd_clone(fp, fd, flags, &nvmm_fileops, owner);
   1007 }
   1008 
   1009 static int
   1010 nvmm_close(file_t *fp)
   1011 {
   1012 	struct nvmm_owner *owner = fp->f_data;
   1013 
   1014 	KASSERT(owner != NULL);
   1015 	nvmm_kill_machines(owner);
   1016 	kmem_free(owner, sizeof(*owner));
   1017 	fp->f_data = NULL;
   1018 
   1019    	return 0;
   1020 }
   1021 
   1022 static int
   1023 nvmm_mmap(file_t *fp, off_t *offp, size_t size, int prot, int *flagsp,
   1024     int *advicep, struct uvm_object **uobjp, int *maxprotp)
   1025 {
   1026 	struct nvmm_owner *owner = fp->f_data;
   1027 	struct nvmm_machine *mach;
   1028 	nvmm_machid_t machid;
   1029 	nvmm_cpuid_t cpuid;
   1030 	int error;
   1031 
   1032 	if (prot & PROT_EXEC)
   1033 		return EACCES;
   1034 	if (size != PAGE_SIZE)
   1035 		return EINVAL;
   1036 
   1037 	cpuid = NVMM_COMM_CPUID(*offp);
   1038 	if (__predict_false(cpuid >= NVMM_MAX_VCPUS))
   1039 		return EINVAL;
   1040 
   1041 	machid = NVMM_COMM_MACHID(*offp);
   1042 	error = nvmm_machine_get(owner, machid, &mach, false);
   1043 	if (error)
   1044 		return error;
   1045 
   1046 	uao_reference(mach->commuobj);
   1047 	*uobjp = mach->commuobj;
   1048 	*offp = cpuid * PAGE_SIZE;
   1049 	*maxprotp = prot;
   1050 	*advicep = UVM_ADV_RANDOM;
   1051 
   1052 	nvmm_machine_put(mach);
   1053 	return 0;
   1054 }
   1055 
   1056 static int
   1057 nvmm_ioctl(file_t *fp, u_long cmd, void *data)
   1058 {
   1059 	struct nvmm_owner *owner = fp->f_data;
   1060 
   1061 	KASSERT(owner != NULL);
   1062 
   1063 	switch (cmd) {
   1064 	case NVMM_IOC_CAPABILITY:
   1065 		return nvmm_capability(owner, data);
   1066 	case NVMM_IOC_MACHINE_CREATE:
   1067 		return nvmm_machine_create(owner, data);
   1068 	case NVMM_IOC_MACHINE_DESTROY:
   1069 		return nvmm_machine_destroy(owner, data);
   1070 	case NVMM_IOC_MACHINE_CONFIGURE:
   1071 		return nvmm_machine_configure(owner, data);
   1072 	case NVMM_IOC_VCPU_CREATE:
   1073 		return nvmm_vcpu_create(owner, data);
   1074 	case NVMM_IOC_VCPU_DESTROY:
   1075 		return nvmm_vcpu_destroy(owner, data);
   1076 	case NVMM_IOC_VCPU_SETSTATE:
   1077 		return nvmm_vcpu_setstate(owner, data);
   1078 	case NVMM_IOC_VCPU_GETSTATE:
   1079 		return nvmm_vcpu_getstate(owner, data);
   1080 	case NVMM_IOC_VCPU_INJECT:
   1081 		return nvmm_vcpu_inject(owner, data);
   1082 	case NVMM_IOC_VCPU_RUN:
   1083 		return nvmm_vcpu_run(owner, data);
   1084 	case NVMM_IOC_GPA_MAP:
   1085 		return nvmm_gpa_map(owner, data);
   1086 	case NVMM_IOC_GPA_UNMAP:
   1087 		return nvmm_gpa_unmap(owner, data);
   1088 	case NVMM_IOC_HVA_MAP:
   1089 		return nvmm_hva_map(owner, data);
   1090 	case NVMM_IOC_HVA_UNMAP:
   1091 		return nvmm_hva_unmap(owner, data);
   1092 	case NVMM_IOC_CTL:
   1093 		return nvmm_ctl(owner, data);
   1094 	default:
   1095 		return EINVAL;
   1096 	}
   1097 }
   1098 
   1099 /* -------------------------------------------------------------------------- */
   1100 
   1101 void
   1102 nvmmattach(int nunits)
   1103 {
   1104 	/* nothing */
   1105 }
   1106 
   1107 MODULE(MODULE_CLASS_MISC, nvmm, NULL);
   1108 
   1109 static int
   1110 nvmm_modcmd(modcmd_t cmd, void *arg)
   1111 {
   1112 	int error;
   1113 
   1114 	switch (cmd) {
   1115 	case MODULE_CMD_INIT:
   1116 		error = nvmm_init();
   1117 		if (error)
   1118 			return error;
   1119 
   1120 #if defined(_MODULE)
   1121 		{
   1122 			devmajor_t bmajor = NODEVMAJOR;
   1123 			devmajor_t cmajor = 345;
   1124 
   1125 			/* mknod /dev/nvmm c 345 0 */
   1126 			error = devsw_attach("nvmm", NULL, &bmajor,
   1127 			    &nvmm_cdevsw, &cmajor);
   1128 			if (error) {
   1129 				nvmm_fini();
   1130 				return error;
   1131 			}
   1132 		}
   1133 #endif
   1134 		return 0;
   1135 
   1136 	case MODULE_CMD_FINI:
   1137 		if (nmachines > 0) {
   1138 			return EBUSY;
   1139 		}
   1140 #if defined(_MODULE)
   1141 		{
   1142 			error = devsw_detach(NULL, &nvmm_cdevsw);
   1143 			if (error) {
   1144 				return error;
   1145 			}
   1146 		}
   1147 #endif
   1148 		nvmm_fini();
   1149 		return 0;
   1150 
   1151 	case MODULE_CMD_AUTOUNLOAD:
   1152 		return EBUSY;
   1153 
   1154 	default:
   1155 		return ENOTTY;
   1156 	}
   1157 }
   1158