// SPDX-License-Identifier: GPL-2.0 /* * ACRN Hypervisor Service Module (HSM) * * Copyright (C) 2020 Intel Corporation. All rights reserved. * * Authors: * Fengwei Yin * Yakui Zhao */ #include #include #include #include #include #include #include #include "acrn_drv.h" /* * When /dev/acrn_hsm is opened, a 'struct acrn_vm' object is created to * represent a VM instance and continues to be associated with the opened file * descriptor. All ioctl operations on this file descriptor will be targeted to * the VM instance. Release of this file descriptor will destroy the object. */ static int acrn_dev_open(struct inode *inode, struct file *filp) { struct acrn_vm *vm; vm = kzalloc(sizeof(*vm), GFP_KERNEL); if (!vm) return -ENOMEM; vm->vmid = ACRN_INVALID_VMID; filp->private_data = vm; return 0; } static int pmcmd_ioctl(u64 cmd, void __user *uptr) { struct acrn_pstate_data *px_data; struct acrn_cstate_data *cx_data; u64 *pm_info; int ret = 0; switch (cmd & PMCMD_TYPE_MASK) { case ACRN_PMCMD_GET_PX_CNT: case ACRN_PMCMD_GET_CX_CNT: pm_info = kmalloc(sizeof(u64), GFP_KERNEL); if (!pm_info) return -ENOMEM; ret = hcall_get_cpu_state(cmd, virt_to_phys(pm_info)); if (ret < 0) { kfree(pm_info); break; } if (copy_to_user(uptr, pm_info, sizeof(u64))) ret = -EFAULT; kfree(pm_info); break; case ACRN_PMCMD_GET_PX_DATA: px_data = kmalloc(sizeof(*px_data), GFP_KERNEL); if (!px_data) return -ENOMEM; ret = hcall_get_cpu_state(cmd, virt_to_phys(px_data)); if (ret < 0) { kfree(px_data); break; } if (copy_to_user(uptr, px_data, sizeof(*px_data))) ret = -EFAULT; kfree(px_data); break; case ACRN_PMCMD_GET_CX_DATA: cx_data = kmalloc(sizeof(*cx_data), GFP_KERNEL); if (!cx_data) return -ENOMEM; ret = hcall_get_cpu_state(cmd, virt_to_phys(cx_data)); if (ret < 0) { kfree(cx_data); break; } if (copy_to_user(uptr, cx_data, sizeof(*cx_data))) ret = -EFAULT; kfree(cx_data); break; default: break; } return ret; } /* * HSM relies on hypercall layer of the ACRN hypervisor to do the * sanity check against the input parameters. */ static long acrn_dev_ioctl(struct file *filp, unsigned int cmd, unsigned long ioctl_param) { struct acrn_vm *vm = filp->private_data; struct acrn_vm_creation *vm_param; struct acrn_vcpu_regs *cpu_regs; struct acrn_ioreq_notify notify; struct acrn_ptdev_irq *irq_info; struct acrn_ioeventfd ioeventfd; struct acrn_vm_memmap memmap; struct acrn_mmiodev *mmiodev; struct acrn_msi_entry *msi; struct acrn_pcidev *pcidev; struct acrn_irqfd irqfd; struct acrn_vdev *vdev; struct page *page; u64 cstate_cmd; int i, ret = 0; if (vm->vmid == ACRN_INVALID_VMID && cmd != ACRN_IOCTL_CREATE_VM) { dev_dbg(acrn_dev.this_device, "ioctl 0x%x: Invalid VM state!\n", cmd); return -EINVAL; } switch (cmd) { case ACRN_IOCTL_CREATE_VM: vm_param = memdup_user((void __user *)ioctl_param, sizeof(struct acrn_vm_creation)); if (IS_ERR(vm_param)) return PTR_ERR(vm_param); if ((vm_param->reserved0 | vm_param->reserved1) != 0) { kfree(vm_param); return -EINVAL; } vm = acrn_vm_create(vm, vm_param); if (!vm) { ret = -EINVAL; kfree(vm_param); break; } if (copy_to_user((void __user *)ioctl_param, vm_param, sizeof(struct acrn_vm_creation))) { acrn_vm_destroy(vm); ret = -EFAULT; } kfree(vm_param); break; case ACRN_IOCTL_START_VM: ret = hcall_start_vm(vm->vmid); if (ret < 0) dev_dbg(acrn_dev.this_device, "Failed to start VM %u!\n", vm->vmid); break; case ACRN_IOCTL_PAUSE_VM: ret = hcall_pause_vm(vm->vmid); if (ret < 0) dev_dbg(acrn_dev.this_device, "Failed to pause VM %u!\n", vm->vmid); break; case ACRN_IOCTL_RESET_VM: ret = hcall_reset_vm(vm->vmid); if (ret < 0) dev_dbg(acrn_dev.this_device, "Failed to restart VM %u!\n", vm->vmid); break; case ACRN_IOCTL_DESTROY_VM: ret = acrn_vm_destroy(vm); break; case ACRN_IOCTL_SET_VCPU_REGS: cpu_regs = memdup_user((void __user *)ioctl_param, sizeof(struct acrn_vcpu_regs)); if (IS_ERR(cpu_regs)) return PTR_ERR(cpu_regs); for (i = 0; i < ARRAY_SIZE(cpu_regs->reserved); i++) if (cpu_regs->reserved[i]) { kfree(cpu_regs); return -EINVAL; } for (i = 0; i < ARRAY_SIZE(cpu_regs->vcpu_regs.reserved_32); i++) if (cpu_regs->vcpu_regs.reserved_32[i]) { kfree(cpu_regs); return -EINVAL; } for (i = 0; i < ARRAY_SIZE(cpu_regs->vcpu_regs.reserved_64); i++) if (cpu_regs->vcpu_regs.reserved_64[i]) { kfree(cpu_regs); return -EINVAL; } for (i = 0; i < ARRAY_SIZE(cpu_regs->vcpu_regs.gdt.reserved); i++) if (cpu_regs->vcpu_regs.gdt.reserved[i] | cpu_regs->vcpu_regs.idt.reserved[i]) { kfree(cpu_regs); return -EINVAL; } ret = hcall_set_vcpu_regs(vm->vmid, virt_to_phys(cpu_regs)); if (ret < 0) dev_dbg(acrn_dev.this_device, "Failed to set regs state of VM%u!\n", vm->vmid); kfree(cpu_regs); break; case ACRN_IOCTL_SET_MEMSEG: if (copy_from_user(&memmap, (void __user *)ioctl_param, sizeof(memmap))) return -EFAULT; ret = acrn_vm_memseg_map(vm, &memmap); break; case ACRN_IOCTL_UNSET_MEMSEG: if (copy_from_user(&memmap, (void __user *)ioctl_param, sizeof(memmap))) return -EFAULT; ret = acrn_vm_memseg_unmap(vm, &memmap); break; case ACRN_IOCTL_ASSIGN_MMIODEV: mmiodev = memdup_user((void __user *)ioctl_param, sizeof(struct acrn_mmiodev)); if (IS_ERR(mmiodev)) return PTR_ERR(mmiodev); ret = hcall_assign_mmiodev(vm->vmid, virt_to_phys(mmiodev)); if (ret < 0) dev_dbg(acrn_dev.this_device, "Failed to assign MMIO device!\n"); kfree(mmiodev); break; case ACRN_IOCTL_DEASSIGN_MMIODEV: mmiodev = memdup_user((void __user *)ioctl_param, sizeof(struct acrn_mmiodev)); if (IS_ERR(mmiodev)) return PTR_ERR(mmiodev); ret = hcall_deassign_mmiodev(vm->vmid, virt_to_phys(mmiodev)); if (ret < 0) dev_dbg(acrn_dev.this_device, "Failed to deassign MMIO device!\n"); kfree(mmiodev); break; case ACRN_IOCTL_ASSIGN_PCIDEV: pcidev = memdup_user((void __user *)ioctl_param, sizeof(struct acrn_pcidev)); if (IS_ERR(pcidev)) return PTR_ERR(pcidev); ret = hcall_assign_pcidev(vm->vmid, virt_to_phys(pcidev)); if (ret < 0) dev_dbg(acrn_dev.this_device, "Failed to assign pci device!\n"); kfree(pcidev); break; case ACRN_IOCTL_DEASSIGN_PCIDEV: pcidev = memdup_user((void __user *)ioctl_param, sizeof(struct acrn_pcidev)); if (IS_ERR(pcidev)) return PTR_ERR(pcidev); ret = hcall_deassign_pcidev(vm->vmid, virt_to_phys(pcidev)); if (ret < 0) dev_dbg(acrn_dev.this_device, "Failed to deassign pci device!\n"); kfree(pcidev); break; case ACRN_IOCTL_CREATE_VDEV: vdev = memdup_user((void __user *)ioctl_param, sizeof(struct acrn_vdev)); if (IS_ERR(vdev)) return PTR_ERR(vdev); ret = hcall_create_vdev(vm->vmid, virt_to_phys(vdev)); if (ret < 0) dev_dbg(acrn_dev.this_device, "Failed to create virtual device!\n"); kfree(vdev); break; case ACRN_IOCTL_DESTROY_VDEV: vdev = memdup_user((void __user *)ioctl_param, sizeof(struct acrn_vdev)); if (IS_ERR(vdev)) return PTR_ERR(vdev); ret = hcall_destroy_vdev(vm->vmid, virt_to_phys(vdev)); if (ret < 0) dev_dbg(acrn_dev.this_device, "Failed to destroy virtual device!\n"); kfree(vdev); break; case ACRN_IOCTL_SET_PTDEV_INTR: irq_info = memdup_user((void __user *)ioctl_param, sizeof(struct acrn_ptdev_irq)); if (IS_ERR(irq_info)) return PTR_ERR(irq_info); ret = hcall_set_ptdev_intr(vm->vmid, virt_to_phys(irq_info)); if (ret < 0) dev_dbg(acrn_dev.this_device, "Failed to configure intr for ptdev!\n"); kfree(irq_info); break; case ACRN_IOCTL_RESET_PTDEV_INTR: irq_info = memdup_user((void __user *)ioctl_param, sizeof(struct acrn_ptdev_irq)); if (IS_ERR(irq_info)) return PTR_ERR(irq_info); ret = hcall_reset_ptdev_intr(vm->vmid, virt_to_phys(irq_info)); if (ret < 0) dev_dbg(acrn_dev.this_device, "Failed to reset intr for ptdev!\n"); kfree(irq_info); break; case ACRN_IOCTL_SET_IRQLINE: ret = hcall_set_irqline(vm->vmid, ioctl_param); if (ret < 0) dev_dbg(acrn_dev.this_device, "Failed to set interrupt line!\n"); break; case ACRN_IOCTL_INJECT_MSI: msi = memdup_user((void __user *)ioctl_param, sizeof(struct acrn_msi_entry)); if (IS_ERR(msi)) return PTR_ERR(msi); ret = hcall_inject_msi(vm->vmid, virt_to_phys(msi)); if (ret < 0) dev_dbg(acrn_dev.this_device, "Failed to inject MSI!\n"); kfree(msi); break; case ACRN_IOCTL_VM_INTR_MONITOR: ret = pin_user_pages_fast(ioctl_param, 1, FOLL_WRITE | FOLL_LONGTERM, &page); if (unlikely(ret != 1)) { dev_dbg(acrn_dev.this_device, "Failed to pin intr hdr buffer!\n"); return -EFAULT; } ret = hcall_vm_intr_monitor(vm->vmid, page_to_phys(page)); if (ret < 0) { unpin_user_page(page); dev_dbg(acrn_dev.this_device, "Failed to monitor intr data!\n"); return ret; } if (vm->monitor_page) unpin_user_page(vm->monitor_page); vm->monitor_page = page; break; case ACRN_IOCTL_CREATE_IOREQ_CLIENT: if (vm->default_client) return -EEXIST; if (!acrn_ioreq_client_create(vm, NULL, NULL, true, "acrndm")) ret = -EINVAL; break; case ACRN_IOCTL_DESTROY_IOREQ_CLIENT: if (vm->default_client) acrn_ioreq_client_destroy(vm->default_client); break; case ACRN_IOCTL_ATTACH_IOREQ_CLIENT: if (vm->default_client) ret = acrn_ioreq_client_wait(vm->default_client); else ret = -ENODEV; break; case ACRN_IOCTL_NOTIFY_REQUEST_FINISH: if (copy_from_user(¬ify, (void __user *)ioctl_param, sizeof(struct acrn_ioreq_notify))) return -EFAULT; if (notify.reserved != 0) return -EINVAL; ret = acrn_ioreq_request_default_complete(vm, notify.vcpu); break; case ACRN_IOCTL_CLEAR_VM_IOREQ: acrn_ioreq_request_clear(vm); break; case ACRN_IOCTL_PM_GET_CPU_STATE: if (copy_from_user(&cstate_cmd, (void __user *)ioctl_param, sizeof(cstate_cmd))) return -EFAULT; ret = pmcmd_ioctl(cstate_cmd, (void __user *)ioctl_param); break; case ACRN_IOCTL_IOEVENTFD: if (copy_from_user(&ioeventfd, (void __user *)ioctl_param, sizeof(ioeventfd))) return -EFAULT; if (ioeventfd.reserved != 0) return -EINVAL; ret = acrn_ioeventfd_config(vm, &ioeventfd); break; case ACRN_IOCTL_IRQFD: if (copy_from_user(&irqfd, (void __user *)ioctl_param, sizeof(irqfd))) return -EFAULT; ret = acrn_irqfd_config(vm, &irqfd); break; default: dev_dbg(acrn_dev.this_device, "Unknown IOCTL 0x%x!\n", cmd); ret = -ENOTTY; } return ret; } static int acrn_dev_release(struct inode *inode, struct file *filp) { struct acrn_vm *vm = filp->private_data; acrn_vm_destroy(vm); kfree(vm); return 0; } static ssize_t remove_cpu_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { u64 cpu, lapicid; int ret; if (kstrtoull(buf, 0, &cpu) < 0) return -EINVAL; if (cpu >= num_possible_cpus() || cpu == 0 || !cpu_is_hotpluggable(cpu)) return -EINVAL; if (cpu_online(cpu)) remove_cpu(cpu); lapicid = cpu_data(cpu).topo.apicid; dev_dbg(dev, "Try to remove cpu %lld with lapicid %lld\n", cpu, lapicid); ret = hcall_sos_remove_cpu(lapicid); if (ret < 0) { dev_err(dev, "Failed to remove cpu %lld!\n", cpu); goto fail_remove; } return count; fail_remove: add_cpu(cpu); return ret; } static DEVICE_ATTR_WO(remove_cpu); static umode_t acrn_attr_visible(struct kobject *kobj, struct attribute *a, int n) { if (a == &dev_attr_remove_cpu.attr) return IS_ENABLED(CONFIG_HOTPLUG_CPU) ? a->mode : 0; return a->mode; } static struct attribute *acrn_attrs[] = { &dev_attr_remove_cpu.attr, NULL }; static struct attribute_group acrn_attr_group = { .attrs = acrn_attrs, .is_visible = acrn_attr_visible, }; static const struct attribute_group *acrn_attr_groups[] = { &acrn_attr_group, NULL }; static const struct file_operations acrn_fops = { .owner = THIS_MODULE, .open = acrn_dev_open, .release = acrn_dev_release, .unlocked_ioctl = acrn_dev_ioctl, }; struct miscdevice acrn_dev = { .minor = MISC_DYNAMIC_MINOR, .name = "acrn_hsm", .fops = &acrn_fops, .groups = acrn_attr_groups, }; static int __init hsm_init(void) { int ret; if (x86_hyper_type != X86_HYPER_ACRN) return -ENODEV; if (!(cpuid_eax(ACRN_CPUID_FEATURES) & ACRN_FEATURE_PRIVILEGED_VM)) return -EPERM; ret = misc_register(&acrn_dev); if (ret) { pr_err("Create misc dev failed!\n"); return ret; } ret = acrn_ioreq_intr_setup(); if (ret) { pr_err("Setup I/O request handler failed!\n"); misc_deregister(&acrn_dev); return ret; } return 0; } static void __exit hsm_exit(void) { acrn_ioreq_intr_remove(); misc_deregister(&acrn_dev); } module_init(hsm_init); module_exit(hsm_exit); MODULE_AUTHOR("Intel Corporation"); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("ACRN Hypervisor Service Module (HSM)");