1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * ACRN Hypervisor Service Module (HSM) 4 * 5 * Copyright (C) 2020 Intel Corporation. All rights reserved. 6 * 7 * Authors: 8 * Fengwei Yin <fengwei.yin@intel.com> 9 * Yakui Zhao <yakui.zhao@intel.com> 10 */ 11 12 #include <linux/cpu.h> 13 #include <linux/io.h> 14 #include <linux/mm.h> 15 #include <linux/module.h> 16 #include <linux/slab.h> 17 18 #include <asm/acrn.h> 19 #include <asm/hypervisor.h> 20 21 #include "acrn_drv.h" 22 23 /* 24 * When /dev/acrn_hsm is opened, a 'struct acrn_vm' object is created to 25 * represent a VM instance and continues to be associated with the opened file 26 * descriptor. All ioctl operations on this file descriptor will be targeted to 27 * the VM instance. Release of this file descriptor will destroy the object. 28 */ 29 static int acrn_dev_open(struct inode *inode, struct file *filp) 30 { 31 struct acrn_vm *vm; 32 33 vm = kzalloc(sizeof(*vm), GFP_KERNEL); 34 if (!vm) 35 return -ENOMEM; 36 37 vm->vmid = ACRN_INVALID_VMID; 38 filp->private_data = vm; 39 return 0; 40 } 41 42 static int pmcmd_ioctl(u64 cmd, void __user *uptr) 43 { 44 struct acrn_pstate_data *px_data; 45 struct acrn_cstate_data *cx_data; 46 u64 *pm_info; 47 int ret = 0; 48 49 switch (cmd & PMCMD_TYPE_MASK) { 50 case ACRN_PMCMD_GET_PX_CNT: 51 case ACRN_PMCMD_GET_CX_CNT: 52 pm_info = kmalloc(sizeof(u64), GFP_KERNEL); 53 if (!pm_info) 54 return -ENOMEM; 55 56 ret = hcall_get_cpu_state(cmd, virt_to_phys(pm_info)); 57 if (ret < 0) { 58 kfree(pm_info); 59 break; 60 } 61 62 if (copy_to_user(uptr, pm_info, sizeof(u64))) 63 ret = -EFAULT; 64 kfree(pm_info); 65 break; 66 case ACRN_PMCMD_GET_PX_DATA: 67 px_data = kmalloc(sizeof(*px_data), GFP_KERNEL); 68 if (!px_data) 69 return -ENOMEM; 70 71 ret = hcall_get_cpu_state(cmd, virt_to_phys(px_data)); 72 if (ret < 0) { 73 kfree(px_data); 74 break; 75 } 76 77 if (copy_to_user(uptr, px_data, sizeof(*px_data))) 78 ret = -EFAULT; 79 kfree(px_data); 80 break; 81 case ACRN_PMCMD_GET_CX_DATA: 82 cx_data = kmalloc(sizeof(*cx_data), GFP_KERNEL); 83 if (!cx_data) 84 return -ENOMEM; 85 86 ret = hcall_get_cpu_state(cmd, virt_to_phys(cx_data)); 87 if (ret < 0) { 88 kfree(cx_data); 89 break; 90 } 91 92 if (copy_to_user(uptr, cx_data, sizeof(*cx_data))) 93 ret = -EFAULT; 94 kfree(cx_data); 95 break; 96 default: 97 break; 98 } 99 100 return ret; 101 } 102 103 /* 104 * HSM relies on hypercall layer of the ACRN hypervisor to do the 105 * sanity check against the input parameters. 106 */ 107 static long acrn_dev_ioctl(struct file *filp, unsigned int cmd, 108 unsigned long ioctl_param) 109 { 110 struct acrn_vm *vm = filp->private_data; 111 struct acrn_vm_creation *vm_param; 112 struct acrn_vcpu_regs *cpu_regs; 113 struct acrn_ioreq_notify notify; 114 struct acrn_ptdev_irq *irq_info; 115 struct acrn_ioeventfd ioeventfd; 116 struct acrn_vm_memmap memmap; 117 struct acrn_mmiodev *mmiodev; 118 struct acrn_msi_entry *msi; 119 struct acrn_pcidev *pcidev; 120 struct acrn_irqfd irqfd; 121 struct acrn_vdev *vdev; 122 struct page *page; 123 u64 cstate_cmd; 124 int i, ret = 0; 125 126 if (vm->vmid == ACRN_INVALID_VMID && cmd != ACRN_IOCTL_CREATE_VM) { 127 dev_dbg(acrn_dev.this_device, 128 "ioctl 0x%x: Invalid VM state!\n", cmd); 129 return -EINVAL; 130 } 131 132 switch (cmd) { 133 case ACRN_IOCTL_CREATE_VM: 134 vm_param = memdup_user((void __user *)ioctl_param, 135 sizeof(struct acrn_vm_creation)); 136 if (IS_ERR(vm_param)) 137 return PTR_ERR(vm_param); 138 139 if ((vm_param->reserved0 | vm_param->reserved1) != 0) { 140 kfree(vm_param); 141 return -EINVAL; 142 } 143 144 vm = acrn_vm_create(vm, vm_param); 145 if (!vm) { 146 ret = -EINVAL; 147 kfree(vm_param); 148 break; 149 } 150 151 if (copy_to_user((void __user *)ioctl_param, vm_param, 152 sizeof(struct acrn_vm_creation))) { 153 acrn_vm_destroy(vm); 154 ret = -EFAULT; 155 } 156 157 kfree(vm_param); 158 break; 159 case ACRN_IOCTL_START_VM: 160 ret = hcall_start_vm(vm->vmid); 161 if (ret < 0) 162 dev_dbg(acrn_dev.this_device, 163 "Failed to start VM %u!\n", vm->vmid); 164 break; 165 case ACRN_IOCTL_PAUSE_VM: 166 ret = hcall_pause_vm(vm->vmid); 167 if (ret < 0) 168 dev_dbg(acrn_dev.this_device, 169 "Failed to pause VM %u!\n", vm->vmid); 170 break; 171 case ACRN_IOCTL_RESET_VM: 172 ret = hcall_reset_vm(vm->vmid); 173 if (ret < 0) 174 dev_dbg(acrn_dev.this_device, 175 "Failed to restart VM %u!\n", vm->vmid); 176 break; 177 case ACRN_IOCTL_DESTROY_VM: 178 ret = acrn_vm_destroy(vm); 179 break; 180 case ACRN_IOCTL_SET_VCPU_REGS: 181 cpu_regs = memdup_user((void __user *)ioctl_param, 182 sizeof(struct acrn_vcpu_regs)); 183 if (IS_ERR(cpu_regs)) 184 return PTR_ERR(cpu_regs); 185 186 for (i = 0; i < ARRAY_SIZE(cpu_regs->reserved); i++) 187 if (cpu_regs->reserved[i]) { 188 kfree(cpu_regs); 189 return -EINVAL; 190 } 191 192 for (i = 0; i < ARRAY_SIZE(cpu_regs->vcpu_regs.reserved_32); i++) 193 if (cpu_regs->vcpu_regs.reserved_32[i]) { 194 kfree(cpu_regs); 195 return -EINVAL; 196 } 197 198 for (i = 0; i < ARRAY_SIZE(cpu_regs->vcpu_regs.reserved_64); i++) 199 if (cpu_regs->vcpu_regs.reserved_64[i]) { 200 kfree(cpu_regs); 201 return -EINVAL; 202 } 203 204 for (i = 0; i < ARRAY_SIZE(cpu_regs->vcpu_regs.gdt.reserved); i++) 205 if (cpu_regs->vcpu_regs.gdt.reserved[i] | 206 cpu_regs->vcpu_regs.idt.reserved[i]) { 207 kfree(cpu_regs); 208 return -EINVAL; 209 } 210 211 ret = hcall_set_vcpu_regs(vm->vmid, virt_to_phys(cpu_regs)); 212 if (ret < 0) 213 dev_dbg(acrn_dev.this_device, 214 "Failed to set regs state of VM%u!\n", 215 vm->vmid); 216 kfree(cpu_regs); 217 break; 218 case ACRN_IOCTL_SET_MEMSEG: 219 if (copy_from_user(&memmap, (void __user *)ioctl_param, 220 sizeof(memmap))) 221 return -EFAULT; 222 223 ret = acrn_vm_memseg_map(vm, &memmap); 224 break; 225 case ACRN_IOCTL_UNSET_MEMSEG: 226 if (copy_from_user(&memmap, (void __user *)ioctl_param, 227 sizeof(memmap))) 228 return -EFAULT; 229 230 ret = acrn_vm_memseg_unmap(vm, &memmap); 231 break; 232 case ACRN_IOCTL_ASSIGN_MMIODEV: 233 mmiodev = memdup_user((void __user *)ioctl_param, 234 sizeof(struct acrn_mmiodev)); 235 if (IS_ERR(mmiodev)) 236 return PTR_ERR(mmiodev); 237 238 ret = hcall_assign_mmiodev(vm->vmid, virt_to_phys(mmiodev)); 239 if (ret < 0) 240 dev_dbg(acrn_dev.this_device, 241 "Failed to assign MMIO device!\n"); 242 kfree(mmiodev); 243 break; 244 case ACRN_IOCTL_DEASSIGN_MMIODEV: 245 mmiodev = memdup_user((void __user *)ioctl_param, 246 sizeof(struct acrn_mmiodev)); 247 if (IS_ERR(mmiodev)) 248 return PTR_ERR(mmiodev); 249 250 ret = hcall_deassign_mmiodev(vm->vmid, virt_to_phys(mmiodev)); 251 if (ret < 0) 252 dev_dbg(acrn_dev.this_device, 253 "Failed to deassign MMIO device!\n"); 254 kfree(mmiodev); 255 break; 256 case ACRN_IOCTL_ASSIGN_PCIDEV: 257 pcidev = memdup_user((void __user *)ioctl_param, 258 sizeof(struct acrn_pcidev)); 259 if (IS_ERR(pcidev)) 260 return PTR_ERR(pcidev); 261 262 ret = hcall_assign_pcidev(vm->vmid, virt_to_phys(pcidev)); 263 if (ret < 0) 264 dev_dbg(acrn_dev.this_device, 265 "Failed to assign pci device!\n"); 266 kfree(pcidev); 267 break; 268 case ACRN_IOCTL_DEASSIGN_PCIDEV: 269 pcidev = memdup_user((void __user *)ioctl_param, 270 sizeof(struct acrn_pcidev)); 271 if (IS_ERR(pcidev)) 272 return PTR_ERR(pcidev); 273 274 ret = hcall_deassign_pcidev(vm->vmid, virt_to_phys(pcidev)); 275 if (ret < 0) 276 dev_dbg(acrn_dev.this_device, 277 "Failed to deassign pci device!\n"); 278 kfree(pcidev); 279 break; 280 case ACRN_IOCTL_CREATE_VDEV: 281 vdev = memdup_user((void __user *)ioctl_param, 282 sizeof(struct acrn_vdev)); 283 if (IS_ERR(vdev)) 284 return PTR_ERR(vdev); 285 286 ret = hcall_create_vdev(vm->vmid, virt_to_phys(vdev)); 287 if (ret < 0) 288 dev_dbg(acrn_dev.this_device, 289 "Failed to create virtual device!\n"); 290 kfree(vdev); 291 break; 292 case ACRN_IOCTL_DESTROY_VDEV: 293 vdev = memdup_user((void __user *)ioctl_param, 294 sizeof(struct acrn_vdev)); 295 if (IS_ERR(vdev)) 296 return PTR_ERR(vdev); 297 ret = hcall_destroy_vdev(vm->vmid, virt_to_phys(vdev)); 298 if (ret < 0) 299 dev_dbg(acrn_dev.this_device, 300 "Failed to destroy virtual device!\n"); 301 kfree(vdev); 302 break; 303 case ACRN_IOCTL_SET_PTDEV_INTR: 304 irq_info = memdup_user((void __user *)ioctl_param, 305 sizeof(struct acrn_ptdev_irq)); 306 if (IS_ERR(irq_info)) 307 return PTR_ERR(irq_info); 308 309 ret = hcall_set_ptdev_intr(vm->vmid, virt_to_phys(irq_info)); 310 if (ret < 0) 311 dev_dbg(acrn_dev.this_device, 312 "Failed to configure intr for ptdev!\n"); 313 kfree(irq_info); 314 break; 315 case ACRN_IOCTL_RESET_PTDEV_INTR: 316 irq_info = memdup_user((void __user *)ioctl_param, 317 sizeof(struct acrn_ptdev_irq)); 318 if (IS_ERR(irq_info)) 319 return PTR_ERR(irq_info); 320 321 ret = hcall_reset_ptdev_intr(vm->vmid, virt_to_phys(irq_info)); 322 if (ret < 0) 323 dev_dbg(acrn_dev.this_device, 324 "Failed to reset intr for ptdev!\n"); 325 kfree(irq_info); 326 break; 327 case ACRN_IOCTL_SET_IRQLINE: 328 ret = hcall_set_irqline(vm->vmid, ioctl_param); 329 if (ret < 0) 330 dev_dbg(acrn_dev.this_device, 331 "Failed to set interrupt line!\n"); 332 break; 333 case ACRN_IOCTL_INJECT_MSI: 334 msi = memdup_user((void __user *)ioctl_param, 335 sizeof(struct acrn_msi_entry)); 336 if (IS_ERR(msi)) 337 return PTR_ERR(msi); 338 339 ret = hcall_inject_msi(vm->vmid, virt_to_phys(msi)); 340 if (ret < 0) 341 dev_dbg(acrn_dev.this_device, 342 "Failed to inject MSI!\n"); 343 kfree(msi); 344 break; 345 case ACRN_IOCTL_VM_INTR_MONITOR: 346 ret = pin_user_pages_fast(ioctl_param, 1, 347 FOLL_WRITE | FOLL_LONGTERM, &page); 348 if (unlikely(ret != 1)) { 349 dev_dbg(acrn_dev.this_device, 350 "Failed to pin intr hdr buffer!\n"); 351 return -EFAULT; 352 } 353 354 ret = hcall_vm_intr_monitor(vm->vmid, page_to_phys(page)); 355 if (ret < 0) { 356 unpin_user_page(page); 357 dev_dbg(acrn_dev.this_device, 358 "Failed to monitor intr data!\n"); 359 return ret; 360 } 361 if (vm->monitor_page) 362 unpin_user_page(vm->monitor_page); 363 vm->monitor_page = page; 364 break; 365 case ACRN_IOCTL_CREATE_IOREQ_CLIENT: 366 if (vm->default_client) 367 return -EEXIST; 368 if (!acrn_ioreq_client_create(vm, NULL, NULL, true, "acrndm")) 369 ret = -EINVAL; 370 break; 371 case ACRN_IOCTL_DESTROY_IOREQ_CLIENT: 372 if (vm->default_client) 373 acrn_ioreq_client_destroy(vm->default_client); 374 break; 375 case ACRN_IOCTL_ATTACH_IOREQ_CLIENT: 376 if (vm->default_client) 377 ret = acrn_ioreq_client_wait(vm->default_client); 378 else 379 ret = -ENODEV; 380 break; 381 case ACRN_IOCTL_NOTIFY_REQUEST_FINISH: 382 if (copy_from_user(¬ify, (void __user *)ioctl_param, 383 sizeof(struct acrn_ioreq_notify))) 384 return -EFAULT; 385 386 if (notify.reserved != 0) 387 return -EINVAL; 388 389 ret = acrn_ioreq_request_default_complete(vm, notify.vcpu); 390 break; 391 case ACRN_IOCTL_CLEAR_VM_IOREQ: 392 acrn_ioreq_request_clear(vm); 393 break; 394 case ACRN_IOCTL_PM_GET_CPU_STATE: 395 if (copy_from_user(&cstate_cmd, (void __user *)ioctl_param, 396 sizeof(cstate_cmd))) 397 return -EFAULT; 398 399 ret = pmcmd_ioctl(cstate_cmd, (void __user *)ioctl_param); 400 break; 401 case ACRN_IOCTL_IOEVENTFD: 402 if (copy_from_user(&ioeventfd, (void __user *)ioctl_param, 403 sizeof(ioeventfd))) 404 return -EFAULT; 405 406 if (ioeventfd.reserved != 0) 407 return -EINVAL; 408 409 ret = acrn_ioeventfd_config(vm, &ioeventfd); 410 break; 411 case ACRN_IOCTL_IRQFD: 412 if (copy_from_user(&irqfd, (void __user *)ioctl_param, 413 sizeof(irqfd))) 414 return -EFAULT; 415 ret = acrn_irqfd_config(vm, &irqfd); 416 break; 417 default: 418 dev_dbg(acrn_dev.this_device, "Unknown IOCTL 0x%x!\n", cmd); 419 ret = -ENOTTY; 420 } 421 422 return ret; 423 } 424 425 static int acrn_dev_release(struct inode *inode, struct file *filp) 426 { 427 struct acrn_vm *vm = filp->private_data; 428 429 acrn_vm_destroy(vm); 430 kfree(vm); 431 return 0; 432 } 433 434 static ssize_t remove_cpu_store(struct device *dev, 435 struct device_attribute *attr, 436 const char *buf, size_t count) 437 { 438 u64 cpu, lapicid; 439 int ret; 440 441 if (kstrtoull(buf, 0, &cpu) < 0) 442 return -EINVAL; 443 444 if (cpu >= num_possible_cpus() || cpu == 0 || !cpu_is_hotpluggable(cpu)) 445 return -EINVAL; 446 447 if (cpu_online(cpu)) 448 remove_cpu(cpu); 449 450 lapicid = cpu_data(cpu).apicid; 451 dev_dbg(dev, "Try to remove cpu %lld with lapicid %lld\n", cpu, lapicid); 452 ret = hcall_sos_remove_cpu(lapicid); 453 if (ret < 0) { 454 dev_err(dev, "Failed to remove cpu %lld!\n", cpu); 455 goto fail_remove; 456 } 457 458 return count; 459 460 fail_remove: 461 add_cpu(cpu); 462 return ret; 463 } 464 static DEVICE_ATTR_WO(remove_cpu); 465 466 static umode_t acrn_attr_visible(struct kobject *kobj, struct attribute *a, int n) 467 { 468 if (a == &dev_attr_remove_cpu.attr) 469 return IS_ENABLED(CONFIG_HOTPLUG_CPU) ? a->mode : 0; 470 471 return a->mode; 472 } 473 474 static struct attribute *acrn_attrs[] = { 475 &dev_attr_remove_cpu.attr, 476 NULL 477 }; 478 479 static struct attribute_group acrn_attr_group = { 480 .attrs = acrn_attrs, 481 .is_visible = acrn_attr_visible, 482 }; 483 484 static const struct attribute_group *acrn_attr_groups[] = { 485 &acrn_attr_group, 486 NULL 487 }; 488 489 static const struct file_operations acrn_fops = { 490 .owner = THIS_MODULE, 491 .open = acrn_dev_open, 492 .release = acrn_dev_release, 493 .unlocked_ioctl = acrn_dev_ioctl, 494 }; 495 496 struct miscdevice acrn_dev = { 497 .minor = MISC_DYNAMIC_MINOR, 498 .name = "acrn_hsm", 499 .fops = &acrn_fops, 500 .groups = acrn_attr_groups, 501 }; 502 503 static int __init hsm_init(void) 504 { 505 int ret; 506 507 if (x86_hyper_type != X86_HYPER_ACRN) 508 return -ENODEV; 509 510 if (!(cpuid_eax(ACRN_CPUID_FEATURES) & ACRN_FEATURE_PRIVILEGED_VM)) 511 return -EPERM; 512 513 ret = misc_register(&acrn_dev); 514 if (ret) { 515 pr_err("Create misc dev failed!\n"); 516 return ret; 517 } 518 519 ret = acrn_ioreq_intr_setup(); 520 if (ret) { 521 pr_err("Setup I/O request handler failed!\n"); 522 misc_deregister(&acrn_dev); 523 return ret; 524 } 525 return 0; 526 } 527 528 static void __exit hsm_exit(void) 529 { 530 acrn_ioreq_intr_remove(); 531 misc_deregister(&acrn_dev); 532 } 533 module_init(hsm_init); 534 module_exit(hsm_exit); 535 536 MODULE_AUTHOR("Intel Corporation"); 537 MODULE_LICENSE("GPL"); 538 MODULE_DESCRIPTION("ACRN Hypervisor Service Module (HSM)"); 539