1 // SPDX-License-Identifier: GPL-2.0
3 * ACRN Hypervisor Service Module (HSM)
5 * Copyright (C) 2020 Intel Corporation. All rights reserved.
8 * Fengwei Yin <fengwei.yin@intel.com>
9 * Yakui Zhao <yakui.zhao@intel.com>
12 #include <linux/cpu.h>
15 #include <linux/module.h>
16 #include <linux/slab.h>
19 #include <asm/hypervisor.h>
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.
29 static int acrn_dev_open(struct inode *inode, struct file *filp)
33 vm = kzalloc(sizeof(*vm), GFP_KERNEL);
37 vm->vmid = ACRN_INVALID_VMID;
38 filp->private_data = vm;
42 static int pmcmd_ioctl(u64 cmd, void __user *uptr)
44 struct acrn_pstate_data *px_data;
45 struct acrn_cstate_data *cx_data;
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);
56 ret = hcall_get_cpu_state(cmd, virt_to_phys(pm_info));
62 if (copy_to_user(uptr, pm_info, sizeof(u64)))
66 case ACRN_PMCMD_GET_PX_DATA:
67 px_data = kmalloc(sizeof(*px_data), GFP_KERNEL);
71 ret = hcall_get_cpu_state(cmd, virt_to_phys(px_data));
77 if (copy_to_user(uptr, px_data, sizeof(*px_data)))
81 case ACRN_PMCMD_GET_CX_DATA:
82 cx_data = kmalloc(sizeof(*cx_data), GFP_KERNEL);
86 ret = hcall_get_cpu_state(cmd, virt_to_phys(cx_data));
92 if (copy_to_user(uptr, cx_data, sizeof(*cx_data)))
104 * HSM relies on hypercall layer of the ACRN hypervisor to do the
105 * sanity check against the input parameters.
107 static long acrn_dev_ioctl(struct file *filp, unsigned int cmd,
108 unsigned long ioctl_param)
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_msi_entry *msi;
118 struct acrn_pcidev *pcidev;
119 struct acrn_irqfd irqfd;
124 if (vm->vmid == ACRN_INVALID_VMID && cmd != ACRN_IOCTL_CREATE_VM) {
125 dev_dbg(acrn_dev.this_device,
126 "ioctl 0x%x: Invalid VM state!\n", cmd);
131 case ACRN_IOCTL_CREATE_VM:
132 vm_param = memdup_user((void __user *)ioctl_param,
133 sizeof(struct acrn_vm_creation));
134 if (IS_ERR(vm_param))
135 return PTR_ERR(vm_param);
137 if ((vm_param->reserved0 | vm_param->reserved1) != 0)
140 vm = acrn_vm_create(vm, vm_param);
147 if (copy_to_user((void __user *)ioctl_param, vm_param,
148 sizeof(struct acrn_vm_creation))) {
155 case ACRN_IOCTL_START_VM:
156 ret = hcall_start_vm(vm->vmid);
158 dev_dbg(acrn_dev.this_device,
159 "Failed to start VM %u!\n", vm->vmid);
161 case ACRN_IOCTL_PAUSE_VM:
162 ret = hcall_pause_vm(vm->vmid);
164 dev_dbg(acrn_dev.this_device,
165 "Failed to pause VM %u!\n", vm->vmid);
167 case ACRN_IOCTL_RESET_VM:
168 ret = hcall_reset_vm(vm->vmid);
170 dev_dbg(acrn_dev.this_device,
171 "Failed to restart VM %u!\n", vm->vmid);
173 case ACRN_IOCTL_DESTROY_VM:
174 ret = acrn_vm_destroy(vm);
176 case ACRN_IOCTL_SET_VCPU_REGS:
177 cpu_regs = memdup_user((void __user *)ioctl_param,
178 sizeof(struct acrn_vcpu_regs));
179 if (IS_ERR(cpu_regs))
180 return PTR_ERR(cpu_regs);
182 for (i = 0; i < ARRAY_SIZE(cpu_regs->reserved); i++)
183 if (cpu_regs->reserved[i])
186 for (i = 0; i < ARRAY_SIZE(cpu_regs->vcpu_regs.reserved_32); i++)
187 if (cpu_regs->vcpu_regs.reserved_32[i])
190 for (i = 0; i < ARRAY_SIZE(cpu_regs->vcpu_regs.reserved_64); i++)
191 if (cpu_regs->vcpu_regs.reserved_64[i])
194 for (i = 0; i < ARRAY_SIZE(cpu_regs->vcpu_regs.gdt.reserved); i++)
195 if (cpu_regs->vcpu_regs.gdt.reserved[i] |
196 cpu_regs->vcpu_regs.idt.reserved[i])
199 ret = hcall_set_vcpu_regs(vm->vmid, virt_to_phys(cpu_regs));
201 dev_dbg(acrn_dev.this_device,
202 "Failed to set regs state of VM%u!\n",
206 case ACRN_IOCTL_SET_MEMSEG:
207 if (copy_from_user(&memmap, (void __user *)ioctl_param,
211 ret = acrn_vm_memseg_map(vm, &memmap);
213 case ACRN_IOCTL_UNSET_MEMSEG:
214 if (copy_from_user(&memmap, (void __user *)ioctl_param,
218 ret = acrn_vm_memseg_unmap(vm, &memmap);
220 case ACRN_IOCTL_ASSIGN_PCIDEV:
221 pcidev = memdup_user((void __user *)ioctl_param,
222 sizeof(struct acrn_pcidev));
224 return PTR_ERR(pcidev);
226 ret = hcall_assign_pcidev(vm->vmid, virt_to_phys(pcidev));
228 dev_dbg(acrn_dev.this_device,
229 "Failed to assign pci device!\n");
232 case ACRN_IOCTL_DEASSIGN_PCIDEV:
233 pcidev = memdup_user((void __user *)ioctl_param,
234 sizeof(struct acrn_pcidev));
236 return PTR_ERR(pcidev);
238 ret = hcall_deassign_pcidev(vm->vmid, virt_to_phys(pcidev));
240 dev_dbg(acrn_dev.this_device,
241 "Failed to deassign pci device!\n");
244 case ACRN_IOCTL_SET_PTDEV_INTR:
245 irq_info = memdup_user((void __user *)ioctl_param,
246 sizeof(struct acrn_ptdev_irq));
247 if (IS_ERR(irq_info))
248 return PTR_ERR(irq_info);
250 ret = hcall_set_ptdev_intr(vm->vmid, virt_to_phys(irq_info));
252 dev_dbg(acrn_dev.this_device,
253 "Failed to configure intr for ptdev!\n");
256 case ACRN_IOCTL_RESET_PTDEV_INTR:
257 irq_info = memdup_user((void __user *)ioctl_param,
258 sizeof(struct acrn_ptdev_irq));
259 if (IS_ERR(irq_info))
260 return PTR_ERR(irq_info);
262 ret = hcall_reset_ptdev_intr(vm->vmid, virt_to_phys(irq_info));
264 dev_dbg(acrn_dev.this_device,
265 "Failed to reset intr for ptdev!\n");
268 case ACRN_IOCTL_SET_IRQLINE:
269 ret = hcall_set_irqline(vm->vmid, ioctl_param);
271 dev_dbg(acrn_dev.this_device,
272 "Failed to set interrupt line!\n");
274 case ACRN_IOCTL_INJECT_MSI:
275 msi = memdup_user((void __user *)ioctl_param,
276 sizeof(struct acrn_msi_entry));
280 ret = hcall_inject_msi(vm->vmid, virt_to_phys(msi));
282 dev_dbg(acrn_dev.this_device,
283 "Failed to inject MSI!\n");
286 case ACRN_IOCTL_VM_INTR_MONITOR:
287 ret = pin_user_pages_fast(ioctl_param, 1,
288 FOLL_WRITE | FOLL_LONGTERM, &page);
289 if (unlikely(ret != 1)) {
290 dev_dbg(acrn_dev.this_device,
291 "Failed to pin intr hdr buffer!\n");
295 ret = hcall_vm_intr_monitor(vm->vmid, page_to_phys(page));
297 unpin_user_page(page);
298 dev_dbg(acrn_dev.this_device,
299 "Failed to monitor intr data!\n");
302 if (vm->monitor_page)
303 unpin_user_page(vm->monitor_page);
304 vm->monitor_page = page;
306 case ACRN_IOCTL_CREATE_IOREQ_CLIENT:
307 if (vm->default_client)
309 if (!acrn_ioreq_client_create(vm, NULL, NULL, true, "acrndm"))
312 case ACRN_IOCTL_DESTROY_IOREQ_CLIENT:
313 if (vm->default_client)
314 acrn_ioreq_client_destroy(vm->default_client);
316 case ACRN_IOCTL_ATTACH_IOREQ_CLIENT:
317 if (vm->default_client)
318 ret = acrn_ioreq_client_wait(vm->default_client);
322 case ACRN_IOCTL_NOTIFY_REQUEST_FINISH:
323 if (copy_from_user(¬ify, (void __user *)ioctl_param,
324 sizeof(struct acrn_ioreq_notify)))
327 if (notify.reserved != 0)
330 ret = acrn_ioreq_request_default_complete(vm, notify.vcpu);
332 case ACRN_IOCTL_CLEAR_VM_IOREQ:
333 acrn_ioreq_request_clear(vm);
335 case ACRN_IOCTL_PM_GET_CPU_STATE:
336 if (copy_from_user(&cstate_cmd, (void __user *)ioctl_param,
340 ret = pmcmd_ioctl(cstate_cmd, (void __user *)ioctl_param);
342 case ACRN_IOCTL_IOEVENTFD:
343 if (copy_from_user(&ioeventfd, (void __user *)ioctl_param,
347 if (ioeventfd.reserved != 0)
350 ret = acrn_ioeventfd_config(vm, &ioeventfd);
352 case ACRN_IOCTL_IRQFD:
353 if (copy_from_user(&irqfd, (void __user *)ioctl_param,
356 ret = acrn_irqfd_config(vm, &irqfd);
359 dev_dbg(acrn_dev.this_device, "Unknown IOCTL 0x%x!\n", cmd);
366 static int acrn_dev_release(struct inode *inode, struct file *filp)
368 struct acrn_vm *vm = filp->private_data;
375 static ssize_t remove_cpu_store(struct device *dev,
376 struct device_attribute *attr,
377 const char *buf, size_t count)
382 if (kstrtoull(buf, 0, &cpu) < 0)
385 if (cpu >= num_possible_cpus() || cpu == 0 || !cpu_is_hotpluggable(cpu))
391 lapicid = cpu_data(cpu).apicid;
392 dev_dbg(dev, "Try to remove cpu %lld with lapicid %lld\n", cpu, lapicid);
393 ret = hcall_sos_remove_cpu(lapicid);
395 dev_err(dev, "Failed to remove cpu %lld!\n", cpu);
405 static DEVICE_ATTR_WO(remove_cpu);
407 static umode_t acrn_attr_visible(struct kobject *kobj, struct attribute *a, int n)
409 if (a == &dev_attr_remove_cpu.attr)
410 return IS_ENABLED(CONFIG_HOTPLUG_CPU) ? a->mode : 0;
415 static struct attribute *acrn_attrs[] = {
416 &dev_attr_remove_cpu.attr,
420 static struct attribute_group acrn_attr_group = {
422 .is_visible = acrn_attr_visible,
425 static const struct attribute_group *acrn_attr_groups[] = {
430 static const struct file_operations acrn_fops = {
431 .owner = THIS_MODULE,
432 .open = acrn_dev_open,
433 .release = acrn_dev_release,
434 .unlocked_ioctl = acrn_dev_ioctl,
437 struct miscdevice acrn_dev = {
438 .minor = MISC_DYNAMIC_MINOR,
441 .groups = acrn_attr_groups,
444 static int __init hsm_init(void)
448 if (x86_hyper_type != X86_HYPER_ACRN)
451 if (!(cpuid_eax(ACRN_CPUID_FEATURES) & ACRN_FEATURE_PRIVILEGED_VM))
454 ret = misc_register(&acrn_dev);
456 pr_err("Create misc dev failed!\n");
460 ret = acrn_ioreq_intr_setup();
462 pr_err("Setup I/O request handler failed!\n");
463 misc_deregister(&acrn_dev);
469 static void __exit hsm_exit(void)
471 acrn_ioreq_intr_remove();
472 misc_deregister(&acrn_dev);
474 module_init(hsm_init);
475 module_exit(hsm_exit);
477 MODULE_AUTHOR("Intel Corporation");
478 MODULE_LICENSE("GPL");
479 MODULE_DESCRIPTION("ACRN Hypervisor Service Module (HSM)");