diff --git a/drivers/virt/gunyah/Kconfig b/drivers/virt/gunyah/Kconfig index c15a1cc730f5..d997663471c1 100644 --- a/drivers/virt/gunyah/Kconfig +++ b/drivers/virt/gunyah/Kconfig @@ -1,5 +1,14 @@ # SPDX-License-Identifier: GPL-2.0-only +config GH_PROXY_SCHED + tristate "PROXY Scheduling for Secondary VMs" + depends on GUNYAH + help + Gunyah Proxy Scheduler provides framework to schedule/run VCPUs + of Secondary VMs by exposing required functionality which can be + invoked by the Gunyah driver. Gunyah Proxy Scheduler communicates + with Gunyah hypervisor to run the VCPUs as needed. + menuconfig GUNYAH_DRIVERS bool "Gunyah Virtualization drivers" depends on ARM64 diff --git a/drivers/virt/gunyah/gh_proxy_sched.c b/drivers/virt/gunyah/gh_proxy_sched.c new file mode 100644 index 000000000000..a43101d9eebf --- /dev/null +++ b/drivers/virt/gunyah/gh_proxy_sched.c @@ -0,0 +1,732 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright 2018 The Hafnium Authors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * This driver is based on idea from Hafnium Hypervisor Linux Driver, + * but modified to work with Gunyah Hypervisor as needed. + * + * Copyright (c) 2021-2022, Qualcomm Innovation Center, Inc. All rights reserved. + */ + +#define pr_fmt(fmt) "gh_proxy_sched: " fmt + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include "gh_proxy_sched.h" + +#define CREATE_TRACE_POINTS +#include "gh_proxy_sched_trace.h" + +#define GH_MAX_VMS 5 +#define GH_MAX_VCPUS_PER_VM 8 +#define GH_MAX_SYSTEM_VCPUS (GH_MAX_VMS * GH_MAX_VCPUS_PER_VM) + +/* VCPU is ready to run */ +#define GH_VCPU_STATE_READY 0 +/* VCPU is sleeping until an interrupt arrives */ +#define GH_VCPU_STATE_EXPECTS_WAKEUP 1 +/* VCPU is powered off */ +#define GH_VCPU_STATE_POWERED_OFF 2 +/* VCPU is blocked in EL2 for an unspecified reason */ +#define GH_VCPU_STATE_BLOCKED 3 + +#define GH_VCPU_SUSPEND_STATE_STANDBY 0 +#define GH_VCPU_SUSPEND_STATE_POWERDOWN 1 + +#define SVM_STATE_RUNNING 1 +#define SVM_STATE_SYSTEM_SUSPENDED 3 + +struct gh_proxy_vcpu { + struct gh_proxy_vm *vm; + gh_capid_t cap_id; + gh_label_t idx; + bool abort_sleep; + struct task_struct *task; + int virq; + char irq_name[32]; + char ws_name[32]; + wait_queue_head_t wait_queue; + struct wakeup_source *ws; +}; + +struct gh_proxy_vm { + gh_vmid_t id; + int vcpu_count; + struct gh_proxy_vcpu vcpu[GH_MAX_VCPUS_PER_VM]; + bool is_vcpu_info_populated; + bool is_active; + + gh_capid_t wdog_cap_id; + gh_capid_t vpmg_cap_id; + int susp_res_irq; + bool is_vpm_group_info_populated; +}; + +static struct gh_proxy_vm *gh_vms; +static int nr_vms; +static int nr_vcpus; +static bool init_done; +static DEFINE_MUTEX(gh_vm_mutex); +static DEFINE_SPINLOCK(gh_vm_lock); + +/* + * Wakes up the thread responsible for running the given vcpu. + */ +static inline void gh_vcpu_wake_up(struct gh_proxy_vcpu *vcpu) +{ + vcpu->abort_sleep = true; + + return wake_up(&vcpu->wait_queue); +} + +/* + * Puts the current thread to sleep. The current thread must be responsible for + * running the given vcpu. + */ +static inline void gh_vcpu_sleep(struct gh_proxy_vcpu *vcpu) +{ + if (!vcpu->abort_sleep && !signal_pending(current)) + wait_event_interruptible(vcpu->wait_queue, vcpu->abort_sleep); +} + +static void gh_init_wait_queues(struct gh_proxy_vm *vm) +{ + gh_label_t j; + + for (j = 0; j < vm->vcpu_count; j++) + init_waitqueue_head(&vm->vcpu[j].wait_queue); +} + +static inline bool is_vm_supports_proxy(gh_vmid_t gh_vmid) +{ + gh_vmid_t vmid; + + if ((!gh_rm_get_vmid(GH_TRUSTED_VM, &vmid) && vmid == gh_vmid) || + (!gh_rm_get_vmid(GH_OEM_VM, &vmid) && vmid == gh_vmid)) + return true; + + return false; +} + +static inline struct gh_proxy_vm *gh_get_vm(gh_vmid_t vmid) +{ + int i; + struct gh_proxy_vm *vm = NULL; + + for (i = 0; i < GH_MAX_VMS; i++) { + vm = &gh_vms[i]; + if (vmid == vm->id || vm->id == GH_VMID_INVAL) + break; + } + + return vm; +} + +static inline struct gh_proxy_vcpu *gh_get_vcpu(struct gh_proxy_vm *vm, gh_capid_t cap_id) +{ + int i; + struct gh_proxy_vcpu *vcpu = NULL; + + for (i = 0; i < vm->vcpu_count; i++) { + if (vm->vcpu[i].cap_id == cap_id) { + vcpu = &vm->vcpu[i]; + break; + } + } + + return vcpu; +} + +static inline void gh_reset_vm(struct gh_proxy_vm *vm) +{ + int j; + + vm->id = GH_VMID_INVAL; + vm->vcpu_count = 0; + vm->is_vcpu_info_populated = false; + vm->is_active = false; + vm->susp_res_irq = U32_MAX; + vm->is_vpm_group_info_populated = false; + vm->vpmg_cap_id = GH_CAPID_INVAL; + for (j = 0; j < GH_MAX_VCPUS_PER_VM; j++) { + vm->vcpu[j].cap_id = GH_CAPID_INVAL; + vm->vcpu[j].virq = U32_MAX; + vm->vcpu[j].idx = U32_MAX; + vm->vcpu[j].vm = NULL; + vm->vcpu[j].abort_sleep = false; + vm->vcpu[j].ws = NULL; + strscpy(vm->vcpu[vm->vcpu_count].irq_name, "", + sizeof(vm->vcpu[vm->vcpu_count].irq_name)); + strscpy(vm->vcpu[vm->vcpu_count].ws_name, "", + sizeof(vm->vcpu[vm->vcpu_count].ws_name)); + } +} + +static void gh_init_vms(void) +{ + struct gh_proxy_vm *vm; + int i; + + for (i = 0; i < GH_MAX_VMS; i++) { + vm = &gh_vms[i]; + gh_reset_vm(vm); + } +} + +static irqreturn_t gh_vcpu_irq_handler(int irq, void *data) +{ + struct gh_proxy_vcpu *vcpu; + + spin_lock(&gh_vm_lock); + vcpu = data; + if (!vcpu || !vcpu->vm || !vcpu->vm->is_vcpu_info_populated) + goto unlock; + + trace_gh_vcpu_irq_handler(vcpu->vm->id, vcpu->idx); + gh_vcpu_wake_up(vcpu); + +unlock: + spin_unlock(&gh_vm_lock); + return IRQ_HANDLED; +} + +static inline void gh_get_vcpu_prop_name(int vmid, int vcpu_num, char *name) +{ + char extrastr[12]; + + scnprintf(extrastr, 12, "_%d_%d", vmid, vcpu_num); + strlcat(name, extrastr, 32); +} + +static int gh_wdog_manage(gh_vmid_t vmid, gh_capid_t cap_id, bool populate) +{ + struct gh_proxy_vm *vm; + int ret = 0; + + if (!init_done) { + pr_err("Driver probe failed\n"); + return -ENXIO; + } + + if (!is_vm_supports_proxy(vmid)) { + pr_info("Skip populating VCPU affinity info for VM=%d\n", vmid); + return -EINVAL; + } + + mutex_lock(&gh_vm_mutex); + vm = gh_get_vm(vmid); + if (!vm) { + ret = -ENODEV; + goto unlock; + } + + if (populate) + vm->wdog_cap_id = cap_id; + else + vm->wdog_cap_id = GH_CAPID_INVAL; + +unlock: + mutex_unlock(&gh_vm_mutex); + return ret; +} + +/* + * Called when vm_status is STATUS_READY, multiple times before status + * moves to STATUS_RUNNING + */ +static int gh_populate_vm_vcpu_info(gh_vmid_t vmid, gh_label_t cpu_idx, + gh_capid_t cap_id, int virq_num) +{ + struct gh_proxy_vm *vm; + int ret = 0; + char *vcpu_irq_name; + + if (!init_done) { + pr_err("Driver probe failed\n"); + ret = -ENXIO; + goto out; + } + + if (!is_vm_supports_proxy(vmid)) { + pr_info("Skip populating VCPU affinity info for VM=%d\n", vmid); + goto out; + } + + if (nr_vcpus >= GH_MAX_SYSTEM_VCPUS) { + pr_err("Exceeded max vcpus in the system %d\n", nr_vcpus); + ret = -ENXIO; + goto out; + } + + if (!virq_num || virq_num == U32_MAX) { + pr_err("Invalid VIRQ, proxy scheduling isn't supported\n"); + goto out; + } + + mutex_lock(&gh_vm_mutex); + vm = gh_get_vm(vmid); + if (vm && !vm->is_vcpu_info_populated) { + if (vm->vcpu_count >= GH_MAX_VCPUS_PER_VM) { + pr_err("Exceeded max vcpus per VM %d\n", vm->vcpu_count); + ret = -ENXIO; + goto unlock; + } + + strscpy(vm->vcpu[vm->vcpu_count].irq_name, "gh_vcpu_irq", + sizeof(vm->vcpu[vm->vcpu_count].irq_name)); + gh_get_vcpu_prop_name(vmid, vm->vcpu_count, + vm->vcpu[vm->vcpu_count].irq_name); + ret = request_irq(virq_num, gh_vcpu_irq_handler, 0, + vm->vcpu[vm->vcpu_count].irq_name, + &vm->vcpu[vm->vcpu_count]); + if (ret < 0) { + pr_err("%s: IRQ registration failed ret=%d\n", __func__, ret); + goto err_irq; + } + + strscpy(vm->vcpu[vm->vcpu_count].ws_name, "gh_vcpu_ws", + sizeof(vm->vcpu[vm->vcpu_count].ws_name)); + gh_get_vcpu_prop_name(vmid, vm->vcpu_count, + vm->vcpu[vm->vcpu_count].ws_name); + vm->vcpu[vm->vcpu_count].ws = wakeup_source_register(NULL, + vm->vcpu[vm->vcpu_count].ws_name); + if (!vm->vcpu[vm->vcpu_count].ws) { + pr_err("%s: Wakeup source creation failed\n", __func__); + goto err_ws; + } + + vm->id = vmid; + vm->vcpu[vm->vcpu_count].cap_id = cap_id; + vm->vcpu[vm->vcpu_count].virq = virq_num; + vm->vcpu[vm->vcpu_count].idx = cpu_idx; + vm->vcpu[vm->vcpu_count].vm = vm; + vcpu_irq_name = vm->vcpu[vm->vcpu_count].irq_name; + vm->vcpu_count++; + + nr_vcpus++; + pr_info("vmid=%d cpu_index:%u vcpu_cap_id:%llu virq_num=%d irq_name=%s nr_vcpus:%d\n", + vmid, cpu_idx, cap_id, virq_num, vcpu_irq_name, nr_vcpus); + } + goto unlock; + +err_ws: + strscpy(vm->vcpu[vm->vcpu_count].ws_name, "", + sizeof(vm->vcpu[vm->vcpu_count].ws_name)); + free_irq(virq_num, &vm->vcpu[vm->vcpu_count]); +err_irq: + strscpy(vm->vcpu[vm->vcpu_count].irq_name, "", + sizeof(vm->vcpu[vm->vcpu_count].irq_name)); +unlock: + mutex_unlock(&gh_vm_mutex); +out: + return ret; +} + +static int gh_unpopulate_vm_vcpu_info(gh_vmid_t vmid, gh_label_t cpu_idx, + gh_capid_t cap_id, int *irq) +{ + struct gh_proxy_vm *vm; + struct gh_proxy_vcpu *vcpu; + + if (!init_done) { + pr_err("Driver probe failed\n"); + return -ENXIO; + } + + if (!is_vm_supports_proxy(vmid)) { + pr_info("Skip unpopulating VCPU affinity info for VM=%d\n", vmid); + goto out; + } + + mutex_lock(&gh_vm_mutex); + vm = gh_get_vm(vmid); + if (vm && vm->is_vcpu_info_populated) { + vcpu = gh_get_vcpu(vm, cap_id); + if (vcpu) { + *irq = vcpu->virq; + free_irq(vcpu->virq, vcpu); + vcpu->virq = U32_MAX; + wakeup_source_unregister(vcpu->ws); + + if (nr_vcpus) + nr_vcpus--; + } + } + mutex_unlock(&gh_vm_mutex); + +out: + return 0; +} + +static inline void gh_get_vpmg_cap_id(int irq, gh_capid_t *vpmg_cap_id) +{ + int i; + struct gh_proxy_vm *vm; + + for (i = 0; i < GH_MAX_VMS; i++) { + vm = &gh_vms[i]; + if (vm->susp_res_irq == irq) + *vpmg_cap_id = vm->vpmg_cap_id; + } +} + +static irqreturn_t gh_susp_res_irq_handler(int irq, void *data) +{ + int err; + uint64_t vpmg_state; + gh_capid_t vpmg_cap_id; + + gh_get_vpmg_cap_id(irq, &vpmg_cap_id); + err = gh_hcall_vpm_group_get_state(vpmg_cap_id, &vpmg_state); + + if (err != GH_ERROR_OK) { + pr_err("Failed to get VPM Group state for cap_id=%llu err=%d\n", + vpmg_cap_id, err); + return IRQ_HANDLED; + } + + if (vpmg_state == SVM_STATE_RUNNING) + pr_debug("SVM is in running state\n"); + else if (vpmg_state == SVM_STATE_SYSTEM_SUSPENDED) + pr_debug("SVM is in system suspend state\n"); + else + pr_err("VPM Group state invalid/non-existent\n"); + + trace_gh_susp_res_irq_handler(vpmg_state); + + return IRQ_HANDLED; +} + +static int gh_populate_vm_vpm_grp_info(gh_vmid_t vmid, gh_capid_t cap_id, int virq_num) +{ + int ret = 0; + struct gh_proxy_vm *vm; + + if (!init_done) { + pr_err("%s: Driver probe failed\n", __func__); + ret = -ENXIO; + goto out; + } + + if (!is_vm_supports_proxy(vmid)) { + pr_info("Skip populating VPM GRP info for VM=%d\n", vmid); + goto out; + } + + if (virq_num < 0) { + pr_err("%s: Invalid IRQ number\n", __func__); + ret = -EINVAL; + goto out; + } + + mutex_lock(&gh_vm_mutex); + vm = gh_get_vm(vmid); + if (vm && !vm->is_vpm_group_info_populated) { + ret = request_irq(virq_num, gh_susp_res_irq_handler, 0, + "gh_susp_res_irq", NULL); + if (ret < 0) { + pr_err("%s: IRQ registration failed ret=%d\n", __func__, ret); + goto unlock; + } + + vm->vpmg_cap_id = cap_id; + vm->susp_res_irq = virq_num; + vm->is_vpm_group_info_populated = true; + } + +unlock: + mutex_unlock(&gh_vm_mutex); +out: + return ret; +} + +static int gh_unpopulate_vm_vpm_grp_info(gh_vmid_t vmid, int *irq) +{ + struct gh_proxy_vm *vm; + + if (!init_done) { + pr_err("%s: Driver probe failed\n", __func__); + return -ENXIO; + } + + if (!is_vm_supports_proxy(vmid)) { + pr_info("Skip unpopulating VPM GRP info for VM=%d\n", vmid); + goto out; + } + + mutex_lock(&gh_vm_mutex); + vm = gh_get_vm(vmid); + if (vm && vm->is_vpm_group_info_populated) { + *irq = vm->susp_res_irq; + free_irq(vm->susp_res_irq, NULL); + vm->susp_res_irq = U32_MAX; + vm->is_vpm_group_info_populated = false; + } + mutex_unlock(&gh_vm_mutex); + +out: + return 0; +} + +static void gh_populate_all_res_info(gh_vmid_t vmid, bool res_populated) +{ + struct gh_proxy_vm *vm; + + if (!init_done) { + pr_err("%s: Driver probe failed\n", __func__); + return; + } + + if (!is_vm_supports_proxy(vmid)) { + pr_info("Proxy Scheduling isn't supported for VM=%d\n", vmid); + return; + } + + if (nr_vms >= GH_MAX_VMS) { + pr_err("Exceeded max VMs in the system %d\n", nr_vms); + return; + } + + mutex_lock(&gh_vm_mutex); + vm = gh_get_vm(vmid); + if (!vm) + goto unlock; + + if (res_populated && !vm->is_vcpu_info_populated) { + gh_init_wait_queues(vm); + nr_vms++; + vm->is_vcpu_info_populated = true; + vm->is_active = true; + } else if (!res_populated && vm->is_vcpu_info_populated) { + gh_reset_vm(vm); + if (nr_vms) + nr_vms--; + } +unlock: + mutex_unlock(&gh_vm_mutex); +} + + +int gh_get_nr_vcpus(gh_vmid_t vmid) +{ + struct gh_proxy_vm *vm; + + vm = gh_get_vm(vmid); + if (vm && vm->is_vcpu_info_populated) + return vm->vcpu_count; + + return 0; +} + +/* Gets called from VM EXIT notification */ +void gh_wakeup_all_vcpus(gh_vmid_t vmid) +{ + struct gh_proxy_vm *vm; + int i; + + vm = gh_get_vm(vmid); + if (vm && vm->is_active) { + vm->is_active = false; + + for (i = 0; i < vm->vcpu_count; i++) + gh_vcpu_wake_up(&vm->vcpu[i]); + } +} + +bool gh_vm_supports_proxy_sched(gh_vmid_t vmid) +{ + struct gh_proxy_vm *vm; + + vm = gh_get_vm(vmid); + if (vm && vm->is_vcpu_info_populated && vm->vcpu_count) + return true; + + return false; +} + +int gh_vcpu_run(gh_vmid_t vmid, unsigned int vcpu_id, uint64_t resume_data_0, + uint64_t resume_data_1, uint64_t resume_data_2, struct gh_hcall_vcpu_run_resp *resp) +{ + struct gh_proxy_vcpu *vcpu; + struct gh_proxy_vm *vm; + int ret; + ktime_t start_ts, yield_ts; + + vm = gh_get_vm(vmid); + if (!vm || !vm->is_active) + return -EPERM; + + if (vm->vcpu[vcpu_id].cap_id == GH_CAPID_INVAL) + return -EPERM; + + vcpu = &vm->vcpu[vcpu_id]; + + do { + /* + * We're about to run the vcpu, so we can reset the abort-sleep flag. + */ + vcpu->abort_sleep = false; + gh_hcall_wdog_manage(vm->wdog_cap_id, WATCHDOG_MANAGE_OP_UNFREEZE); + __pm_stay_awake(vcpu->ws); + + start_ts = ktime_get(); + /* Call into Gunyah to run vcpu. */ + preempt_disable(); + ret = gh_hcall_vcpu_run(vcpu->cap_id, resume_data_0, + resume_data_1, resume_data_2, resp); + if (ret == GH_ERROR_OK && resp->vcpu_state == GH_VCPU_STATE_READY) { + if (need_resched()) + gh_hcall_wdog_manage(vm->wdog_cap_id, + WATCHDOG_MANAGE_OP_FREEZE); + } + preempt_enable(); + yield_ts = ktime_get() - start_ts; + trace_gh_hcall_vcpu_run(ret, vcpu->vm->id, vcpu_id, yield_ts, + resp->vcpu_state, resp->vcpu_suspend_state); + + if (ret == GH_ERROR_OK) { + switch (resp->vcpu_state) { + /* VCPU is preempted by PVM interrupt. */ + case GH_VCPU_STATE_READY: + if (need_resched()) { + schedule(); + gh_hcall_wdog_manage(vm->wdog_cap_id, + WATCHDOG_MANAGE_OP_UNFREEZE); + } + break; + + /* VCPU in WFI or suspended/powered down. */ + case GH_VCPU_STATE_EXPECTS_WAKEUP: + case GH_VCPU_STATE_POWERED_OFF: + __pm_relax(vcpu->ws); + gh_vcpu_sleep(vcpu); + break; + + /* VCPU is blocked in EL2 for an unspecified reason */ + case GH_VCPU_STATE_BLOCKED: + schedule(); + break; + + /* Unknown VCPU state. */ + default: + pr_err("Unknown VCPU STATE: state=%d VCPU=%u of VM=%d state_data_0=0x%llx state_data_1=0x%llx state_data_2=0x%llx\n", + resp->vcpu_state, vcpu_id, vcpu->vm->id, + resp->state_data_0, resp->state_data_1, resp->state_data_2); + schedule(); + break; + } + } else if (ret == GH_ERROR_RETRY) { + schedule(); + } + + if (signal_pending(current)) { + gh_hcall_wdog_manage(vm->wdog_cap_id, + WATCHDOG_MANAGE_OP_FREEZE); + ret = -ERESTARTSYS; + break; + } + } while ((ret == GH_ERROR_OK || ret == GH_ERROR_RETRY) && vm->is_active); + + if (ret != -ERESTARTSYS) + ret = gh_remap_error(ret); + + return ret; +} + +static int gh_proxy_sched_reg_rm_cbs(void) +{ + int ret = -EINVAL; + + ret = gh_rm_set_wdog_manage_cb(&gh_wdog_manage); + if (ret) { + pr_err("fail to set the WDOG resource callback\n"); + return ret; + } + + ret = gh_rm_set_vcpu_affinity_cb(&gh_populate_vm_vcpu_info); + if (ret) { + pr_err("fail to set the VM VCPU populate callback\n"); + return ret; + } + + ret = gh_rm_reset_vcpu_affinity_cb(&gh_unpopulate_vm_vcpu_info); + if (ret) { + pr_err("fail to set the VM VCPU unpopulate callback\n"); + return ret; + } + + ret = gh_rm_set_vpm_grp_cb(&gh_populate_vm_vpm_grp_info); + if (ret) { + pr_err("fail to set the VM VPM GRP populate callback\n"); + return ret; + } + + ret = gh_rm_reset_vpm_grp_cb(&gh_unpopulate_vm_vpm_grp_info); + if (ret) { + pr_err("fail to set the VM VPM GRP unpopulate callback\n"); + return ret; + } + + ret = gh_rm_all_res_populated_cb(&gh_populate_all_res_info); + if (ret) { + pr_err("fail to set the all res populate callback\n"); + return ret; + } + + return 0; +} + +int gh_proxy_sched_init(void) +{ + int ret; + + gh_vms = kcalloc(GH_MAX_VMS, sizeof(struct gh_proxy_vm), GFP_KERNEL); + if (!gh_vms) { + ret = -ENOMEM; + goto err; + } + + ret = gh_proxy_sched_reg_rm_cbs(); + if (ret) + goto free_gh_vms; + + gh_init_vms(); + + init_done = true; + return 0; + +free_gh_vms: + kfree(gh_vms); +err: + return ret; +} + +void gh_proxy_sched_exit(void) +{ + kfree(gh_vms); +} diff --git a/drivers/virt/gunyah/gh_proxy_sched.h b/drivers/virt/gunyah/gh_proxy_sched.h new file mode 100644 index 000000000000..d7517f1f701a --- /dev/null +++ b/drivers/virt/gunyah/gh_proxy_sched.h @@ -0,0 +1,117 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2021-2022, Qualcomm Innovation Center, Inc. All rights reserved. + */ +#ifndef __GH_PROXY_SCHED_H +#define __GH_PROXY_SCHED_H + +#include +#include + +#include +#include +#include + +#define WATCHDOG_MANAGE_OP_FREEZE 0 +#define WATCHDOG_MANAGE_OP_FREEZE_AND_RESET 1 +#define WATCHDOG_MANAGE_OP_UNFREEZE 2 + +struct gh_hcall_vcpu_run_resp { + int ret; + uint64_t vcpu_state; + uint64_t vcpu_suspend_state; + uint64_t state_data_0; + uint64_t state_data_1; + uint64_t state_data_2; +}; + +static inline int gh_hcall_wdog_manage(gh_capid_t wdog_capid, u16 operation) +{ + int ret; + struct gh_hcall_resp _resp = {0}; + + ret = _gh_hcall(0x6063, (struct gh_hcall_args){ wdog_capid, operation }, &_resp); + + return ret; +} + +static inline int gh_hcall_vcpu_run(gh_capid_t vcpu_capid, uint64_t resume_data_0, + uint64_t resume_data_1, uint64_t resume_data_2, + struct gh_hcall_vcpu_run_resp *resp) +{ + int ret; + struct gh_hcall_resp _resp = {0}; + + ret = _gh_hcall(0x6065, + (struct gh_hcall_args){ vcpu_capid, resume_data_0, + resume_data_1, resume_data_2, 0 }, &_resp); + + resp->ret = ret; + resp->vcpu_state = _resp.resp1; + resp->vcpu_suspend_state = _resp.resp2; + resp->state_data_0 = _resp.resp3; + resp->state_data_1 = _resp.resp4; + resp->state_data_2 = _resp.resp5; + + return ret; +} + +static inline int gh_hcall_vpm_group_get_state(gh_capid_t vpmg_capid, + uint64_t *vpmg_state) +{ + int ret; + struct gh_hcall_resp _resp = {0}; + + ret = _gh_hcall(0x6045, + (struct gh_hcall_args){ vpmg_capid, 0 }, + &_resp); + *vpmg_state = _resp.resp1; + + return ret; +} + +/* + * proxy scheduler APIs called by gunyah driver + */ +#if IS_ENABLED(CONFIG_GH_PROXY_SCHED) +int gh_proxy_sched_init(void); + +void gh_proxy_sched_exit(void); + +int gh_get_nr_vcpus(gh_vmid_t vmid); + +bool gh_vm_supports_proxy_sched(gh_vmid_t vmid); + +int gh_vcpu_run(gh_vmid_t vmid, unsigned int vcpu_id, uint64_t resume_data_0, + uint64_t resume_data_1, uint64_t resume_data_2, + struct gh_hcall_vcpu_run_resp *resp); + +void gh_wakeup_all_vcpus(gh_vmid_t vmid); +#else /* !CONFIG_GH_PROXY_SCHED */ +static inline int gh_proxy_sched_init(void) +{ + return -EPERM; +} + +static inline int gh_get_nr_vcpus(gh_vmid_t vmid) +{ + return 0; +} + +bool gh_vm_supports_proxy_sched(gh_vmid_t vmid) +{ + return false; +} + +static inline int gh_vcpu_run(gh_vmid_t vmid, unsigned int vcpu_id, + uint64_t resume_data_0, uint64_t resume_data_1, + uint64_t resume_data_2, struct gh_hcall_vcpu_run_resp *resp) +{ + return -EPERM; +} + +static inline void gh_wakeup_all_vcpus(gh_vmid_t vmid) { } + +static inline void gh_proxy_sched_exit(void) { } +#endif /* CONFIG_GH_PROXY_SCHED */ +#endif diff --git a/drivers/virt/gunyah/gh_proxy_sched_trace.h b/drivers/virt/gunyah/gh_proxy_sched_trace.h new file mode 100644 index 000000000000..1c36e87b5035 --- /dev/null +++ b/drivers/virt/gunyah/gh_proxy_sched_trace.h @@ -0,0 +1,86 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (c) 2021-2022, Qualcomm Innovation Center, Inc. All rights reserved. + */ + +#undef TRACE_SYSTEM +#define TRACE_SYSTEM gh_proxy_sched +#undef TRACE_INCLUDE_PATH +#define TRACE_INCLUDE_PATH . +#undef TRACE_INCLUDE_FILE +#define TRACE_INCLUDE_FILE gh_proxy_sched_trace + +#if !defined(_TRACE_GH_PROXY_SCHED_H) || defined(TRACE_HEADER_MULTI_READ) +#define _TRACE_GH_PROXY_SCHED_H + +#include + +TRACE_EVENT(gh_hcall_vcpu_run, + + TP_PROTO(int ret, u16 vm_id, u32 vcpu_idx, u64 yield_ts, + u64 vcpu_state, u64 vcpu_suspend_state), + + TP_ARGS(ret, vm_id, vcpu_idx, yield_ts, vcpu_state, vcpu_suspend_state), + + TP_STRUCT__entry( + __field(int, ret) + __field(u16, vm_id) + __field(u32, vcpu_idx) + __field(u64, yield_ts) + __field(u64, vcpu_state) + __field(u64, vcpu_suspend_state) + ), + + TP_fast_assign( + __entry->ret = ret; + __entry->vm_id = vm_id; + __entry->vcpu_idx = vcpu_idx; + __entry->yield_ts = yield_ts; + __entry->vcpu_state = vcpu_state; + __entry->vcpu_suspend_state = vcpu_suspend_state; + ), + + TP_printk("ret=%d vm=%u vcpu=%u yield_time=%llu vcpu_state=%llu vcpu_suspend_state=%llu", + ret, __entry->vm_id, __entry->vcpu_idx, __entry->yield_ts, + __entry->vcpu_state, __entry->vcpu_suspend_state) +); + +TRACE_EVENT(gh_susp_res_irq_handler, + + TP_PROTO(u64 vpmg_state), + + TP_ARGS(vpmg_state), + + TP_STRUCT__entry( + __field(u64, vpmg_state) + ), + + TP_fast_assign( + __entry->vpmg_state = vpmg_state; + ), + + TP_printk("vpmg_state=%llu", __entry->vpmg_state) +); + +TRACE_EVENT(gh_vcpu_irq_handler, + + TP_PROTO(u16 vm_id, u32 vcpu_idx), + + TP_ARGS(vm_id, vcpu_idx), + + TP_STRUCT__entry( + __field(u16, vm_id) + __field(u32, vcpu_idx) + ), + + TP_fast_assign( + __entry->vm_id = vm_id; + __entry->vcpu_idx = vcpu_idx; + ), + + TP_printk("vm=%u vcpu=%u", __entry->vm_id, __entry->vcpu_idx) +); +#endif /* _TRACE_GH_PROXY_SCHED_H */ + +/* This part must be outside protection */ +#include