// SPDX-License-Identifier: GPL-2.0/* * ACRN_HSM: Virtual Machine management * * Copyright (C) 2020 Intel Corporation. All rights reserved. * * Authors: *	Jason Chen CJ <jason.cj.chen@intel.com> *	Yakui Zhao <yakui.zhao@intel.com> */#include <linux/io.h>#include <linux/mm.h>#include <linux/slab.h> #include "acrn_drv.h" /* List of VMs */LIST_HEAD(acrn_vm_list);/* * acrn_vm_list is read in a worker thread which dispatch I/O requests and * is wrote in VM creation ioctl. Use the rwlock mechanism to protect it. */DEFINE_RWLOCK(acrn_vm_list_lock); struct acrn_vm *acrn_vm_create(struct acrn_vm *vm,			       struct acrn_vm_creation *vm_param){	int ret; 	ret = hcall_create_vm(virt_to_phys(vm_param));	if (ret < 0 || vm_param->vmid == ACRN_INVALID_VMID) {		dev_err(acrn_dev.this_device,			"Failed to create VM! Error: %d\n", ret);		return NULL;	} 	mutex_init(&vm->regions_mapping_lock);	INIT_LIST_HEAD(&vm->ioreq_clients);	spin_lock_init(&vm->ioreq_clients_lock);	vm->vmid = vm_param->vmid;	vm->vcpu_num = vm_param->vcpu_num; 	if (acrn_ioreq_init(vm, vm_param->ioreq_buf) < 0) {		hcall_destroy_vm(vm_param->vmid);		vm->vmid = ACRN_INVALID_VMID;		return NULL;	} 	write_lock_bh(&acrn_vm_list_lock);	list_add(&vm->list, &acrn_vm_list);	write_unlock_bh(&acrn_vm_list_lock); 	acrn_ioeventfd_init(vm);	acrn_irqfd_init(vm);	dev_dbg(acrn_dev.this_device, "VM %u created.\n", vm->vmid);	return vm;} int acrn_vm_destroy(struct acrn_vm *vm){	int ret; 	if (vm->vmid == ACRN_INVALID_VMID ||	    test_and_set_bit(ACRN_VM_FLAG_DESTROYED, &vm->flags))		return 0; 	ret = hcall_destroy_vm(vm->vmid);	if (ret < 0) {		dev_err(acrn_dev.this_device,			"Failed to destroy VM %u\n", vm->vmid);		clear_bit(ACRN_VM_FLAG_DESTROYED, &vm->flags);		return ret;	} 	/* Remove from global VM list */	write_lock_bh(&acrn_vm_list_lock);	list_del_init(&vm->list);	write_unlock_bh(&acrn_vm_list_lock); 	acrn_ioeventfd_deinit(vm);	acrn_irqfd_deinit(vm);	acrn_ioreq_deinit(vm); 	if (vm->monitor_page) {		put_page(vm->monitor_page);		vm->monitor_page = NULL;	} 	acrn_vm_all_ram_unmap(vm); 	dev_dbg(acrn_dev.this_device, "VM %u destroyed.\n", vm->vmid);	vm->vmid = ACRN_INVALID_VMID;	return 0;} /** * acrn_msi_inject() - Inject a MSI interrupt into a User VM * @vm:		User VM * @msi_addr:	The MSI address * @msi_data:	The MSI data * * Return: 0 on success, <0 on error */int acrn_msi_inject(struct acrn_vm *vm, u64 msi_addr, u64 msi_data){	struct acrn_msi_entry *msi;	int ret; 	/* might be used in interrupt context, so use GFP_ATOMIC */	msi = kzalloc_obj(*msi, GFP_ATOMIC);	if (!msi)		return -ENOMEM; 	/*	 * msi_addr: addr[19:12] with dest vcpu id	 * msi_data: data[7:0] with vector	 */	msi->msi_addr = msi_addr;	msi->msi_data = msi_data;	ret = hcall_inject_msi(vm->vmid, virt_to_phys(msi));	if (ret < 0)		dev_err(acrn_dev.this_device,			"Failed to inject MSI to VM %u!\n", vm->vmid);	kfree(msi);	return ret;}