@@ -15,6 +15,68 @@
#include "rsc_mgr.h"
#include "vm_mgr.h"
+static int gunyah_vm_rm_notification_status(struct gunyah_vm *ghvm, void *data)
+{
+ struct gunyah_rm_vm_status_payload *payload = data;
+
+ if (le16_to_cpu(payload->vmid) != ghvm->vmid)
+ return NOTIFY_OK;
+
+ /* All other state transitions are synchronous to a corresponding RM call */
+ if (payload->vm_status == GUNYAH_RM_VM_STATUS_RESET) {
+ down_write(&ghvm->status_lock);
+ ghvm->vm_status = payload->vm_status;
+ up_write(&ghvm->status_lock);
+ wake_up(&ghvm->vm_status_wait);
+ }
+
+ return NOTIFY_DONE;
+}
+
+static int gunyah_vm_rm_notification_exited(struct gunyah_vm *ghvm, void *data)
+{
+ struct gunyah_rm_vm_exited_payload *payload = data;
+
+ if (le16_to_cpu(payload->vmid) != ghvm->vmid)
+ return NOTIFY_OK;
+
+ down_write(&ghvm->status_lock);
+ ghvm->vm_status = GUNYAH_RM_VM_STATUS_EXITED;
+ up_write(&ghvm->status_lock);
+ wake_up(&ghvm->vm_status_wait);
+
+ return NOTIFY_DONE;
+}
+
+static int gunyah_vm_rm_notification(struct notifier_block *nb,
+ unsigned long action, void *data)
+{
+ struct gunyah_vm *ghvm = container_of(nb, struct gunyah_vm, nb);
+
+ switch (action) {
+ case GUNYAH_RM_NOTIFICATION_VM_STATUS:
+ return gunyah_vm_rm_notification_status(ghvm, data);
+ case GUNYAH_RM_NOTIFICATION_VM_EXITED:
+ return gunyah_vm_rm_notification_exited(ghvm, data);
+ default:
+ return NOTIFY_OK;
+ }
+}
+
+static void gunyah_vm_stop(struct gunyah_vm *ghvm)
+{
+ int ret;
+
+ if (ghvm->vm_status == GUNYAH_RM_VM_STATUS_RUNNING) {
+ ret = gunyah_rm_vm_stop(ghvm->rm, ghvm->vmid);
+ if (ret)
+ dev_warn(ghvm->parent, "Failed to stop VM: %d\n", ret);
+ }
+
+ wait_event(ghvm->vm_status_wait,
+ ghvm->vm_status != GUNYAH_RM_VM_STATUS_RUNNING);
+}
+
static __must_check struct gunyah_vm *gunyah_vm_alloc(struct gunyah_rm *rm)
{
struct gunyah_vm *ghvm;
@@ -24,14 +86,148 @@ static __must_check struct gunyah_vm *gunyah_vm_alloc(struct gunyah_rm *rm)
return ERR_PTR(-ENOMEM);
ghvm->parent = gunyah_rm_get(rm);
+ ghvm->vmid = GUNYAH_VMID_INVAL;
ghvm->rm = rm;
+ init_rwsem(&ghvm->status_lock);
+ init_waitqueue_head(&ghvm->vm_status_wait);
+ ghvm->vm_status = GUNYAH_RM_VM_STATUS_NO_STATE;
+
return ghvm;
}
+static int gunyah_vm_start(struct gunyah_vm *ghvm)
+{
+ int ret;
+
+ down_write(&ghvm->status_lock);
+ if (ghvm->vm_status != GUNYAH_RM_VM_STATUS_NO_STATE) {
+ up_write(&ghvm->status_lock);
+ return 0;
+ }
+
+ ghvm->nb.notifier_call = gunyah_vm_rm_notification;
+ ret = gunyah_rm_notifier_register(ghvm->rm, &ghvm->nb);
+ if (ret)
+ goto err;
+
+ ret = gunyah_rm_alloc_vmid(ghvm->rm, 0);
+ if (ret < 0) {
+ gunyah_rm_notifier_unregister(ghvm->rm, &ghvm->nb);
+ goto err;
+ }
+ ghvm->vmid = ret;
+ ghvm->vm_status = GUNYAH_RM_VM_STATUS_LOAD;
+
+ ret = gunyah_rm_vm_configure(ghvm->rm, ghvm->vmid, ghvm->auth, 0, 0, 0,
+ 0, 0);
+ if (ret) {
+ dev_warn(ghvm->parent, "Failed to configure VM: %d\n", ret);
+ goto err;
+ }
+
+ ret = gunyah_rm_vm_init(ghvm->rm, ghvm->vmid);
+ if (ret) {
+ ghvm->vm_status = GUNYAH_RM_VM_STATUS_INIT_FAILED;
+ dev_warn(ghvm->parent, "Failed to initialize VM: %d\n", ret);
+ goto err;
+ }
+ ghvm->vm_status = GUNYAH_RM_VM_STATUS_READY;
+
+ ret = gunyah_rm_vm_start(ghvm->rm, ghvm->vmid);
+ if (ret) {
+ dev_warn(ghvm->parent, "Failed to start VM: %d\n", ret);
+ goto err;
+ }
+
+ ghvm->vm_status = GUNYAH_RM_VM_STATUS_RUNNING;
+ up_write(&ghvm->status_lock);
+ return ret;
+err:
+ /* gunyah_vm_free will handle releasing resources and reclaiming memory */
+ up_write(&ghvm->status_lock);
+ return ret;
+}
+
+static int gunyah_vm_ensure_started(struct gunyah_vm *ghvm)
+{
+ int ret;
+
+ ret = down_read_interruptible(&ghvm->status_lock);
+ if (ret)
+ return ret;
+
+ /* Unlikely because VM is typically started */
+ if (unlikely(ghvm->vm_status == GUNYAH_RM_VM_STATUS_NO_STATE)) {
+ up_read(&ghvm->status_lock);
+ ret = gunyah_vm_start(ghvm);
+ if (ret)
+ return ret;
+ /** gunyah_vm_start() is guaranteed to bring status out of
+ * GUNYAH_RM_VM_STATUS_LOAD, thus infinitely recursive call is not
+ * possible
+ */
+ return gunyah_vm_ensure_started(ghvm);
+ }
+
+ /* Unlikely because VM is typically running */
+ if (unlikely(ghvm->vm_status != GUNYAH_RM_VM_STATUS_RUNNING))
+ ret = -ENODEV;
+
+ up_read(&ghvm->status_lock);
+ return ret;
+}
+
+static long gunyah_vm_ioctl(struct file *filp, unsigned int cmd,
+ unsigned long arg)
+{
+ struct gunyah_vm *ghvm = filp->private_data;
+ long r;
+
+ switch (cmd) {
+ case GUNYAH_VM_START: {
+ r = gunyah_vm_ensure_started(ghvm);
+ break;
+ }
+ default:
+ r = -ENOTTY;
+ break;
+ }
+
+ return r;
+}
+
static int gunyah_vm_release(struct inode *inode, struct file *filp)
{
struct gunyah_vm *ghvm = filp->private_data;
+ int ret;
+
+ /**
+ * We might race with a VM exit notification, but that's ok:
+ * gh_rm_vm_stop() will just return right away.
+ */
+ if (ghvm->vm_status == GUNYAH_RM_VM_STATUS_RUNNING)
+ gunyah_vm_stop(ghvm);
+
+ if (ghvm->vm_status != GUNYAH_RM_VM_STATUS_NO_STATE &&
+ ghvm->vm_status != GUNYAH_RM_VM_STATUS_LOAD &&
+ ghvm->vm_status != GUNYAH_RM_VM_STATUS_RESET) {
+ ret = gunyah_rm_vm_reset(ghvm->rm, ghvm->vmid);
+ if (ret)
+ dev_err(ghvm->parent, "Failed to reset the vm: %d\n",
+ ret);
+ wait_event(ghvm->vm_status_wait,
+ ghvm->vm_status == GUNYAH_RM_VM_STATUS_RESET);
+ }
+
+ if (ghvm->vm_status > GUNYAH_RM_VM_STATUS_NO_STATE) {
+ gunyah_rm_notifier_unregister(ghvm->rm, &ghvm->nb);
+
+ ret = gunyah_rm_dealloc_vmid(ghvm->rm, ghvm->vmid);
+ if (ret)
+ dev_warn(ghvm->parent,
+ "Failed to deallocate vmid: %d\n", ret);
+ }
gunyah_rm_put(ghvm->rm);
kfree(ghvm);
@@ -40,6 +236,8 @@ static int gunyah_vm_release(struct inode *inode, struct file *filp)
static const struct file_operations gunyah_vm_fops = {
.owner = THIS_MODULE,
+ .unlocked_ioctl = gunyah_vm_ioctl,
+ .compat_ioctl = compat_ptr_ioctl,
.release = gunyah_vm_release,
.llseek = noop_llseek,
};
@@ -7,6 +7,8 @@
#define _GUNYAH_VM_MGR_PRIV_H
#include <linux/device.h>
+#include <linux/rwsem.h>
+#include <linux/wait.h>
#include <uapi/linux/gunyah.h>
@@ -17,12 +19,29 @@ long gunyah_dev_vm_mgr_ioctl(struct gunyah_rm *rm, unsigned int cmd,
/**
* struct gunyah_vm - Main representation of a Gunyah Virtual machine
+ * @vmid: Gunyah's VMID for this virtual machine
* @rm: Pointer to the resource manager struct to make RM calls
* @parent: For logging
+ * @nb: Notifier block for RM notifications
+ * @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
+ * @auth: Authentication mechanism to be used by resource manager when
+ * launching the VM
+ *
+ * Members are grouped by hot path.
*/
struct gunyah_vm {
+ u16 vmid;
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 device *parent;
+ enum gunyah_rm_vm_auth_mechanism auth;
};
#endif
@@ -20,4 +20,9 @@
*/
#define GUNYAH_CREATE_VM _IO(GUNYAH_IOCTL_TYPE, 0x0) /* Returns a Gunyah VM fd */
+/*
+ * ioctls for gunyah-vm fds (returned by GUNYAH_CREATE_VM)
+ */
+#define GUNYAH_VM_START _IO(GUNYAH_IOCTL_TYPE, 0x3)
+
#endif