@@ -330,6 +330,104 @@ int kvm_arm_set_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
}
}
+static int gunyah_vm_add_resource_ticket(struct gunyah_vm *ghvm,
+ struct gunyah_vm_resource_ticket *ticket)
+{
+ struct gunyah_vm_resource_ticket *iter;
+ struct gunyah_resource *ghrsc, *rsc_iter;
+ int ret = 0;
+
+ mutex_lock(&ghvm->resources_lock);
+ list_for_each_entry(iter, &ghvm->resource_tickets, vm_list) {
+ if (iter->resource_type == ticket->resource_type &&
+ iter->label == ticket->label) {
+ ret = -EEXIST;
+ goto out;
+ }
+ }
+
+ list_add(&ticket->vm_list, &ghvm->resource_tickets);
+ INIT_LIST_HEAD(&ticket->resources);
+
+ list_for_each_entry_safe(ghrsc, rsc_iter, &ghvm->resources, list) {
+ if (ghrsc->type == ticket->resource_type &&
+ ghrsc->rm_label == ticket->label) {
+ if (ticket->populate(ticket, ghrsc))
+ list_move(&ghrsc->list, &ticket->resources);
+ }
+ }
+out:
+ mutex_unlock(&ghvm->resources_lock);
+ return ret;
+}
+
+static void __gunyah_vm_remove_resource_ticket(struct gunyah_vm *ghvm,
+ struct gunyah_vm_resource_ticket *ticket)
+{
+ struct gunyah_resource *ghrsc, *iter;
+
+ list_for_each_entry_safe(ghrsc, iter, &ticket->resources, list) {
+ ticket->unpopulate(ticket, ghrsc);
+ list_move(&ghrsc->list, &ghvm->resources);
+ }
+ list_del(&ticket->vm_list);
+}
+
+static void gunyah_vm_remove_resource_ticket(struct gunyah_vm *ghvm,
+ struct gunyah_vm_resource_ticket *ticket)
+{
+
+ mutex_lock(&ghvm->resources_lock);
+ __gunyah_vm_remove_resource_ticket(ghvm, ticket);
+ mutex_unlock(&ghvm->resources_lock);
+}
+
+static void gunyah_vm_add_resource(struct gunyah_vm *ghvm,
+ struct gunyah_resource *ghrsc)
+{
+ struct gunyah_vm_resource_ticket *ticket;
+
+ mutex_lock(&ghvm->resources_lock);
+ list_for_each_entry(ticket, &ghvm->resource_tickets, vm_list) {
+ if (ghrsc->type == ticket->resource_type &&
+ ghrsc->rm_label == ticket->label) {
+ if (ticket->populate(ticket, ghrsc))
+ list_add(&ghrsc->list, &ticket->resources);
+ else
+ list_add(&ghrsc->list, &ghvm->resources);
+ /* unconditonal -- we prevent multiple identical
+ * resource tickets so there will not be some other
+ * ticket elsewhere in the list if populate() failed.
+ */
+ goto found;
+ }
+ }
+ list_add(&ghrsc->list, &ghvm->resources);
+found:
+ mutex_unlock(&ghvm->resources_lock);
+}
+
+static void gunyah_vm_clean_resources(struct gunyah_vm *ghvm)
+{
+ struct gunyah_vm_resource_ticket *ticket, *titer;
+ struct gunyah_resource *ghrsc, *riter;
+
+ mutex_lock(&ghvm->resources_lock);
+ if (!list_empty(&ghvm->resource_tickets)) {
+ pr_warn("Dangling resource tickets:\n");
+ list_for_each_entry_safe(ticket, titer, &ghvm->resource_tickets,
+ vm_list) {
+ pr_warn(" %pS\n", ticket->populate);
+ __gunyah_vm_remove_resource_ticket(ghvm, ticket);
+ }
+ }
+
+ list_for_each_entry_safe(ghrsc, riter, &ghvm->resources, list) {
+ gunyah_rm_free_resource(ghrsc);
+ }
+ mutex_unlock(&ghvm->resources_lock);
+}
+
int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
{
return kvm_vcpu_exiting_guest_mode(vcpu) == IN_GUEST_MODE;
@@ -852,7 +950,9 @@ static void gunyah_vm_stop(struct gunyah_vm *ghvm)
static int gunyah_vm_start(struct gunyah_vm *ghvm)
{
- int ret;
+ struct gunyah_rm_hyp_resources *resources;
+ struct gunyah_resource *ghrsc;
+ int i, n, ret;
down_write(&ghvm->status_lock);
if (ghvm->vm_status != GUNYAH_RM_VM_STATUS_NO_STATE) {
@@ -887,6 +987,22 @@ static int gunyah_vm_start(struct gunyah_vm *ghvm)
}
ghvm->vm_status = GUNYAH_RM_VM_STATUS_READY;
+ ret = gunyah_rm_get_hyp_resources(ghvm->rm, ghvm->vmid, &resources);
+ if (ret) {
+ pr_warn("Failed to get hyp resources for VM: %d\n", ret);
+ goto err;
+ }
+
+ for (i = 0, n = le32_to_cpu(resources->n_entries); i < n; i++) {
+ ghrsc = gunyah_rm_alloc_resource(ghvm->rm,
+ &resources->entries[i]);
+ if (!ghrsc) {
+ ret = -ENOMEM;
+ goto err;
+ }
+ gunyah_vm_add_resource(ghvm, ghrsc);
+ }
+
ret = gunyah_rm_vm_start(ghvm->rm, ghvm->vmid);
if (ret) {
pr_warn("Failed to start VM: %d\n", ret);
@@ -915,6 +1031,9 @@ static struct gunyah_vm *gunyah_vm_alloc(struct gunyah_rm *rm)
init_rwsem(&ghvm->status_lock);
init_waitqueue_head(&ghvm->vm_status_wait);
ghvm->vm_status = GUNYAH_RM_VM_STATUS_NO_STATE;
+ mutex_init(&ghvm->resources_lock);
+ INIT_LIST_HEAD(&ghvm->resources);
+ INIT_LIST_HEAD(&ghvm->resource_tickets);
return ghvm;
}
@@ -930,6 +1049,8 @@ static void gunyah_destroy_vm(struct gunyah_vm *ghvm)
if (ghvm->vm_status == GUNYAH_RM_VM_STATUS_RUNNING)
gunyah_vm_stop(ghvm);
+ gunyah_vm_clean_resources(ghvm);
+
if (ghvm->vm_status == GUNYAH_RM_VM_STATUS_EXITED ||
ghvm->vm_status == GUNYAH_RM_VM_STATUS_READY ||
ghvm->vm_status == GUNYAH_RM_VM_STATUS_INIT_FAILED) {
@@ -10,6 +10,7 @@
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/limits.h>
+#include <linux/list.h>
#include <linux/types.h>
#include <linux/kvm_host.h>
@@ -18,6 +19,8 @@
#define kvm_to_gunyah(kvm_ptr) \
container_of(kvm_ptr, struct gunyah_vm, kvm)
+struct gunyah_vm;
+
/* Matches resource manager's resource types for VM_GET_HYP_RESOURCES RPC */
enum gunyah_resource_type {
/* clang-format off */
@@ -35,10 +38,39 @@ struct gunyah_resource {
enum gunyah_resource_type type;
u64 capid;
unsigned int irq;
-
+ struct list_head list;
u32 rm_label;
};
+/**
+ * struct gunyah_vm_resource_ticket - Represents a ticket to reserve access to VM resource(s)
+ * @label: Label of the resource from resource manager this ticket reserves.
+ * @vm_list: for @gunyah_vm->resource_tickets
+ * @resources: List of resource(s) associated with this ticket
+ * (members are from @gunyah_resource->list)
+ * @resource_type: Type of resource this ticket reserves
+ * @populate: callback provided by the ticket owner and called when a resource is found that
+ * matches @resource_type and @label. Note that this callback could be called
+ * multiple times if userspace created mutliple resources with the same type/label.
+ * This callback may also have significant delay after gunyah_vm_add_resource_ticket()
+ * since gunyah_vm_add_resource_ticket() could be called before the VM starts.
+ * @unpopulate: callback provided by the ticket owner and called when the ticket owner should no
+ * longer use the resource provided in the argument. When unpopulate() returns,
+ * the ticket owner should not be able to use the resource any more as the resource
+ * might being freed.
+ */
+struct gunyah_vm_resource_ticket {
+ u32 label;
+ struct list_head vm_list;
+ struct list_head resources;
+ enum gunyah_resource_type resource_type;
+ bool (*populate)(struct gunyah_vm_resource_ticket *ticket,
+ struct gunyah_resource *ghrsc);
+ void (*unpopulate)(struct gunyah_vm_resource_ticket *ticket,
+ struct gunyah_resource *ghrsc);
+};
+
+
/**
* struct gunyah_vm - Main representation of a Gunyah Virtual machine
memory shared with the guest.
@@ -49,6 +81,9 @@ struct gunyah_resource {
* @vm_status: Current state of the VM, as last reported by RM
* @vm_status_wait: Wait queue for status @vm_status changes
* @status_lock: Serializing state transitions
+ * @resource_lock: Serializing addition of resources and resource tickets
+ * @resources: List of &struct gunyah_resource that are associated with this VM
+ * @resource_tickets: List of &struct gunyah_vm_resource_ticket
* @auth: Authentication mechanism to be used by resource manager when
* launching the VM
*/
@@ -56,12 +91,13 @@ struct gunyah_vm {
u16 vmid;
struct kvm kvm;
struct gunyah_rm *rm;
-
struct notifier_block nb;
enum gunyah_rm_vm_status vm_status;
wait_queue_head_t vm_status_wait;
struct rw_semaphore status_lock;
-
+ struct mutex resources_lock;
+ struct list_head resources;
+ struct list_head resource_tickets;
enum gunyah_rm_vm_auth_mechanism auth;
};