diff --git a/arch/x86/configs/biscotti_defconfig b/arch/x86/configs/biscotti_defconfig
index 8e2c1fe..dbf3c09 100644
--- a/arch/x86/configs/biscotti_defconfig
+++ b/arch/x86/configs/biscotti_defconfig
@@ -334,6 +334,7 @@
 CONFIG_VIRTIO_MMIO=y
 CONFIG_VIRTIO_MMIO_CMDLINE_DEVICES=y
 CONFIG_VIRTIO_WL=y
+CONFIG_VIRTIO_MAGMA=y
 CONFIG_STAGING=y
 CONFIG_POWERCAP=y
 CONFIG_INTEL_RAPL=y
diff --git a/drivers/virtio/Kconfig b/drivers/virtio/Kconfig
index a9c3cbe..e71de1f 100644
--- a/drivers/virtio/Kconfig
+++ b/drivers/virtio/Kconfig
@@ -91,4 +91,12 @@
 
 	 If unsure, say 'N'.
 
+config VIRTIO_MAGMA
+	bool "Virtio Magma driver"
+	depends on VIRTIO
+	---help---
+	 This driver supports proxying of a magma device from host to guest.
+
+	 If unsure, say 'N'.
+
 endif # VIRTIO_MENU
diff --git a/drivers/virtio/Makefile b/drivers/virtio/Makefile
index a74ec94..a0f07695 100644
--- a/drivers/virtio/Makefile
+++ b/drivers/virtio/Makefile
@@ -6,4 +6,5 @@
 virtio_pci-$(CONFIG_VIRTIO_PCI_LEGACY) += virtio_pci_legacy.o
 obj-$(CONFIG_VIRTIO_BALLOON) += virtio_balloon.o
 obj-$(CONFIG_VIRTIO_INPUT) += virtio_input.o
-obj-$(CONFIG_VIRTIO_WL) += virtio_wl.o virtio_magma.o
+obj-$(CONFIG_VIRTIO_WL) += virtio_wl.o
+obj-$(CONFIG_VIRTIO_MAGMA) += virtio_magma.o
diff --git a/drivers/virtio/virtio_magma.c b/drivers/virtio/virtio_magma.c
index 98ba709..cd6da57 100644
--- a/drivers/virtio/virtio_magma.c
+++ b/drivers/virtio/virtio_magma.c
@@ -2,101 +2,1295 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <linux/anon_inodes.h>
+#include <linux/cdev.h>
+#include <linux/compat.h>
+#include <linux/hashtable.h>
+#include <linux/module.h>
 #include <linux/uaccess.h>
+#include <linux/virtio.h>
 #include <linux/virtio_magma.h>
 #include <linux/vmalloc.h>
 
-#include "virtio_magma.h"
-
 #define VQ_DESCRIPTOR_SIZE PAGE_SIZE
-#define PAGE_COUNT(x) (((x) + PAGE_SIZE - 1) >> PAGE_SHIFT)
+#define CONNECTIONS_HASHTABLE_BITS 4
+#define CONNECTION_OBJECTS_HASHTABLE_BITS 12
+#define NOTIFICATION_MAX_BYTES 65536
+#define COMMAND_OK(command, request_ptr, response_ptr)                         \
+	((command)->request_size >= sizeof(*(request_ptr)) &&                  \
+	 (command)->response_size >= sizeof(*(response_ptr)))
+#define WAYLAND_DEVICE_PATH "/dev/wl0"
+#define MESSAGE_CACHE_OBJECT_SIZE 64
 
-struct virtmagma_info_private
-{
-	struct mutex vq_locks[VIRTMAGMA_QUEUE_COUNT];
-	struct virtqueue *vqs[VIRTMAGMA_QUEUE_COUNT];
-	struct work_struct in_vq_work;
+struct virtmagma_info {
+	dev_t dev_num;
+	struct device *dev;
+	struct class *class;
+	struct cdev cdev;
+
+	struct mutex vq_out_lock;
+	struct virtqueue *vq_out;
 	struct work_struct out_vq_work;
 	wait_queue_head_t out_waitq;
+
+	struct mutex instances_lock;
+	struct idr instances;
 };
 
-static int vq_return_inbuf_locked(struct virtqueue *vq, void *buffer)
+enum virtmagma_connection_object_type {
+	MAGMA_BUFFER,
+	MAGMA_SEMAPHORE,
+	MAGMA_CONTEXT
+};
+
+static const char *virtmagma_connection_object_type_string(
+	enum virtmagma_connection_object_type type)
+{
+	switch (type) {
+	case MAGMA_BUFFER:
+		return "MAGMA_BUFFER";
+	case MAGMA_SEMAPHORE:
+		return "MAGMA_SEMAPHORE";
+	case MAGMA_CONTEXT:
+		return "MAGMA_CONTEXT";
+	default:
+		return "[UNKNOWN]";
+	}
+}
+
+struct virtmagma_buffer {
+	size_t size_requested;
+	size_t size_allocated;
+	bool is_command_buffer;
+};
+
+struct virtmagma_semaphore {
+	uint8_t dummy;
+};
+
+struct virtmagma_context {
+	uint8_t dummy;
+};
+
+struct virtmagma_connection;
+struct virtmagma_connection_object {
+	struct virtmagma_connection *parent_connection;
+	enum virtmagma_connection_object_type type;
+	uint64_t host_value;
+	union {
+		struct virtmagma_buffer buffer;
+		struct virtmagma_semaphore semaphore;
+		struct virtmagma_context context;
+	};
+	struct hlist_node node;
+};
+
+struct virtmagma_connection {
+	struct virtmagma_instance *parent_instance;
+	uint64_t host_value;
+	DECLARE_HASHTABLE(objects, CONNECTION_OBJECTS_HASHTABLE_BITS);
+	struct hlist_node node;
+};
+
+struct virtmagma_instance {
+	struct virtmagma_info *vi;
+	int id;
+	DECLARE_HASHTABLE(connections, CONNECTIONS_HASHTABLE_BITS);
+	int mmfd;
+	struct {
+		struct virtmagma_buffer *buffer;
+		u64 phys_addr;
+		bool pending;
+	} mmap_params;
+	struct {
+		pid_t pid;
+		pid_t tgid;
+		char comm[TASK_COMM_LEN];
+	} creator;
+	struct kmem_cache *msg_cache;
+	void *wayland_device_private_data;
+};
+
+struct virtmagma_virtio_command {
+	void *request_ptr;
+	size_t request_size;
+	void *response_ptr;
+	size_t response_size;
+};
+
+static void virtmagma_cache_ctor(void *p)
+{
+	memset(p, 0, MESSAGE_CACHE_OBJECT_SIZE);
+}
+
+static int vq_out_send_sync(struct virtmagma_info *vi,
+			    struct virtmagma_virtio_command *command)
 {
 	int ret;
-	struct scatterlist sg[1];
+	DECLARE_COMPLETION_ONSTACK(finish_completion);
+	struct scatterlist sg_out;
+	struct scatterlist sg_in;
+	struct scatterlist *sgs[] = { &sg_out, &sg_in };
+	init_completion(&finish_completion);
+	sg_init_one(&sg_out, command->request_ptr, command->request_size);
+	sg_init_one(&sg_in, command->response_ptr, command->response_size);
 
-	sg_init_one(sg, buffer, VQ_DESCRIPTOR_SIZE);
+	mutex_lock(&vi->vq_out_lock);
+	while ((ret = virtqueue_add_sgs(vi->vq_out, sgs, 1, 1,
+					&finish_completion, GFP_KERNEL)) ==
+	       -ENOSPC) {
+		mutex_unlock(&vi->vq_out_lock);
+		if (!wait_event_timeout(vi->out_waitq, vi->vq_out->num_free > 0,
+					HZ))
+			return -EBUSY;
+		mutex_lock(&vi->vq_out_lock);
+	}
+	if (!ret)
+		virtqueue_kick(vi->vq_out);
+	mutex_unlock(&vi->vq_out_lock);
 
-	ret = virtqueue_add_inbuf(vq, sg, 1, buffer, GFP_KERNEL);
-	if (ret) {
-		pr_warn("virtmagma: failed to give inbuf to host: %d\n", ret);
+	wait_for_completion(&finish_completion);
+
+	return ret;
+}
+
+/* Verify that a virtio command's response matches its expected response.
+   Note that a match indicates only that the proxying of the magma command
+   has succeeded, not necessarily that the magma command itself did. */
+static int virtmagma_check_expected_response_type(void *request, void *response)
+{
+	struct virtio_magma_ctrl_hdr *request_hdr = request;
+	struct virtio_magma_ctrl_hdr *response_hdr = response;
+	if (virtio_magma_expected_response_type(request_hdr->type) !=
+	    response_hdr->type) {
+		pr_warn("virtmagma: unexpected virtio response %s (%d) to request %s (%d)",
+			virtio_magma_ctrl_type_string(response_hdr->type),
+			response_hdr->type,
+			virtio_magma_ctrl_type_string(request_hdr->type),
+			request_hdr->type);
+		return -EIO;
+	}
+	return 0;
+}
+
+static struct virtmagma_connection *
+	get_connection(struct virtmagma_instance *instance, uint64_t id)
+{
+	struct virtmagma_connection *connection = NULL;
+	hash_for_each_possible (instance->connections, connection, node, id) {
+		if (connection->host_value == id)
+			break;
+	}
+	if (!connection) {
+		pr_warn("virtmagma: invalid connection id %lld", id);
+	}
+	return connection;
+}
+
+static struct virtmagma_connection_object *
+	get_connection_object(struct virtmagma_connection *connection,
+			      uint64_t id,
+			      enum virtmagma_connection_object_type type)
+{
+	struct virtmagma_connection_object *object = NULL;
+	hash_for_each_possible (connection->objects, object, node, id) {
+		if (object->type == type && object->host_value == id)
+			break;
+	}
+	if (!object) {
+		pr_warn("virtmagma: invalid %s object id %lld",
+			virtmagma_connection_object_type_string(type), id);
+	}
+	return object;
+}
+
+static int control_type(void *p)
+{
+	return ((struct virtio_magma_ctrl_hdr *)p)->type;
+}
+
+static int release_buffer(struct virtmagma_buffer *buffer)
+{
+	int ret;
+	struct virtio_magma_release_buffer_ctrl *request;
+	struct virtio_magma_release_buffer_resp *response;
+	struct virtmagma_virtio_command command;
+	struct virtmagma_connection_object *object = container_of(
+		buffer, struct virtmagma_connection_object, buffer);
+	BUILD_BUG_ON(sizeof(*request) > MESSAGE_CACHE_OBJECT_SIZE);
+	BUILD_BUG_ON(sizeof(*response) > MESSAGE_CACHE_OBJECT_SIZE);
+
+	request = kmem_cache_alloc(
+		object->parent_connection->parent_instance->msg_cache,
+		GFP_KERNEL);
+	if (!request)
+		return -ENOMEM;
+
+	response = kmem_cache_alloc(
+		object->parent_connection->parent_instance->msg_cache,
+		GFP_KERNEL);
+	if (!response) {
+		ret = -ENOMEM;
+		goto free_request;
+	}
+
+	request->hdr.type = VIRTIO_MAGMA_CMD_RELEASE_BUFFER;
+	request->connection = object->parent_connection->host_value;
+	request->buffer = object->host_value;
+
+	command.request_ptr = request;
+	command.request_size = sizeof(*request);
+	command.response_ptr = response;
+	command.response_size = sizeof(*response);
+
+	ret = vq_out_send_sync(object->parent_connection->parent_instance->vi,
+			       &command);
+	if (ret)
+		goto free_response;
+
+	if (response->hdr.type != VIRTIO_MAGMA_RESP_RELEASE_BUFFER)
+		ret = -EIO;
+
+free_response:
+	kmem_cache_free(object->parent_connection->parent_instance->msg_cache,
+			response);
+
+free_request:
+	kmem_cache_free(object->parent_connection->parent_instance->msg_cache,
+			request);
+
+	return ret;
+}
+
+static int release_command_buffer(struct virtmagma_buffer *buffer)
+{
+	int ret;
+	struct virtio_magma_release_command_buffer_ctrl *request;
+	struct virtio_magma_release_command_buffer_resp *response;
+	struct virtmagma_virtio_command command;
+	struct virtmagma_connection_object *object = container_of(
+		buffer, struct virtmagma_connection_object, buffer);
+	BUILD_BUG_ON(sizeof(*request) > MESSAGE_CACHE_OBJECT_SIZE);
+	BUILD_BUG_ON(sizeof(*response) > MESSAGE_CACHE_OBJECT_SIZE);
+
+	request = kmem_cache_alloc(
+		object->parent_connection->parent_instance->msg_cache,
+		GFP_KERNEL);
+	if (!request)
+		return -ENOMEM;
+
+	response = kmem_cache_alloc(
+		object->parent_connection->parent_instance->msg_cache,
+		GFP_KERNEL);
+	if (!response) {
+		ret = -ENOMEM;
+		goto free_request;
+	}
+
+	request->hdr.type = VIRTIO_MAGMA_CMD_RELEASE_COMMAND_BUFFER;
+	request->connection = object->parent_connection->host_value;
+	request->command_buffer = object->host_value;
+
+	command.request_ptr = request;
+	command.request_size = sizeof(*request);
+	command.response_ptr = response;
+	command.response_size = sizeof(*response);
+
+	ret = vq_out_send_sync(object->parent_connection->parent_instance->vi,
+			       &command);
+	if (ret)
+		goto free_response;
+
+	if (response->hdr.type != VIRTIO_MAGMA_RESP_RELEASE_COMMAND_BUFFER)
+		ret = -EIO;
+
+free_response:
+	kmem_cache_free(object->parent_connection->parent_instance->msg_cache,
+			response);
+
+free_request:
+	kmem_cache_free(object->parent_connection->parent_instance->msg_cache,
+			request);
+
+	return ret;
+}
+
+static int release_semaphore(struct virtmagma_semaphore *semaphore)
+{
+	int ret;
+	struct virtio_magma_release_semaphore_ctrl *request;
+	struct virtio_magma_release_semaphore_resp *response;
+	struct virtmagma_virtio_command command;
+	struct virtmagma_connection_object *object = container_of(
+		semaphore, struct virtmagma_connection_object, semaphore);
+	BUILD_BUG_ON(sizeof(*request) > MESSAGE_CACHE_OBJECT_SIZE);
+	BUILD_BUG_ON(sizeof(*response) > MESSAGE_CACHE_OBJECT_SIZE);
+
+	request = kmem_cache_alloc(
+		object->parent_connection->parent_instance->msg_cache,
+		GFP_KERNEL);
+	if (!request)
+		return -ENOMEM;
+
+	response = kmem_cache_alloc(
+		object->parent_connection->parent_instance->msg_cache,
+		GFP_KERNEL);
+	if (!response) {
+		ret = -ENOMEM;
+		goto free_request;
+	}
+
+	request->hdr.type = VIRTIO_MAGMA_CMD_RELEASE_SEMAPHORE;
+	request->connection = object->parent_connection->host_value;
+	request->semaphore = object->host_value;
+
+	command.request_ptr = request;
+	command.request_size = sizeof(*request);
+	command.response_ptr = response;
+	command.response_size = sizeof(*response);
+
+	ret = vq_out_send_sync(object->parent_connection->parent_instance->vi,
+			       &command);
+	if (ret)
+		goto free_response;
+
+	if (response->hdr.type != VIRTIO_MAGMA_RESP_RELEASE_SEMAPHORE)
+		ret = -EIO;
+
+free_response:
+	kmem_cache_free(object->parent_connection->parent_instance->msg_cache,
+			response);
+
+free_request:
+	kmem_cache_free(object->parent_connection->parent_instance->msg_cache,
+			request);
+
+	return ret;
+}
+
+static int release_context(struct virtmagma_context *context)
+{
+	int ret;
+	struct virtio_magma_release_context_ctrl *request;
+	struct virtio_magma_release_context_resp *response;
+	struct virtmagma_virtio_command command;
+	struct virtmagma_connection_object *object = container_of(
+		context, struct virtmagma_connection_object, context);
+	BUILD_BUG_ON(sizeof(*request) > MESSAGE_CACHE_OBJECT_SIZE);
+	BUILD_BUG_ON(sizeof(*response) > MESSAGE_CACHE_OBJECT_SIZE);
+
+	request = kmem_cache_alloc(
+		object->parent_connection->parent_instance->msg_cache,
+		GFP_KERNEL);
+	if (!request)
+		return -ENOMEM;
+
+	response = kmem_cache_alloc(
+		object->parent_connection->parent_instance->msg_cache,
+		GFP_KERNEL);
+	if (!response) {
+		ret = -ENOMEM;
+		goto free_request;
+	}
+
+	request->hdr.type = VIRTIO_MAGMA_CMD_RELEASE_CONTEXT;
+	request->connection = object->parent_connection->host_value;
+	request->context_id = object->host_value;
+
+	command.request_ptr = request;
+	command.request_size = sizeof(*request);
+	command.response_ptr = response;
+	command.response_size = sizeof(*response);
+
+	ret = vq_out_send_sync(object->parent_connection->parent_instance->vi,
+			       &command);
+	if (ret)
+		goto free_response;
+
+	if (response->hdr.type != VIRTIO_MAGMA_RESP_RELEASE_CONTEXT)
+		ret = -EIO;
+
+free_response:
+	kmem_cache_free(object->parent_connection->parent_instance->msg_cache,
+			response);
+
+free_request:
+	kmem_cache_free(object->parent_connection->parent_instance->msg_cache,
+			request);
+
+	return ret;
+}
+
+static int release_connection(struct virtmagma_connection *connection)
+{
+	int ret;
+	int bkt;
+	struct virtmagma_connection_object *object;
+	struct virtio_magma_release_connection_ctrl *request;
+	struct virtio_magma_release_connection_resp *response;
+	struct virtmagma_virtio_command command;
+	uint64_t leaked_buffers = 0;
+	uint64_t leaked_command_buffers = 0;
+	uint64_t leaked_semaphores = 0;
+	uint64_t leaked_contexts = 0;
+
+	/* first, release any child objects */
+
+	hash_for_each (connection->objects, bkt, object, node) {
+		switch (object->type) {
+		case MAGMA_BUFFER:
+			if (object->buffer.is_command_buffer) {
+				release_command_buffer(&object->buffer);
+				++leaked_command_buffers;
+			} else {
+				release_buffer(&object->buffer);
+				++leaked_buffers;
+			}
+			break;
+		case MAGMA_CONTEXT:
+			release_context(&object->context);
+			++leaked_contexts;
+			break;
+		case MAGMA_SEMAPHORE:
+			release_semaphore(&object->semaphore);
+			++leaked_semaphores;
+			break;
+		default:
+			pr_err("virtmagma: unknown connection object (%d)",
+			       object->type);
+			break;
+		}
+	}
+	if (leaked_buffers || leaked_command_buffers || leaked_semaphores ||
+	    leaked_contexts) {
+		pr_info("virtmagma: connection %lld from command %s closed with leaked objects:\n",
+			connection->host_value,
+			connection->parent_instance->creator.comm);
+		pr_cont("virtmagma: buffers: %lld\n", leaked_buffers);
+		pr_cont("virtmagma: command buffers: %lld\n",
+			leaked_command_buffers);
+		pr_cont("virtmagma: semaphores: %lld\n", leaked_semaphores);
+		pr_cont("virtmagma: contexts: %lld\n", leaked_contexts);
+	}
+
+	/* now release the connection */
+
+	BUILD_BUG_ON(sizeof(*request) > MESSAGE_CACHE_OBJECT_SIZE);
+	BUILD_BUG_ON(sizeof(*response) > MESSAGE_CACHE_OBJECT_SIZE);
+
+	request = kmem_cache_alloc(connection->parent_instance->msg_cache,
+				   GFP_KERNEL);
+	if (!request)
+		return -ENOMEM;
+
+	response = kmem_cache_alloc(connection->parent_instance->msg_cache,
+				    GFP_KERNEL);
+	if (!response) {
+		ret = -ENOMEM;
+		goto free_request;
+	}
+
+	request->hdr.type = VIRTIO_MAGMA_CMD_RELEASE_CONNECTION;
+	request->connection = connection->host_value;
+
+	command.request_ptr = request;
+	command.request_size = sizeof(*request);
+	command.response_ptr = response;
+	command.response_size = sizeof(*response);
+
+	ret = vq_out_send_sync(connection->parent_instance->vi, &command);
+	if (ret)
+		goto free_response;
+
+	if (response->hdr.type != VIRTIO_MAGMA_RESP_RELEASE_CONNECTION)
+		ret = -EIO;
+
+free_response:
+	kmem_cache_free(connection->parent_instance->msg_cache, response);
+
+free_request:
+	kmem_cache_free(connection->parent_instance->msg_cache, request);
+
+	return ret;
+}
+
+static int destroy_connection(struct virtmagma_connection *connection)
+{
+	int bkt;
+	struct virtmagma_connection_object *object;
+	hash_for_each (connection->objects, bkt, object, node) {
+		hash_del(&object->node);
+		kfree(object);
+	}
+	hash_del(&connection->node);
+	kfree(connection);
+	return 0;
+}
+
+static int destroy_instance(int id, void *p, void *data)
+{
+	struct virtmagma_instance *instance = p;
+	struct virtmagma_connection *connection;
+	int bkt;
+	uint64_t leaked_connections = 0;
+
+	instance = p;
+
+	hash_for_each (instance->connections, bkt, connection, node) {
+		++leaked_connections;
+	}
+	if (leaked_connections) {
+		pr_info("virtmagma: command %s exited with %lld leaked connections",
+			instance->creator.comm, leaked_connections);
+	}
+	hash_for_each (instance->connections, bkt, connection, node) {
+		release_connection(connection);
+		destroy_connection(connection);
+	}
+
+	kmem_cache_destroy(instance->msg_cache);
+
+	kfree(instance);
+	return 0;
+}
+
+static int virtmagma_mmfd_mmap(struct file *filp, struct vm_area_struct *vma)
+{
+	struct virtmagma_instance *instance = filp->private_data;
+	unsigned long vm_size = vma->vm_end - vma->vm_start;
+	size_t max_map_size;
+	int ret;
+
+	if (!instance)
+		return -ENODEV;
+
+	if (!instance->mmap_params.pending) {
+		pr_warn("virtmagma: user called mmap on the mmfd without first submitting a magma_map ioctl");
+		return -EINVAL;
+	}
+
+	instance->mmap_params.pending = false;
+
+	if (instance->mmap_params.buffer->is_command_buffer)
+		max_map_size = instance->mmap_params.buffer->size_requested;
+	else
+		max_map_size = instance->mmap_params.buffer->size_allocated;
+	max_map_size = PAGE_ALIGN(max_map_size);
+
+	if (vm_size > max_map_size) {
+		pr_warn("virtmagma: user tried to mmap with a size (%ld) larger than the buffer's size (%ld)",
+			vm_size, max_map_size);
+		return -EINVAL;
+	}
+
+	ret = io_remap_pfn_range(vma, vma->vm_start,
+				 instance->mmap_params.phys_addr / PAGE_SIZE,
+				 vm_size, vma->vm_page_prot);
+
+	if (ret)
+		return ret;
+
+	vma->vm_flags |= VM_PFNMAP | VM_IO | VM_DONTEXPAND | VM_DONTDUMP;
+
+	return ret;
+}
+
+static const struct file_operations virtmagma_mmfd_fops = {
+	.mmap = virtmagma_mmfd_mmap,
+};
+
+static int create_instance(struct virtmagma_info *vi,
+			   struct virtmagma_instance **instance_out)
+{
+	int ret;
+	struct file *filp;
+	struct virtmagma_instance *instance;
+
+	*instance_out = NULL;
+
+	instance = kzalloc(sizeof(*instance), GFP_KERNEL);
+	if (!instance)
+		return -ENOMEM;
+	instance->vi = vi;
+
+	mutex_lock(&vi->instances_lock);
+	ret = idr_alloc(&vi->instances, instance, 1, -1, GFP_KERNEL);
+	mutex_unlock(&vi->instances_lock);
+	if (ret <= 0) {
+		ret = -ENOMEM;
+		goto free_instance;
+	}
+	instance->id = ret;
+
+	ret = anon_inode_getfd("[virtmagma_mmfd]", &virtmagma_mmfd_fops,
+			       instance, O_RDWR);
+	if (ret < 0) {
+		goto free_instance;
+	}
+	instance->mmfd = ret;
+
+	hash_init(instance->connections);
+	instance->creator.pid = current->pid;
+	instance->creator.tgid = current->tgid;
+	memcpy(instance->creator.comm, current->comm,
+	       sizeof(instance->creator.comm));
+	instance->creator.comm[sizeof(instance->creator.comm) - 1] = 0;
+
+	filp = filp_open(WAYLAND_DEVICE_PATH, O_RDWR, 0);
+	if (filp) {
+		instance->wayland_device_private_data = filp->private_data;
+	} else {
+		pr_warn("virtmagma: failed to open wayland device at %s\n",
+			WAYLAND_DEVICE_PATH);
+		pr_cont("virtmagma: magma_export will not be available\n");
+	}
+	filp_close(filp, 0);
+
+	instance->msg_cache =
+		kmem_cache_create("virtmagma_cache", MESSAGE_CACHE_OBJECT_SIZE,
+				  MESSAGE_CACHE_OBJECT_SIZE, 0,
+				  virtmagma_cache_ctor);
+	if (!instance->msg_cache) {
+		pr_err("virtmagma: failed to create message cache");
+		return -ENOMEM;
+	}
+
+	*instance_out = instance;
+
+	return 0;
+
+free_instance:
+	kfree(instance);
+
+	return ret;
+}
+
+static int virtmagma_command_magma_create_connection(
+	struct virtmagma_instance *instance,
+	struct virtmagma_virtio_command *command)
+{
+	int ret;
+	struct virtmagma_connection *connection;
+	struct virtio_magma_create_connection_ctrl *request =
+		command->request_ptr;
+	struct virtio_magma_create_connection_resp *response =
+		command->response_ptr;
+
+	if (!COMMAND_OK(command, request, response))
+		return -EINVAL;
+
+	ret = vq_out_send_sync(instance->vi, command);
+	if (ret)
+		return ret;
+
+	ret = virtmagma_check_expected_response_type(request, response);
+	if (ret)
+		return ret;
+
+	/* pass on magma errors without creating a connection object */
+	if (response->result_return) {
+		pr_warn("virtmagma: magma_create_connection returned %d",
+			(int32_t)response->result_return);
+		return 0; /* the ioctl is still successful */
+	}
+
+	connection = kzalloc(sizeof(*connection), GFP_KERNEL);
+	if (!connection)
+		return -ENOMEM;
+
+	connection->parent_instance = instance;
+	connection->host_value = response->connection_out;
+	hash_init(connection->objects);
+
+	hash_add(instance->connections, &connection->node,
+		 connection->host_value);
+
+	return 0;
+}
+
+static int virtmagma_command_magma_release_connection(
+	struct virtmagma_instance *instance,
+	struct virtmagma_virtio_command *command)
+{
+	int ret;
+	struct virtmagma_connection *connection = NULL;
+	struct virtio_magma_release_connection_ctrl *request =
+		command->request_ptr;
+	struct virtio_magma_release_connection_resp *response =
+		command->response_ptr;
+
+	if (!COMMAND_OK(command, request, response))
+		return -EINVAL;
+
+	connection = get_connection(instance, request->connection);
+	if (!connection)
+		return -EINVAL;
+
+	ret = release_connection(connection);
+	if (ret)
+		return ret;
+
+	return destroy_connection(connection);
+}
+
+static int virtmagma_command_magma_create_context(
+	struct virtmagma_instance *instance,
+	struct virtmagma_virtio_command *command)
+{
+	int ret;
+	struct virtmagma_connection *connection;
+	struct virtmagma_connection_object *object;
+	struct virtio_magma_create_context_ctrl *request = command->request_ptr;
+	struct virtio_magma_create_context_resp *response =
+		command->response_ptr;
+
+	if (!COMMAND_OK(command, request, response))
+		return -EINVAL;
+
+	connection = get_connection(instance, request->connection);
+	if (!connection)
+		return -EINVAL;
+
+	ret = vq_out_send_sync(instance->vi, command);
+	if (ret)
+		return ret;
+
+	ret = virtmagma_check_expected_response_type(request, response);
+	if (ret)
+		return ret;
+
+	/* magma_create_context does not return errors */
+
+	object = kzalloc(sizeof(*object), GFP_KERNEL);
+	if (!object)
+		return -ENOMEM;
+
+	object->parent_connection = connection;
+	object->host_value = response->context_id_out;
+	object->type = MAGMA_CONTEXT;
+
+	hash_add(connection->objects, &object->node, object->host_value);
+
+	return 0;
+}
+
+static int virtmagma_command_magma_release_context(
+	struct virtmagma_instance *instance,
+	struct virtmagma_virtio_command *command)
+{
+	int ret;
+	struct virtmagma_connection *connection = NULL;
+	struct virtmagma_connection_object *object = NULL;
+	struct virtio_magma_release_context_ctrl *request =
+		command->request_ptr;
+	struct virtio_magma_release_context_resp *response =
+		command->response_ptr;
+
+	if (!COMMAND_OK(command, request, response))
+		return -EINVAL;
+
+	connection = get_connection(instance, request->connection);
+	if (!connection)
+		return -EINVAL;
+
+	object = get_connection_object(connection, request->context_id,
+				       MAGMA_CONTEXT);
+	if (!object)
+		return -EINVAL;
+
+	ret = vq_out_send_sync(instance->vi, command);
+	if (ret)
+		return ret;
+
+	ret = virtmagma_check_expected_response_type(request, response);
+	if (ret)
+		return ret;
+
+	hash_del(&object->node);
+	kfree(object);
+
+	return 0;
+}
+
+static int virtmagma_command_magma_create_buffer(
+	struct virtmagma_instance *instance,
+	struct virtmagma_virtio_command *command)
+{
+	int ret;
+	struct virtmagma_connection *connection;
+	struct virtmagma_connection_object *object;
+	struct virtio_magma_create_buffer_ctrl *request = command->request_ptr;
+	struct virtio_magma_create_buffer_resp *response =
+		command->response_ptr;
+
+	if (!COMMAND_OK(command, request, response))
+		return -EINVAL;
+
+	connection = get_connection(instance, request->connection);
+	if (!connection)
+		return -EINVAL;
+
+	ret = vq_out_send_sync(instance->vi, command);
+	if (ret)
+		return ret;
+
+	ret = virtmagma_check_expected_response_type(request, response);
+	if (ret)
+		return ret;
+
+	/* pass on magma errors without creating a buffer object */
+	if (response->result_return) {
+		pr_warn("virtmagma: magma_create_buffer returned %d",
+			(int32_t)response->result_return);
+		return 0; /* the ioctl is still successful */
+	}
+
+	object = kzalloc(sizeof(*object), GFP_KERNEL);
+	if (!object)
+		return -ENOMEM;
+
+	object->parent_connection = connection;
+	object->host_value = response->buffer_out;
+	object->type = MAGMA_BUFFER;
+	object->buffer.size_requested = request->size;
+	object->buffer.size_allocated = response->size_out;
+	object->buffer.is_command_buffer = false;
+
+	hash_add(connection->objects, &object->node, object->host_value);
+
+	return 0;
+}
+
+static int virtmagma_command_magma_release_buffer(
+	struct virtmagma_instance *instance,
+	struct virtmagma_virtio_command *command)
+{
+	int ret;
+	struct virtmagma_connection *connection = NULL;
+	struct virtmagma_connection_object *object = NULL;
+	struct virtio_magma_release_buffer_ctrl *request = command->request_ptr;
+	struct virtio_magma_release_buffer_resp *response =
+		command->response_ptr;
+
+	if (!COMMAND_OK(command, request, response))
+		return -EINVAL;
+
+	connection = get_connection(instance, request->connection);
+	if (!connection)
+		return -EINVAL;
+
+	object = get_connection_object(connection, request->buffer,
+				       MAGMA_BUFFER);
+	if (!object)
+		return -EINVAL;
+
+	ret = vq_out_send_sync(instance->vi, command);
+	if (ret)
+		return ret;
+
+	ret = virtmagma_check_expected_response_type(request, response);
+	if (ret)
+		return ret;
+
+	hash_del(&object->node);
+	kfree(object);
+
+	return 0;
+}
+
+static int virtmagma_command_magma_create_command_buffer(
+	struct virtmagma_instance *instance,
+	struct virtmagma_virtio_command *command)
+{
+	int ret;
+	struct virtmagma_connection *connection;
+	struct virtmagma_connection_object *object;
+	struct virtio_magma_create_command_buffer_ctrl *request =
+		command->request_ptr;
+	struct virtio_magma_create_command_buffer_resp *response =
+		command->response_ptr;
+
+	if (!COMMAND_OK(command, request, response))
+		return -EINVAL;
+
+	connection = get_connection(instance, request->connection);
+	if (!connection)
+		return -EINVAL;
+
+	ret = vq_out_send_sync(instance->vi, command);
+	if (ret)
+		return ret;
+
+	ret = virtmagma_check_expected_response_type(request, response);
+	if (ret)
+		return ret;
+
+	/* pass on magma errors without creating a command_buffer object */
+	if (response->result_return) {
+		pr_warn("virtmagma: magma_create_command_buffer returned %d",
+			(int32_t)response->result_return);
+		return 0; /* the ioctl is still successful */
+	}
+
+	object = kzalloc(sizeof(*object), GFP_KERNEL);
+	if (!object)
+		return -ENOMEM;
+
+	object->parent_connection = connection;
+	object->host_value = response->buffer_out;
+	object->type = MAGMA_BUFFER;
+	object->buffer.size_requested = request->size;
+	object->buffer.is_command_buffer = true;
+
+	hash_add(connection->objects, &object->node, object->host_value);
+
+	return 0;
+}
+
+static int virtmagma_command_magma_release_command_buffer(
+	struct virtmagma_instance *instance,
+	struct virtmagma_virtio_command *command)
+{
+	int ret;
+	struct virtmagma_connection *connection = NULL;
+	struct virtmagma_connection_object *object = NULL;
+	struct virtio_magma_release_command_buffer_ctrl *request =
+		command->request_ptr;
+	struct virtio_magma_release_command_buffer_resp *response =
+		command->response_ptr;
+
+	if (!COMMAND_OK(command, request, response))
+		return -EINVAL;
+
+	connection = get_connection(instance, request->connection);
+	if (!connection)
+		return -EINVAL;
+
+	object = get_connection_object(connection, request->command_buffer,
+				       MAGMA_BUFFER);
+	if (!object)
+		return -EINVAL;
+
+	ret = vq_out_send_sync(instance->vi, command);
+	if (ret)
+		return ret;
+
+	ret = virtmagma_check_expected_response_type(request, response);
+	if (ret)
+		return ret;
+
+	hash_del(&object->node);
+	kfree(object);
+
+	return 0;
+}
+
+static int virtmagma_command_magma_submit_command_buffer(
+	struct virtmagma_instance *instance,
+	struct virtmagma_virtio_command *command)
+{
+	int ret;
+	struct virtmagma_connection *connection = NULL;
+	struct virtmagma_connection_object *object = NULL;
+	struct virtio_magma_submit_command_buffer_ctrl *request =
+		command->request_ptr;
+	struct virtio_magma_submit_command_buffer_resp *response =
+		command->response_ptr;
+
+	if (!COMMAND_OK(command, request, response))
+		return -EINVAL;
+
+	connection = get_connection(instance, request->connection);
+	if (!connection)
+		return -EINVAL;
+
+	object = get_connection_object(connection, request->command_buffer,
+				       MAGMA_BUFFER);
+	if (!object)
+		return -EINVAL;
+
+	ret = vq_out_send_sync(instance->vi, command);
+	if (ret)
+		return ret;
+
+	ret = virtmagma_check_expected_response_type(request, response);
+	if (ret)
+		return ret;
+
+	/* command buffers are implicitly freed on submit */
+
+	hash_del(&object->node);
+	kfree(object);
+
+	return 0;
+}
+
+static int virtmagma_command_magma_create_semaphore(
+	struct virtmagma_instance *instance,
+	struct virtmagma_virtio_command *command)
+{
+	int ret;
+	struct virtmagma_connection *connection;
+	struct virtmagma_connection_object *object;
+	struct virtio_magma_create_semaphore_ctrl *request =
+		command->request_ptr;
+	struct virtio_magma_create_semaphore_resp *response =
+		command->response_ptr;
+
+	if (!COMMAND_OK(command, request, response))
+		return -EINVAL;
+
+	connection = get_connection(instance, request->connection);
+	if (!connection)
+		return -EINVAL;
+
+	ret = vq_out_send_sync(instance->vi, command);
+	if (ret)
+		return ret;
+
+	ret = virtmagma_check_expected_response_type(request, response);
+	if (ret)
+		return ret;
+
+	/* pass on magma errors without creating a semaphore object */
+	if (response->result_return) {
+		pr_warn("virtmagma: magma_create_semaphore returned %d",
+			(int32_t)response->result_return);
+		return 0; /* the ioctl is still successful */
+	}
+
+	object = kzalloc(sizeof(*object), GFP_KERNEL);
+	if (!object)
+		return -ENOMEM;
+
+	object->parent_connection = connection;
+	object->host_value = response->semaphore_out;
+	object->type = MAGMA_SEMAPHORE;
+
+	hash_add(connection->objects, &object->node, object->host_value);
+
+	return 0;
+}
+
+static int virtmagma_command_magma_release_semaphore(
+	struct virtmagma_instance *instance,
+	struct virtmagma_virtio_command *command)
+{
+	int ret;
+	struct virtmagma_connection *connection = NULL;
+	struct virtmagma_connection_object *object = NULL;
+	struct virtio_magma_release_semaphore_ctrl *request =
+		command->request_ptr;
+	struct virtio_magma_release_semaphore_resp *response =
+		command->response_ptr;
+
+	if (!COMMAND_OK(command, request, response))
+		return -EINVAL;
+
+	connection = get_connection(instance, request->connection);
+	if (!connection)
+		return -EINVAL;
+
+	object = get_connection_object(connection, request->semaphore,
+				       MAGMA_SEMAPHORE);
+	if (!object)
+		return -EINVAL;
+
+	ret = vq_out_send_sync(instance->vi, command);
+	if (ret)
+		return ret;
+
+	ret = virtmagma_check_expected_response_type(request, response);
+	if (ret)
+		return ret;
+
+	hash_del(&object->node);
+	kfree(object);
+
+	return 0;
+}
+
+static int virtmagma_command_magma_map(struct virtmagma_instance *instance,
+				       struct virtmagma_virtio_command *command)
+{
+	int ret;
+	struct virtmagma_connection *connection;
+	struct virtmagma_connection_object *object;
+	struct virtio_magma_map_ctrl *request = command->request_ptr;
+	/* this ioctl has a size_t output parameter appended */
+	struct {
+		struct virtio_magma_map_resp virtio_response;
+		size_t size_to_mmap_out;
+	} *response = command->response_ptr;
+
+	if (!COMMAND_OK(command, request, response))
+		return -EINVAL;
+
+	connection = get_connection(instance, request->connection);
+	if (!connection)
+		return -EINVAL;
+
+	object = get_connection_object(connection, request->buffer,
+				       MAGMA_BUFFER);
+	if (!object)
+		return -EINVAL;
+
+	ret = vq_out_send_sync(instance->vi, command);
+	if (ret)
+		return ret;
+
+	ret = virtmagma_check_expected_response_type(request, response);
+	if (ret)
+		return ret;
+
+	/* store parameters for subsequent mmap call */
+
+	instance->mmap_params.buffer = &object->buffer;
+	instance->mmap_params.phys_addr = response->virtio_response.addr_out;
+	instance->mmap_params.pending = true;
+
+	/* user must use the returned size in its subsequent mmap call */
+
+	response->size_to_mmap_out = object->buffer.size_requested;
+
+	return 0;
+}
+
+static int virtmagma_command_magma_wait_semaphores(
+	struct virtmagma_instance *instance,
+	struct virtmagma_virtio_command *command)
+{
+	int ret;
+	size_t semaphores_size;
+	struct virtio_magma_wait_semaphores_ctrl *request =
+		command->request_ptr;
+	struct virtio_magma_wait_semaphores_resp *response =
+		command->response_ptr;
+
+	if (!COMMAND_OK(command, request, response))
+		return -EINVAL;
+
+	/* reallocate request buffer with enough space for the semaphores */
+	semaphores_size = request->count * sizeof(uint64_t);
+	command->request_size = sizeof(*request) + semaphores_size;
+	command->request_ptr = kzalloc(command->request_size, GFP_KERNEL);
+	if (!command->request_ptr)
+		return -ENOMEM;
+
+	memcpy(command->request_ptr, request, sizeof(*request));
+	ret = copy_from_user((char *)command->request_ptr + sizeof(*request),
+			     (void *)request->semaphores, semaphores_size);
+	if (ret)
+		return ret;
+
+	ret = vq_out_send_sync(instance->vi, command);
+	if (ret)
+		return ret;
+
+	return virtmagma_check_expected_response_type(request, response);
+}
+
+static int virtmagma_command_magma_read_notification_channel(
+	struct virtmagma_instance *instance,
+	struct virtmagma_virtio_command *command)
+{
+	int ret;
+	struct virtio_magma_read_notification_channel_ctrl *request =
+		command->request_ptr;
+	struct virtio_magma_read_notification_channel_resp *response =
+		command->response_ptr;
+
+	if (!COMMAND_OK(command, request, response))
+		return -EINVAL;
+
+	/* reallocate response buffer with additional space for notification data.
+	   note that the size is not modified, as we only want the response struct
+	   itself to be copied back to the user by our caller */
+
+	command->response_ptr = response =
+		kzalloc(sizeof(*response) + NOTIFICATION_MAX_BYTES, GFP_KERNEL);
+	if (!command->response_ptr)
+		return -ENOMEM;
+
+	ret = vq_out_send_sync(instance->vi, command);
+	if (ret)
+		return ret;
+
+	ret = virtmagma_check_expected_response_type(request, response);
+	if (ret)
+		return ret;
+
+	/* pass on magma errors without writing to the buffer */
+	if (response->result_return) {
+		pr_warn("virtmagma: magma_read_notification_channel returned %d",
+			(int32_t)response->result_return);
+		return 0; /* the ioctl is still successful */
+	}
+
+	if (response->buffer_size_out > request->buffer_size) {
+		pr_err("virtmagma: magma_read_notification_channel returned buffer_size_out (%lld) larger than buffer_size (%lld)",
+		       response->buffer_size_out, request->buffer_size);
+		return -EIO;
+	}
+
+	return copy_to_user((void *)request->buffer,
+			    (char *)command->response_ptr + sizeof(*response),
+			    response->buffer_size_out);
+}
+
+#if IS_ENABLED(CONFIG_VIRTIO_WL)
+/* use the implementation in the virtio_wl module */
+extern int virtwl_create_fd_for_vfd(void *filp_private_data, uint32_t vfd_id);
+#else
+#define virtwl_create_fd_for_vfd(a, b) (-ENODEV)
+#endif
+
+static int
+	virtmagma_command_magma_export(struct virtmagma_instance *instance,
+				       struct virtmagma_virtio_command *command)
+{
+	int ret;
+	struct virtio_magma_export_ctrl *request = command->request_ptr;
+	struct virtio_magma_export_resp *response = command->response_ptr;
+
+	if (!instance->wayland_device_private_data)
+		return -ENODEV;
+
+	if (!COMMAND_OK(command, request, response))
+		return -EINVAL;
+
+	ret = vq_out_send_sync(instance->vi, command);
+	if (ret)
+		return ret;
+
+	ret = virtmagma_check_expected_response_type(request, response);
+	if (ret)
+		return ret;
+
+	/* pass on magma errors without creating a vfd */
+	if (response->result_return) {
+		pr_warn("virtmagma: magma_export returned %d",
+			(int32_t)response->result_return);
+		return 0; /* the ioctl is still successful */
+	}
+
+	ret = virtwl_create_fd_for_vfd(instance->wayland_device_private_data,
+				       response->buffer_handle_out);
+	if (ret < 0) {
+		pr_err("virtmagma: failed to get vfd creation info for vfd id %lld",
+		       response->buffer_handle_out);
 		return ret;
 	}
 
-	return 0;
-}
-
-static int vq_queue_out(struct virtmagma_info_private *vip,
-			struct scatterlist *out_sg,
-			struct scatterlist *in_sg,
-			struct completion *finish_completion,
-			bool nonblock)
-{
-	struct virtqueue *vq = vip->vqs[VIRTMAGMA_VQ_OUT];
-	struct mutex *vq_lock = &vip->vq_locks[VIRTMAGMA_VQ_OUT];
-	struct scatterlist *sgs[] = { out_sg, in_sg };
-	int ret = 0;
-
-	mutex_lock(vq_lock);
-	while ((ret = virtqueue_add_sgs(vq, sgs, 1, 1, finish_completion,
-					GFP_KERNEL)) == -ENOSPC) {
-		mutex_unlock(vq_lock);
-		if (nonblock)
-			return -EAGAIN;
-		if (!wait_event_timeout(vip->out_waitq, vq->num_free > 0, HZ))
-			return -EBUSY;
-		mutex_lock(vq_lock);
-	}
-	if (!ret)
-		virtqueue_kick(vq);
-	mutex_unlock(vq_lock);
-
-	if (!nonblock)
-		wait_for_completion(finish_completion);
-
-	return ret;
-}
-
-static int vq_fill_locked(struct virtqueue *vq)
-{
-	void *buffer;
-	int ret = 0;
-
-	while (vq->num_free > 0) {
-		buffer = kmalloc(VQ_DESCRIPTOR_SIZE, GFP_KERNEL);
-		if (!buffer) {
-			ret = -ENOMEM;
-			goto clear_queue;
-		}
-
-		ret = vq_return_inbuf_locked(vq, buffer);
-		if (ret)
-			goto clear_queue;
-	}
+	response->buffer_handle_out = ret;
 
 	return 0;
-
-clear_queue:
-	while ((buffer = virtqueue_detach_unused_buf(vq)))
-		kfree(buffer);
-	return ret;
 }
 
-static int virtmagma_ioctl_handshake(void __user *ptr)
+static int virtmagma_ioctl_handshake(struct file *filp, void __user *ptr)
 {
 	struct virtmagma_ioctl_args_handshake ioctl_args;
-	int ret;
-	ret = copy_from_user(&ioctl_args, ptr, sizeof(ioctl_args));
+	int ret = copy_from_user(&ioctl_args, ptr, sizeof(ioctl_args));
 	if (ret)
 		return ret;
 	if (ioctl_args.handshake_inout != VIRTMAGMA_HANDSHAKE_SEND)
@@ -106,406 +1300,400 @@
 	return copy_to_user(ptr, &ioctl_args, sizeof(ioctl_args));
 }
 
-static void* map_driver(unsigned long long pfn_base, size_t size) {
-	size_t num_pages;
-	struct page **pages;
-	size_t page_index;
-	void *ret;
-
-	num_pages = PAGE_COUNT(size);
-
-	pages = kzalloc(sizeof(pages[0]) * num_pages, GFP_KERNEL);
-	if (!pages)
-		return NULL;
-
-	for (page_index = 0; page_index < num_pages; ++page_index)
-		pages[page_index] = pfn_to_page(pfn_base + page_index);
-
-	/* TODO(MA-520): there should be a faster way to do this if pages are all contiguous in physmem */
-	ret = vm_map_ram(pages, num_pages, 0, PAGE_KERNEL);
-	kfree(pages);
-	return ret;
-}
-
-static void unmap_driver(void *addr, size_t size) {
-	vm_unmap_ram(addr, PAGE_COUNT(size));
-}
-
-static int write_driver_file(const char* path, const void* data, size_t size) {
-	struct file *driver_file;
-	ssize_t bytes_written;
-	loff_t offset;
-	int ret;
-
-	driver_file = filp_open(path, O_CLOEXEC | O_CREAT | O_RDWR, 0555);
-	if (!driver_file)
-		return -EFAULT;
-
-	offset = 0;
-	bytes_written = kernel_write(driver_file, data, size, &offset);
-	if (bytes_written != size) {
-		ret = -EFAULT;
-		goto close_file;
-	}
-
-	ret = 0;
-
-close_file:
-	filp_close(driver_file, NULL);
-
-	return ret;
-}
-
-#define DRIVER_PATH "/libvulkan_magma.so"
-
-static int virtmagma_ioctl_get_driver(struct virtmagma_info* vi, void __user *ptr)
+static int virtmagma_ioctl_get_mmfd(struct file *filp, void __user *ptr)
 {
-	struct virtmagma_ioctl_args_get_driver ioctl_args;
-	struct virtio_magma_get_driver *virtio_ctrl;
-	struct virtio_magma_get_driver_resp *virtio_resp;
-	struct completion finish_completion;
-	struct scatterlist out_sg;
-	struct scatterlist in_sg;
-	unsigned long long driver_pfn_base;
-	size_t driver_size;
-	void *driver_data;
-	int ret;
-
-	ret = copy_from_user(&ioctl_args, ptr, sizeof(ioctl_args));
-	if (ret)
-		return -EFAULT;
-
-	virtio_ctrl = kzalloc(sizeof(*virtio_ctrl), GFP_KERNEL);
-	if (!virtio_ctrl)
-		return -ENOMEM;
-	virtio_resp = kzalloc(sizeof(*virtio_resp), GFP_KERNEL);
-	if (!virtio_resp) {
-		ret = -ENOMEM;
-		goto free_virtio_ctrl;
-	}
-
-	virtio_ctrl->hdr.type = VIRTIO_MAGMA_CMD_GET_DRIVER;
-	virtio_ctrl->page_size = cpu_to_le32(PAGE_SIZE);
-
-	init_completion(&finish_completion);
-
-	sg_init_one(&out_sg, virtio_ctrl, sizeof(*virtio_ctrl));
-	sg_init_one(&in_sg, virtio_resp, sizeof(*virtio_resp));
-
-	ret = vq_queue_out(vi->private, &out_sg, &in_sg, &finish_completion, false /* block */);
-	if (ret)
-		goto free_virtio_resp;
-
-	if (virtio_resp->hdr.type != VIRTIO_MAGMA_RESP_GET_DRIVER) {
-		ret = -EFAULT;
-		goto free_virtio_resp;
-	}
-
-	driver_pfn_base = le64_to_cpu(virtio_resp->pfn);
-	driver_size = le64_to_cpu(virtio_resp->size);
-	driver_data = map_driver(driver_pfn_base, driver_size);
-	if (!driver_data) {
-		ret = -EFAULT;
-		goto free_virtio_resp;
-	}
-
-	ret = write_driver_file(DRIVER_PATH, driver_data, driver_size);
-	if (ret)
-		goto free_driver_alloc;
-
-	ioctl_args.unused = 0;
-	ret = copy_to_user(ptr, &ioctl_args, sizeof(ioctl_args));
-
-free_driver_alloc:
-	unmap_driver(driver_data, driver_size);
-
-free_virtio_resp:
-	kfree(virtio_resp);
-
-free_virtio_ctrl:
-	kfree(virtio_ctrl);
-
-	return ret;
-}
-
-static int virtmagma_ioctl_query(struct virtmagma_info* vi, void __user *ptr)
-{
-	struct virtmagma_ioctl_args_query ioctl_args;
-	struct virtio_magma_query *virtio_ctrl;
-	struct virtio_magma_query_resp *virtio_resp;
-	struct completion finish_completion;
-	struct scatterlist out_sg;
-	struct scatterlist in_sg;
-	int ret;
-
-	ret = copy_from_user(&ioctl_args, ptr, sizeof(ioctl_args));
-	if (ret)
-		return -EFAULT;
-
-	virtio_ctrl = kzalloc(sizeof(*virtio_ctrl), GFP_KERNEL);
-	if (!virtio_ctrl)
-		return -ENOMEM;
-	virtio_resp = kzalloc(sizeof(*virtio_resp), GFP_KERNEL);
-	if (!virtio_resp) {
-		ret = -ENOMEM;
-		goto free_virtio_ctrl;
-	}
-
-	virtio_ctrl->hdr.type = VIRTIO_MAGMA_CMD_QUERY;
-	virtio_ctrl->field_id = cpu_to_le64(ioctl_args.id);
-
-	init_completion(&finish_completion);
-
-	sg_init_one(&out_sg, virtio_ctrl, sizeof(*virtio_ctrl));
-	sg_init_one(&in_sg, virtio_resp, sizeof(*virtio_resp));
-
-	ret = vq_queue_out(vi->private, &out_sg, &in_sg, &finish_completion, false /* block */);
-	if (ret)
-		goto free_virtio_resp;
-
-	if (virtio_resp->hdr.type != VIRTIO_MAGMA_RESP_QUERY) {
-		ret = -EFAULT;
-		goto free_virtio_resp;
-	}
-	ioctl_args.value_out = le64_to_cpu(virtio_resp->field_value_out);
-	ioctl_args.status_return = le32_to_cpu(virtio_resp->status_return);
-	ret = copy_to_user(ptr, &ioctl_args, sizeof(ioctl_args));
-
-free_virtio_resp:
-	kfree(virtio_resp);
-
-free_virtio_ctrl:
-	kfree(virtio_ctrl);
-
-	return ret;
-}
-
-static int virtmagma_ioctl_create_connection(struct virtmagma_info* vi, void __user *ptr)
-{
-	struct virtmagma_ioctl_args_create_connection ioctl_args;
-	struct virtio_magma_create_connection *virtio_ctrl;
-	struct virtio_magma_create_connection_resp *virtio_resp;
-	struct completion finish_completion;
-	struct scatterlist out_sg;
-	struct scatterlist in_sg;
-	int ret;
-
-	ret = copy_from_user(&ioctl_args, ptr, sizeof(ioctl_args));
-	if (ret)
-		return -EFAULT;
-
-	virtio_ctrl = kzalloc(sizeof(*virtio_ctrl), GFP_KERNEL);
-	if (!virtio_ctrl)
-		return -ENOMEM;
-	virtio_resp = kzalloc(sizeof(*virtio_resp), GFP_KERNEL);
-	if (!virtio_resp) {
-		ret = -ENOMEM;
-		goto free_virtio_ctrl;
-	}
-
-	virtio_ctrl->hdr.type = VIRTIO_MAGMA_CMD_CREATE_CONNECTION;
-
-	init_completion(&finish_completion);
-
-	sg_init_one(&out_sg, virtio_ctrl, sizeof(*virtio_ctrl));
-	sg_init_one(&in_sg, virtio_resp, sizeof(*virtio_resp));
-
-	ret = vq_queue_out(vi->private, &out_sg, &in_sg, &finish_completion, false /* block */);
-	if (ret)
-		goto free_virtio_resp;
-
-	if (virtio_resp->hdr.type != VIRTIO_MAGMA_RESP_CREATE_CONNECTION) {
-		ret = -EFAULT;
-		goto free_virtio_resp;
-	}
-
-	ioctl_args.connection_return = virtio_resp->connection_return;
-	ret = copy_to_user(ptr, &ioctl_args, sizeof(ioctl_args));
-
-free_virtio_resp:
-	kfree(virtio_resp);
-
-free_virtio_ctrl:
-	kfree(virtio_ctrl);
-
-	return ret;
-}
-
-static int virtmagma_ioctl_release_connection(struct virtmagma_info* vi, void __user *ptr)
-{
-	struct virtmagma_ioctl_args_release_connection ioctl_args;
-	struct virtio_magma_release_connection *virtio_ctrl;
-	struct virtio_magma_release_connection_resp *virtio_resp;
-	struct completion finish_completion;
-	struct scatterlist out_sg;
-	struct scatterlist in_sg;
-	int ret;
-
-	ret = copy_from_user(&ioctl_args, ptr, sizeof(ioctl_args));
-	if (ret)
-		return -EFAULT;
-
-	virtio_ctrl = kzalloc(sizeof(*virtio_ctrl), GFP_KERNEL);
-	if (!virtio_ctrl)
-		return -ENOMEM;
-	virtio_resp = kzalloc(sizeof(*virtio_resp), GFP_KERNEL);
-	if (!virtio_resp) {
-		ret = -ENOMEM;
-		goto free_virtio_ctrl;
-	}
-
-	virtio_ctrl->hdr.type = VIRTIO_MAGMA_CMD_RELEASE_CONNECTION;
-	virtio_ctrl->connection = ioctl_args.connection;
-
-	init_completion(&finish_completion);
-
-	sg_init_one(&out_sg, virtio_ctrl, sizeof(*virtio_ctrl));
-	sg_init_one(&in_sg, virtio_resp, sizeof(*virtio_resp));
-
-	ret = vq_queue_out(vi->private, &out_sg, &in_sg, &finish_completion, false /* block */);
-	if (ret)
-		goto free_virtio_resp;
-
-	if (virtio_resp->hdr.type != VIRTIO_MAGMA_RESP_RELEASE_CONNECTION)
-		ret = -EFAULT;
-
-free_virtio_resp:
-	kfree(virtio_resp);
-
-free_virtio_ctrl:
-	kfree(virtio_ctrl);
-
-	return ret;
-}
-
-static int virtmagma_probe(struct virtmagma_info* vi, struct virtio_device *vdev)
-{
-	return 0;
-}
-
-static void virtmagma_remove(struct virtmagma_info* vi, struct virtio_device *vdev)
-{
-}
-
-static long virtmagma_ioctl(struct virtmagma_info* vi, unsigned int cmd, void __user *ptr)
-{
-	/* if vi->private is NULL, magma has not been initialized */
-	if (!vi->private)
+	struct virtmagma_ioctl_args_get_mmfd ioctl_args;
+	struct virtmagma_instance *instance = filp->private_data;
+	if (!instance)
 		return -ENODEV;
-	switch (cmd) {
-	case VIRTMAGMA_IOCTL_HANDSHAKE:
-		return virtmagma_ioctl_handshake(ptr);
-	case VIRTMAGMA_IOCTL_GET_DRIVER:
-		return virtmagma_ioctl_get_driver(vi, ptr);
-	case VIRTMAGMA_IOCTL_QUERY:
-		return virtmagma_ioctl_query(vi, ptr);
-	case VIRTMAGMA_IOCTL_CREATE_CONNECTION:
-		return virtmagma_ioctl_create_connection(vi, ptr);
-	case VIRTMAGMA_IOCTL_RELEASE_CONNECTION:
-		return virtmagma_ioctl_release_connection(vi, ptr);
-	default:
+	ioctl_args.fd_out = instance->mmfd;
+	return copy_to_user(ptr, &ioctl_args, sizeof(ioctl_args));
+}
+
+int virtmagma_ioctl_magma_command(struct file *filp, void __user *ptr)
+{
+	struct virtmagma_ioctl_args_magma_command ioctl_args;
+	struct virtmagma_virtio_command command;
+	void *request;
+	void *response;
+	int request_type;
+	int ret;
+	struct virtmagma_instance *instance = filp->private_data;
+	command.request_ptr = NULL;
+	command.response_ptr = NULL;
+
+	if (!instance)
+		return -ENODEV;
+
+	if (instance->mmap_params.pending) {
+		pr_warn("virtmagma: user failed to mmap on the mmfd after submitting a magma_map ioctl");
 		return -EINVAL;
 	}
+
+	/* copy in command arguments */
+
+	ret = copy_from_user(&ioctl_args, ptr, sizeof(ioctl_args));
+	if (ret)
+		return ret;
+
+	/* verify userspace-provided pointers are accessible */
+
+	ret = !access_ok(VERIFY_READ, (void *)ioctl_args.request_address,
+			 ioctl_args.request_size);
+	if (ret)
+		return -EFAULT;
+	ret = !access_ok(VERIFY_WRITE, (void *)ioctl_args.response_address,
+			 ioctl_args.response_size);
+	if (ret)
+		return -EFAULT;
+
+	/* allocate buffers and copy in userspace data */
+
+	if (ioctl_args.request_size <= MESSAGE_CACHE_OBJECT_SIZE)
+		request = kmem_cache_alloc(instance->msg_cache, GFP_KERNEL);
+	else
+		request = kzalloc(ioctl_args.request_size, GFP_KERNEL);
+	if (!request)
+		return -ENOMEM;
+	if (ioctl_args.response_size <= MESSAGE_CACHE_OBJECT_SIZE)
+		response = kmem_cache_alloc(instance->msg_cache, GFP_KERNEL);
+	else
+		response = kzalloc(ioctl_args.response_size, GFP_KERNEL);
+	if (!response) {
+		ret = -ENOMEM;
+		goto free_request;
+	}
+	command.request_ptr = request;
+	command.response_ptr = response;
+	command.request_size = ioctl_args.request_size;
+	command.response_size = ioctl_args.response_size;
+
+	ret = copy_from_user(command.request_ptr,
+			     (void *)ioctl_args.request_address,
+			     ioctl_args.request_size);
+	if (ret)
+		goto free_response;
+
+	request_type = control_type(command.request_ptr);
+	switch (request_type) {
+	case VIRTIO_MAGMA_CMD_CREATE_CONNECTION:
+		ret = virtmagma_command_magma_create_connection(instance,
+								&command);
+		break;
+	case VIRTIO_MAGMA_CMD_RELEASE_CONNECTION:
+		ret = virtmagma_command_magma_release_connection(instance,
+								 &command);
+		break;
+	case VIRTIO_MAGMA_CMD_CREATE_CONTEXT:
+		ret = virtmagma_command_magma_create_context(instance,
+							     &command);
+		break;
+	case VIRTIO_MAGMA_CMD_RELEASE_CONTEXT:
+		ret = virtmagma_command_magma_release_context(instance,
+							      &command);
+		break;
+	case VIRTIO_MAGMA_CMD_CREATE_BUFFER:
+		ret = virtmagma_command_magma_create_buffer(instance, &command);
+		break;
+	case VIRTIO_MAGMA_CMD_RELEASE_BUFFER:
+		ret = virtmagma_command_magma_release_buffer(instance,
+							     &command);
+		break;
+	case VIRTIO_MAGMA_CMD_CREATE_COMMAND_BUFFER:
+		ret = virtmagma_command_magma_create_command_buffer(instance,
+								    &command);
+		break;
+	case VIRTIO_MAGMA_CMD_RELEASE_COMMAND_BUFFER:
+		ret = virtmagma_command_magma_release_command_buffer(instance,
+								     &command);
+		break;
+	case VIRTIO_MAGMA_CMD_SUBMIT_COMMAND_BUFFER:
+		ret = virtmagma_command_magma_submit_command_buffer(instance,
+								    &command);
+		break;
+	case VIRTIO_MAGMA_CMD_CREATE_SEMAPHORE:
+		ret = virtmagma_command_magma_create_semaphore(instance,
+							       &command);
+		break;
+	case VIRTIO_MAGMA_CMD_RELEASE_SEMAPHORE:
+		ret = virtmagma_command_magma_release_semaphore(instance,
+								&command);
+		break;
+	case VIRTIO_MAGMA_CMD_MAP:
+		ret = virtmagma_command_magma_map(instance, &command);
+		break;
+	case VIRTIO_MAGMA_CMD_WAIT_SEMAPHORES:
+		ret = virtmagma_command_magma_wait_semaphores(instance,
+							      &command);
+		break;
+	case VIRTIO_MAGMA_CMD_READ_NOTIFICATION_CHANNEL:
+		ret = virtmagma_command_magma_read_notification_channel(
+			instance, &command);
+		break;
+	case VIRTIO_MAGMA_CMD_EXPORT:
+		ret = virtmagma_command_magma_export(instance, &command);
+		break;
+	/* pass-through handlers */
+	case VIRTIO_MAGMA_CMD_QUERY:
+	case VIRTIO_MAGMA_CMD_GET_ERROR:
+	case VIRTIO_MAGMA_CMD_GET_BUFFER_ID:
+	case VIRTIO_MAGMA_CMD_GET_BUFFER_SIZE:
+	case VIRTIO_MAGMA_CMD_CLEAN_CACHE:
+	case VIRTIO_MAGMA_CMD_SET_CACHE_POLICY:
+	case VIRTIO_MAGMA_CMD_GET_BUFFER_CACHE_POLICY:
+	case VIRTIO_MAGMA_CMD_GET_BUFFER_IS_MAPPABLE:
+	case VIRTIO_MAGMA_CMD_UNMAP:
+	case VIRTIO_MAGMA_CMD_MAP_BUFFER_GPU:
+	case VIRTIO_MAGMA_CMD_UNMAP_BUFFER_GPU:
+	case VIRTIO_MAGMA_CMD_COMMIT_BUFFER:
+	case VIRTIO_MAGMA_CMD_GET_SEMAPHORE_ID:
+	case VIRTIO_MAGMA_CMD_SIGNAL_SEMAPHORE:
+	case VIRTIO_MAGMA_CMD_RESET_SEMAPHORE:
+	case VIRTIO_MAGMA_CMD_GET_NOTIFICATION_CHANNEL_HANDLE:
+	case VIRTIO_MAGMA_CMD_WAIT_NOTIFICATION_CHANNEL:
+		ret = vq_out_send_sync(instance->vi, &command);
+		if (!ret)
+			ret = virtmagma_check_expected_response_type(
+				command.request_ptr, command.response_ptr);
+		break;
+	default:
+		pr_warn("virtmagma: command %s (%d) not implemented",
+			virtio_magma_ctrl_type_string(request_type),
+			request_type);
+		ret = -EINVAL;
+		break;
+	}
+	if (ret) {
+		pr_err("virtmagma: error handling command %s (%d)",
+		       virtio_magma_ctrl_type_string(request_type),
+		       request_type);
+		dump_stack();
+		goto free_response;
+	}
+
+	/* copy responses back to userspace */
+
+	ret = copy_to_user((void *)ioctl_args.response_address,
+			   command.response_ptr, ioctl_args.response_size);
+
+free_response:
+	if (ioctl_args.request_size <= MESSAGE_CACHE_OBJECT_SIZE)
+		kmem_cache_free(instance->msg_cache, request);
+	else
+		kfree(request);
+
+free_request:
+	if (ioctl_args.response_size <= MESSAGE_CACHE_OBJECT_SIZE)
+		kmem_cache_free(instance->msg_cache, response);
+	else
+		kfree(response);
+
+	/* Some of the handlers above may override the command members and hand
+	   off allocation ownership back to us. Free them now. */
+
+	if (command.request_ptr && command.request_ptr != request)
+		kfree(command.request_ptr);
+
+	if (command.response_ptr && command.response_ptr != response)
+		kfree(command.response_ptr);
+
+	return ret;
+}
+
+static int virtmagma_open(struct inode *inodep, struct file *filp)
+{
+	int ret;
+	struct virtmagma_instance *instance;
+	struct virtmagma_info *vi =
+		container_of(inodep->i_cdev, struct virtmagma_info, cdev);
+
+	ret = create_instance(vi, &instance);
+	if (ret)
+		return ret;
+
+	filp->private_data = instance;
+
 	return 0;
 }
 
-static void vq_in_work_handler(struct work_struct *work)
+static int virtmagma_release(struct inode *inodep, struct file *filp)
 {
-	pr_warn("%s\n", __PRETTY_FUNCTION__);
+	struct virtmagma_instance *instance = filp->private_data;
+	return destroy_instance(instance->id, instance, instance->vi);
 }
 
 static void vq_out_work_handler(struct work_struct *work)
 {
-	struct virtmagma_info_private *vip = container_of(work, struct virtmagma_info_private,
-					      out_vq_work);
-	struct virtqueue *vq = vip->vqs[VIRTMAGMA_VQ_OUT];
-	struct mutex *vq_lock = &vip->vq_locks[VIRTMAGMA_VQ_OUT];
+	struct virtmagma_info *vi =
+		container_of(work, struct virtmagma_info, out_vq_work);
 	unsigned int len;
 	struct completion *finish_completion;
 	bool wake_waitq = false;
 
-	mutex_lock(vq_lock);
-	while ((finish_completion = virtqueue_get_buf(vq, &len)) != NULL) {
+	mutex_lock(&vi->vq_out_lock);
+	while ((finish_completion = virtqueue_get_buf(vi->vq_out, &len)) !=
+	       NULL) {
 		wake_waitq = true;
 		complete(finish_completion);
 	}
-	mutex_unlock(vq_lock);
+	mutex_unlock(&vi->vq_out_lock);
 
 	if (wake_waitq)
-		wake_up_interruptible_all(&vip->out_waitq);
-}
-
-static void vq_in_cb(struct virtqueue *vq)
-{
-	struct virtmagma_info *vi = vq->vdev->priv + magma_info_offset;
-	struct virtmagma_info_private *vip = vi->private;
-	schedule_work(&vip->in_vq_work);
+		wake_up_interruptible_all(&vi->out_waitq);
 }
 
 static void vq_out_cb(struct virtqueue *vq)
 {
-	struct virtmagma_info *vi = vq->vdev->priv + magma_info_offset;
-	struct virtmagma_info_private *vip = vi->private;
-	schedule_work(&vip->out_vq_work);
+	struct virtmagma_info *vi = vq->vdev->priv;
+	schedule_work(&vi->out_vq_work);
 }
 
-static void virtmagma_virtio_find_vqs_prepare(struct virtmagma_info* vi, vq_callback_t **vq_callbacks, const char **vq_names)
+static long virtmagma_ioctl_common(struct file *filp, unsigned int cmd,
+				   void __user *ptr)
 {
-	vq_callbacks[VIRTMAGMA_VQ_IN] = vq_in_cb;
-	vq_callbacks[VIRTMAGMA_VQ_OUT] = vq_out_cb;
-	vq_names[VIRTMAGMA_VQ_IN] = "magma_in";
-	vq_names[VIRTMAGMA_VQ_OUT] = "magma_out";
-}
-
-static void virtmagma_virtio_find_vqs_complete(struct virtmagma_info* vi, struct virtqueue **vqs)
-{
-	struct virtmagma_info_private *vip = vi->private;
-	memcpy(vip->vqs, vqs, sizeof(vip->vqs));
-	INIT_WORK(&vip->in_vq_work, vq_in_work_handler);
-	INIT_WORK(&vip->out_vq_work, vq_out_work_handler);
-	init_waitqueue_head(&vip->out_waitq);
-}
-
-static int virtmagma_device_ready_prepare(struct virtmagma_info* vi)
-{
-	struct virtmagma_info_private *vip = vi->private;
-	int ret;
-	ret = vq_fill_locked(vip->vqs[VIRTMAGMA_VQ_IN]);
-	if (ret) {
-		pr_warn("virtmagma: failed to fill in virtqueue: %d", ret);
-		return ret;
+	switch (cmd) {
+	case VIRTMAGMA_IOCTL_HANDSHAKE:
+		return virtmagma_ioctl_handshake(filp, ptr);
+	case VIRTMAGMA_IOCTL_GET_MMFD:
+		return virtmagma_ioctl_get_mmfd(filp, ptr);
+	case VIRTMAGMA_IOCTL_MAGMA_COMMAND:
+		return virtmagma_ioctl_magma_command(filp, ptr);
+	default:
+		return -ENOTTY;
 	}
-	return 0;
 }
 
-static void virtmagma_device_ready_complete(struct virtmagma_info* vi)
+static long virtmagma_ioctl(struct file *filp, unsigned int cmd,
+			    unsigned long arg)
 {
-	struct virtmagma_info_private *vip = vi->private;
-	virtqueue_kick(vip->vqs[VIRTMAGMA_VQ_IN]);
+	return virtmagma_ioctl_common(filp, cmd, (void __user *)arg);
 }
 
-int virtmagma_init(struct virtmagma_info *vi)
+#ifdef CONFIG_COMPAT
+static long virtmagma_ioctl_compat(struct file *filp, unsigned int cmd,
+				   unsigned long arg)
 {
-	int i;
-	struct virtmagma_info_private *vip;
-	vi->virtio_probe = virtmagma_probe;
-	vi->virtio_remove = virtmagma_remove;
-	vi->ioctl = virtmagma_ioctl;
-	vi->virtio_find_vqs_prepare = virtmagma_virtio_find_vqs_prepare;
-	vi->virtio_find_vqs_complete = virtmagma_virtio_find_vqs_complete;
-	vi->virtio_device_ready_prepare = virtmagma_device_ready_prepare;
-	vi->virtio_device_ready_complete = virtmagma_device_ready_complete;
-	vi->queue_count = VIRTMAGMA_QUEUE_COUNT;
+	return virtmagma_ioctl_common(filp, cmd, compat_ptr(arg));
+}
+#else
+#define virtmagma_ioctl_compat NULL
+#endif
 
-	vi->private = kzalloc(sizeof(*vip), GFP_KERNEL);
-	if (!vi->private)
+static const struct file_operations virtmagma_fops = {
+	.open = virtmagma_open,
+	.unlocked_ioctl = virtmagma_ioctl,
+	.compat_ioctl = virtmagma_ioctl_compat,
+	.release = virtmagma_release,
+};
+
+static int virtmagma_probe(struct virtio_device *vdev)
+{
+	int ret;
+	struct virtmagma_info *vi = NULL;
+	static const char *vq_out_name = "out";
+	vq_callback_t *callback = &vq_out_cb;
+
+	vi = kzalloc(sizeof(struct virtmagma_info), GFP_KERNEL);
+	if (!vi)
 		return -ENOMEM;
-	vip = vi->private;
 
-	for (i = 0; i < VIRTMAGMA_QUEUE_COUNT; i++)
-		mutex_init(&vip->vq_locks[i]);
+	vdev->priv = vi;
 
-	vi->enabled = true;
+	ret = alloc_chrdev_region(&vi->dev_num, 0, 1, "magma");
+	if (ret) {
+		ret = -ENOMEM;
+		pr_warn("virtmagma: failed to allocate wl chrdev region: %d\n",
+			ret);
+		goto free_vi;
+	}
+
+	vi->class = class_create(THIS_MODULE, "magma");
+	if (IS_ERR(vi->class)) {
+		ret = PTR_ERR(vi->class);
+		pr_warn("virtmagma: failed to create magma class: %d\n", ret);
+		goto unregister_region;
+	}
+
+	vi->dev = device_create(vi->class, NULL, vi->dev_num, vi, "magma%d", 0);
+	if (IS_ERR(vi->dev)) {
+		ret = PTR_ERR(vi->dev);
+		pr_warn("virtmagma: failed to create magma0 device: %d\n", ret);
+		goto destroy_class;
+	}
+
+	cdev_init(&vi->cdev, &virtmagma_fops);
+	ret = cdev_add(&vi->cdev, vi->dev_num, 1);
+	if (ret) {
+		pr_warn("virtmagma: failed to add virtio magma character device to system: %d\n",
+			ret);
+		goto destroy_device;
+	}
+
+	mutex_init(&vi->vq_out_lock);
+	mutex_init(&vi->instances_lock);
+	idr_init(&vi->instances);
+
+	ret = virtio_find_vqs(vdev, 1, &vi->vq_out, &callback, &vq_out_name,
+			      NULL);
+	if (ret) {
+		pr_warn("virtmagma: failed to find virtio magma out queue: %d\n",
+			ret);
+		goto del_cdev;
+	}
+
+	INIT_WORK(&vi->out_vq_work, vq_out_work_handler);
+	init_waitqueue_head(&vi->out_waitq);
+
+	virtio_device_ready(vdev);
 
 	return 0;
+
+del_cdev:
+	cdev_del(&vi->cdev);
+destroy_device:
+	put_device(vi->dev);
+destroy_class:
+	class_destroy(vi->class);
+unregister_region:
+	unregister_chrdev_region(vi->dev_num, 0);
+free_vi:
+	kfree(vi);
+	return ret;
 }
+
+static void virtmagma_remove(struct virtio_device *vdev)
+{
+	struct virtmagma_info *vi = vdev->priv;
+
+	idr_for_each(&vi->instances, destroy_instance, vi);
+	mutex_destroy(&vi->instances_lock);
+	idr_destroy(&vi->instances);
+	cdev_del(&vi->cdev);
+	put_device(vi->dev);
+	class_destroy(vi->class);
+	unregister_chrdev_region(vi->dev_num, 0);
+	kfree(vi);
+}
+
+static void virtmagma_scan(struct virtio_device *vdev)
+{
+}
+
+static struct virtio_device_id id_table[] = {
+	{ VIRTIO_ID_MAGMA, VIRTIO_DEV_ANY_ID },
+	{ 0 },
+};
+
+static struct virtio_driver virtio_magma_driver = {
+	.driver.name = KBUILD_MODNAME,
+	.driver.owner = THIS_MODULE,
+	.id_table = id_table,
+	.probe = virtmagma_probe,
+	.remove = virtmagma_remove,
+	.scan = virtmagma_scan,
+};
+
+module_virtio_driver(virtio_magma_driver);
+MODULE_DEVICE_TABLE(virtio, id_table);
+MODULE_DESCRIPTION("Virtio Magma driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/virtio/virtio_magma.h b/drivers/virtio/virtio_magma.h
deleted file mode 100644
index efef2b1..0000000
--- a/drivers/virtio/virtio_magma.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2019 The Fuchsia Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef _DRIVERS_VIRTIO_VIRTIO_MAGMA_H
-#define _DRIVERS_VIRTIO_VIRTIO_MAGMA_H
-
-#include <linux/fs.h>
-#include <linux/types.h>
-#include <linux/virtio.h>
-#include <linux/virtmagma.h>
-
-#define VIRTMAGMA_VQ_IN 0
-#define VIRTMAGMA_VQ_OUT 1
-#define VIRTMAGMA_QUEUE_COUNT 2
-
-struct virtmagma_info {
-	bool enabled;
-	int (*virtio_probe)(struct virtmagma_info* vi, struct virtio_device *vdev);
-	void (*virtio_remove)(struct virtmagma_info* vi, struct virtio_device *vdev);
-	long (*ioctl)(struct virtmagma_info* vi, unsigned int cmd, void __user *ptr);
-	void (*virtio_find_vqs_prepare)(struct virtmagma_info* vi, vq_callback_t **vq_callbacks, const char **vq_names);
-	void (*virtio_find_vqs_complete)(struct virtmagma_info* vi, struct virtqueue **vqs);
-	int (*virtio_device_ready_prepare)(struct virtmagma_info* vi);
-	void (*virtio_device_ready_complete)(struct virtmagma_info* vi);
-	uint32_t queue_count;
-	void *private;
-};
-
-int virtmagma_init(struct virtmagma_info *vi);
-
-extern const size_t magma_info_offset;
-
-#endif /* _DRIVERS_VIRTIO_VIRTIO_MAGMA_H */
diff --git a/drivers/virtio/virtio_wl.c b/drivers/virtio/virtio_wl.c
index 23e1f7e..3ee6225 100644
--- a/drivers/virtio/virtio_wl.c
+++ b/drivers/virtio/virtio_wl.c
@@ -60,8 +60,6 @@
 
 #include <uapi/linux/dma-buf.h>
 
-#include "virtio_magma.h"
-
 #define VFD_ILLEGAL_SIGN_BIT 0x80000000
 #define VFD_HOST_VFD_ID_BIT 0x40000000
 
@@ -104,11 +102,10 @@
 	struct mutex vfds_lock;
 	struct idr vfds;
 
-	struct virtmagma_info magma_info;
+	uint32_t vfd_wait_id;
+	struct completion vfd_wait_completion;
 };
 
-const size_t magma_info_offset = offsetof(struct virtwl_info, magma_info);
-
 static struct virtwl_vfd *virtwl_vfd_alloc(struct virtwl_info *vi);
 static void virtwl_vfd_free(struct virtwl_vfd *vfd);
 
@@ -240,6 +237,11 @@
 	vfd->pfn = new->pfn;
 	vfd->flags = new->flags;
 
+	if (vfd->id == vi->vfd_wait_id) {
+		vi->vfd_wait_id = 0;
+		complete(&vi->vfd_wait_completion);
+	}
+
 	return true; /* return the inbuf to vq */
 }
 
@@ -914,6 +916,36 @@
 	return 0;
 }
 
+/* externally visible function to create fds for existing vfds */
+int virtwl_create_fd_for_vfd(void *filp_private_data, uint32_t vfd_id)
+{
+	struct virtwl_info *vi = filp_private_data;
+	struct virtwl_vfd *vfd;
+
+	mutex_lock(&vi->vfds_lock);
+	vfd = idr_find(&vi->vfds, vfd_id);
+	mutex_unlock(&vi->vfds_lock);
+
+	if (!vfd) {
+		vi->vfd_wait_id = vfd_id;
+		reinit_completion(&vi->vfd_wait_completion);
+		if (wait_for_completion_timeout(&vi->vfd_wait_completion, HZ)) {
+			mutex_lock(&vi->vfds_lock);
+			vfd = idr_find(&vi->vfds, vfd_id);
+			mutex_unlock(&vi->vfds_lock);
+		}
+	}
+
+	if (!vfd) {
+		pr_warn("virtwl: request to create fd for non-existent vfd id %d",
+			vfd_id);
+		return -ENOENT;
+	}
+
+	return anon_inode_getfd("[virtwl_vfd]", &virtwl_vfd_fops, vfd,
+				virtwl_vfd_file_flags(vfd) | O_CLOEXEC);
+}
+
 static int virtwl_open(struct inode *inodep, struct file *filp)
 {
 	struct virtwl_info *vi = container_of(inodep->i_cdev,
@@ -1202,13 +1234,6 @@
 	if (filp->f_op == &virtwl_vfd_fops)
 		return virtwl_vfd_ioctl(filp, cmd, ptr);
 
-	if (_IOC_TYPE(cmd) == VIRTMAGMA_IOCTL_BASE) {
-		struct virtwl_info *vi = filp->private_data;
-		if (!vi->magma_info.enabled)
-			return -ENODEV; /* virtmagma not initialized */
-		return vi->magma_info.ioctl(&vi->magma_info, cmd, ptr);
-	}
-
 	switch (_IOC_NR(cmd)) {
 	case _IOC_NR(VIRTWL_IOCTL_NEW):
 		return virtwl_ioctl_new(filp, ptr, _IOC_SIZE(cmd));
@@ -1258,11 +1283,9 @@
 {
 	int i;
 	int ret;
-	unsigned queue_count;
 	struct virtwl_info *vi = NULL;
-	struct virtqueue *vqs[VIRTWL_MAX_QUEUES];
-	vq_callback_t *vq_callbacks[VIRTWL_MAX_QUEUES] = { vq_in_cb, vq_out_cb };
-	static const char *vq_names[VIRTWL_MAX_QUEUES] = { "in", "out" };
+	vq_callback_t *vq_callbacks[] = { vq_in_cb, vq_out_cb };
+	static const char * const vq_names[] = { "in", "out" };
 
 	vi = kzalloc(sizeof(struct virtwl_info), GFP_KERNEL);
 	if (!vi)
@@ -1304,39 +1327,13 @@
 	for (i = 0; i < VIRTWL_QUEUE_COUNT; i++)
 		mutex_init(&vi->vq_locks[i]);
 
-	queue_count = VIRTWL_QUEUE_COUNT;
-	if (vdev->features & (1ULL << VIRTIO_WL_F_MAGMA)) {
-		pr_info("virtwl: initializing virtmagma");
-		ret = virtmagma_init(&vi->magma_info);
-		if (ret) {
-			pr_warn("virtwl: failed to initialize virtmagma: %d\n", ret);
-			goto destroy_device;
-		}
-		queue_count += vi->magma_info.queue_count;
-	}
-
-	/*
-	 * virtio_find_vqs is a one-time operation, so child devices must
-	 * expose their respective arguments for the call to the parent.
-	 */
-	if (queue_count > VIRTWL_MAX_QUEUES) {
-		pr_warn("virtwl: too many queues requested by child device\n");
-		ret = -ENOMEM;
-		goto destroy_device;
-	}
-	if (vi->magma_info.enabled)
-		vi->magma_info.virtio_find_vqs_prepare(&vi->magma_info,
-			&vq_callbacks[VIRTWL_QUEUE_COUNT],
-			&vq_names[VIRTWL_QUEUE_COUNT]);
-	ret = virtio_find_vqs(vdev, queue_count, vqs, vq_callbacks, vq_names, NULL);
+	ret = virtio_find_vqs(vdev, VIRTWL_QUEUE_COUNT, vi->vqs, vq_callbacks,
+			      vq_names, NULL);
 	if (ret) {
 		pr_warn("virtwl: failed to find virtio wayland queues: %d\n",
 			ret);
 		goto del_cdev;
 	}
-	memcpy(vi->vqs, vqs, sizeof(vi->vqs));
-	if (vi->magma_info.enabled)
-		vi->magma_info.virtio_find_vqs_complete(&vi->magma_info, &vqs[VIRTWL_QUEUE_COUNT]);
 
 	INIT_WORK(&vi->in_vq_work, vq_in_work_handler);
 	INIT_WORK(&vi->out_vq_work, vq_out_work_handler);
@@ -1344,6 +1341,7 @@
 
 	mutex_init(&vi->vfds_lock);
 	idr_init(&vi->vfds);
+	init_completion(&vi->vfd_wait_completion);
 
 	/* lock is unneeded as we have unique ownership */
 	ret = vq_fill_locked(vi->vqs[VIRTWL_VQ_IN]);
@@ -1352,17 +1350,8 @@
 		goto del_cdev;
 	}
 
-	if (vi->magma_info.enabled) {
-		ret = vi->magma_info.virtio_device_ready_prepare(&vi->magma_info);
-		if (ret) {
-			pr_warn("virtwl: failed to prepare virtmagma for device-ready: %d", ret);
-			goto del_cdev;
-		}
-	}
 	virtio_device_ready(vdev);
 	virtqueue_kick(vi->vqs[VIRTWL_VQ_IN]);
-	if (vi->magma_info.enabled)
-		vi->magma_info.virtio_device_ready_complete(&vi->magma_info);
 
 	return 0;
 
@@ -1383,7 +1372,6 @@
 {
 	struct virtwl_info *vi = vdev->priv;
 
-	vi->magma_info.virtio_remove(&vi->magma_info, vdev);
 	cdev_del(&vi->cdev);
 	put_device(vi->dev);
 	class_destroy(vi->class);
@@ -1405,20 +1393,17 @@
 {
 }
 
-
 static struct virtio_device_id id_table[] = {
 	{ VIRTIO_ID_WL, VIRTIO_DEV_ANY_ID },
 	{ 0 },
 };
 
 static unsigned int features_legacy[] = {
-	VIRTIO_WL_F_TRANS_FLAGS,
-	VIRTIO_WL_F_MAGMA
+	VIRTIO_WL_F_TRANS_FLAGS
 };
 
 static unsigned int features[] = {
-	VIRTIO_WL_F_TRANS_FLAGS,
-	VIRTIO_WL_F_MAGMA
+	VIRTIO_WL_F_TRANS_FLAGS
 };
 
 static struct virtio_driver virtio_wl_driver = {
diff --git a/include/uapi/linux/virtio_ids.h b/include/uapi/linux/virtio_ids.h
index 293872a..c5cf1b2 100644
--- a/include/uapi/linux/virtio_ids.h
+++ b/include/uapi/linux/virtio_ids.h
@@ -44,5 +44,6 @@
 #define VIRTIO_ID_VSOCK        19 /* virtio vsock transport */
 #define VIRTIO_ID_CRYPTO       20 /* virtio crypto */
 #define VIRTIO_ID_WL           30 /* virtio wayland */
+#define VIRTIO_ID_MAGMA        50 /* virtio magma */
 
 #endif /* _LINUX_VIRTIO_IDS_H */
diff --git a/include/uapi/linux/virtio_magma.h b/include/uapi/linux/virtio_magma.h
index d57435f..74f441d 100644
--- a/include/uapi/linux/virtio_magma.h
+++ b/include/uapi/linux/virtio_magma.h
@@ -1,6 +1,9 @@
-// Copyright 2018 The Fuchsia Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+/* Copyright 2018 The Fuchsia Authors. All rights reserved.
+   Use of this source code is governed by a BSD-style license that can be
+   found in the LICENSE file. */
+
+/* NOTE: DO NOT EDIT THIS FILE! It is generated automatically by:
+     //garnet/lib/magma/include/virtio/virtio_magma.h.gen.py */
 
 #ifndef _LINUX_VIRTIO_MAGMA_H
 #define _LINUX_VIRTIO_MAGMA_H
@@ -9,485 +12,724 @@
 #include <linux/virtio_config.h>
 #include <linux/virtmagma.h>
 
-
-
+struct virtio_magma_config {
+	__le64 dummy;
+} __attribute((packed));
 
 enum virtio_magma_ctrl_type {
-    /* magma commands */
-    VIRTIO_MAGMA_CMD_GET_DRIVER = 0x0400,
-    VIRTIO_MAGMA_CMD_QUERY,
-    VIRTIO_MAGMA_CMD_CREATE_CONNECTION,
-    VIRTIO_MAGMA_CMD_RELEASE_CONNECTION,
-    VIRTIO_MAGMA_CMD_GET_ERROR,
-    VIRTIO_MAGMA_CMD_CREATE_CONTEXT,
-    VIRTIO_MAGMA_CMD_RELEASE_CONTEXT,
-    VIRTIO_MAGMA_CMD_CREATE_BUFFER,
-    VIRTIO_MAGMA_CMD_RELEASE_BUFFER,
-    VIRTIO_MAGMA_CMD_GET_BUFFER_ID,
-    VIRTIO_MAGMA_CMD_GET_BUFFER_SIZE,
-    VIRTIO_MAGMA_CMD_CLEAN_CACHE,
-    VIRTIO_MAGMA_CMD_SET_CACHE_POLICY,
-    VIRTIO_MAGMA_CMD_MAP,
-    VIRTIO_MAGMA_CMD_MAP_ALIGNED,
-    VIRTIO_MAGMA_CMD_MAP_SPECIFIC,
-    VIRTIO_MAGMA_CMD_UNMAP,
-    VIRTIO_MAGMA_CMD_MAP_BUFFER_GPU,
-    VIRTIO_MAGMA_CMD_UNMAP_BUFFER_GPU,
-    VIRTIO_MAGMA_CMD_COMMIT_BUFFER,
-    VIRTIO_MAGMA_CMD_EXPORT,
-    VIRTIO_MAGMA_CMD_IMPORT,
-    VIRTIO_MAGMA_CMD_CREATE_COMMAND_BUFFER,
-    VIRTIO_MAGMA_CMD_RELEASE_COMMAND_BUFFER,
-    VIRTIO_MAGMA_CMD_SUBMIT_COMMAND_BUFFER,
-    VIRTIO_MAGMA_CMD_EXECUTE_IMMEDIATE_COMMANDS,
-    VIRTIO_MAGMA_CMD_CREATE_SEMAPHORE,
-    VIRTIO_MAGMA_CMD_RELEASE_SEMAPHORE,
-    VIRTIO_MAGMA_CMD_GET_SEMAPHORE_ID,
-    VIRTIO_MAGMA_CMD_SIGNAL_SEMAPHORE,
-    VIRTIO_MAGMA_CMD_RESET_SEMAPHORE,
-    VIRTIO_MAGMA_CMD_WAIT_SEMAPHORES,
-    VIRTIO_MAGMA_CMD_EXPORT_SEMAPHORE,
-    VIRTIO_MAGMA_CMD_IMPORT_SEMAPHORE,
-    VIRTIO_MAGMA_CMD_READ_NOTIFICATION_CHANNEL,
-    /* magma success responses */
-    VIRTIO_MAGMA_RESP_GET_DRIVER = 0x1180,
-    VIRTIO_MAGMA_RESP_QUERY,
-    VIRTIO_MAGMA_RESP_CREATE_CONNECTION,
-    VIRTIO_MAGMA_RESP_RELEASE_CONNECTION,
-    VIRTIO_MAGMA_RESP_GET_ERROR,
-    VIRTIO_MAGMA_RESP_CREATE_CONTEXT,
-    VIRTIO_MAGMA_RESP_RELEASE_CONTEXT,
-    VIRTIO_MAGMA_RESP_CREATE_BUFFER,
-    VIRTIO_MAGMA_RESP_RELEASE_BUFFER,
-    VIRTIO_MAGMA_RESP_GET_BUFFER_ID,
-    VIRTIO_MAGMA_RESP_GET_BUFFER_SIZE,
-    VIRTIO_MAGMA_RESP_CLEAN_CACHE,
-    VIRTIO_MAGMA_RESP_SET_CACHE_POLICY,
-    VIRTIO_MAGMA_RESP_MAP,
-    VIRTIO_MAGMA_RESP_MAP_ALIGNED,
-    VIRTIO_MAGMA_RESP_MAP_SPECIFIC,
-    VIRTIO_MAGMA_RESP_UNMAP,
-    VIRTIO_MAGMA_RESP_MAP_BUFFER_GPU,
-    VIRTIO_MAGMA_RESP_UNMAP_BUFFER_GPU,
-    VIRTIO_MAGMA_RESP_COMMIT_BUFFER,
-    VIRTIO_MAGMA_RESP_EXPORT,
-    VIRTIO_MAGMA_RESP_IMPORT,
-    VIRTIO_MAGMA_RESP_CREATE_COMMAND_BUFFER,
-    VIRTIO_MAGMA_RESP_RELEASE_COMMAND_BUFFER,
-    VIRTIO_MAGMA_RESP_SUBMIT_COMMAND_BUFFER,
-    VIRTIO_MAGMA_RESP_EXECUTE_IMMEDIATE_COMMANDS,
-    VIRTIO_MAGMA_RESP_CREATE_SEMAPHORE,
-    VIRTIO_MAGMA_RESP_RELEASE_SEMAPHORE,
-    VIRTIO_MAGMA_RESP_GET_SEMAPHORE_ID,
-    VIRTIO_MAGMA_RESP_SIGNAL_SEMAPHORE,
-    VIRTIO_MAGMA_RESP_RESET_SEMAPHORE,
-    VIRTIO_MAGMA_RESP_WAIT_SEMAPHORES,
-    VIRTIO_MAGMA_RESP_EXPORT_SEMAPHORE,
-    VIRTIO_MAGMA_RESP_IMPORT_SEMAPHORE,
-    VIRTIO_MAGMA_RESP_READ_NOTIFICATION_CHANNEL,
-    /* magma error responses */
-    VIRTIO_MAGMA_RESP_ERR_UNIMPLEMENTED = 0x1280,
-    VIRTIO_MAGMA_RESP_ERR_INTERNAL,
-    VIRTIO_MAGMA_RESP_ERR_HOST_DISCONNECTED,
-    VIRTIO_MAGMA_RESP_ERR_OUT_OF_MEMORY,
-    VIRTIO_MAGMA_RESP_ERR_INVALID_COMMAND,
-    VIRTIO_MAGMA_RESP_ERR_INVALID_ARGUMENT,
-};
+	/* magma commands */
+	VIRTIO_MAGMA_CMD_QUERY = 0x0400,
+	VIRTIO_MAGMA_CMD_CREATE_CONNECTION,
+	VIRTIO_MAGMA_CMD_RELEASE_CONNECTION,
+	VIRTIO_MAGMA_CMD_GET_ERROR,
+	VIRTIO_MAGMA_CMD_CREATE_CONTEXT,
+	VIRTIO_MAGMA_CMD_RELEASE_CONTEXT,
+	VIRTIO_MAGMA_CMD_CREATE_BUFFER,
+	VIRTIO_MAGMA_CMD_RELEASE_BUFFER,
+	VIRTIO_MAGMA_CMD_DUPLICATE_HANDLE,
+	VIRTIO_MAGMA_CMD_RELEASE_BUFFER_HANDLE,
+	VIRTIO_MAGMA_CMD_GET_BUFFER_ID,
+	VIRTIO_MAGMA_CMD_GET_BUFFER_SIZE,
+	VIRTIO_MAGMA_CMD_CLEAN_CACHE,
+	VIRTIO_MAGMA_CMD_SET_CACHE_POLICY,
+	VIRTIO_MAGMA_CMD_GET_BUFFER_CACHE_POLICY,
+	VIRTIO_MAGMA_CMD_GET_BUFFER_IS_MAPPABLE,
+	VIRTIO_MAGMA_CMD_SET_BUFFER_MAPPING_ADDRESS_RANGE,
+	VIRTIO_MAGMA_CMD_MAP,
+	VIRTIO_MAGMA_CMD_MAP_ALIGNED,
+	VIRTIO_MAGMA_CMD_MAP_SPECIFIC,
+	VIRTIO_MAGMA_CMD_UNMAP,
+	VIRTIO_MAGMA_CMD_MAP_BUFFER_GPU,
+	VIRTIO_MAGMA_CMD_UNMAP_BUFFER_GPU,
+	VIRTIO_MAGMA_CMD_COMMIT_BUFFER,
+	VIRTIO_MAGMA_CMD_EXPORT,
+	VIRTIO_MAGMA_CMD_IMPORT,
+	VIRTIO_MAGMA_CMD_CREATE_COMMAND_BUFFER,
+	VIRTIO_MAGMA_CMD_RELEASE_COMMAND_BUFFER,
+	VIRTIO_MAGMA_CMD_SUBMIT_COMMAND_BUFFER,
+	VIRTIO_MAGMA_CMD_EXECUTE_IMMEDIATE_COMMANDS,
+	VIRTIO_MAGMA_CMD_EXECUTE_IMMEDIATE_COMMANDS2,
+	VIRTIO_MAGMA_CMD_CREATE_SEMAPHORE,
+	VIRTIO_MAGMA_CMD_RELEASE_SEMAPHORE,
+	VIRTIO_MAGMA_CMD_GET_SEMAPHORE_ID,
+	VIRTIO_MAGMA_CMD_SIGNAL_SEMAPHORE,
+	VIRTIO_MAGMA_CMD_RESET_SEMAPHORE,
+	VIRTIO_MAGMA_CMD_WAIT_SEMAPHORES,
+	VIRTIO_MAGMA_CMD_EXPORT_SEMAPHORE,
+	VIRTIO_MAGMA_CMD_IMPORT_SEMAPHORE,
+	VIRTIO_MAGMA_CMD_GET_NOTIFICATION_CHANNEL_HANDLE,
+	VIRTIO_MAGMA_CMD_WAIT_NOTIFICATION_CHANNEL,
+	VIRTIO_MAGMA_CMD_READ_NOTIFICATION_CHANNEL,
+	/* magma success responses */
+	VIRTIO_MAGMA_RESP_QUERY = 0x1180,
+	VIRTIO_MAGMA_RESP_CREATE_CONNECTION,
+	VIRTIO_MAGMA_RESP_RELEASE_CONNECTION,
+	VIRTIO_MAGMA_RESP_GET_ERROR,
+	VIRTIO_MAGMA_RESP_CREATE_CONTEXT,
+	VIRTIO_MAGMA_RESP_RELEASE_CONTEXT,
+	VIRTIO_MAGMA_RESP_CREATE_BUFFER,
+	VIRTIO_MAGMA_RESP_RELEASE_BUFFER,
+	VIRTIO_MAGMA_RESP_DUPLICATE_HANDLE,
+	VIRTIO_MAGMA_RESP_RELEASE_BUFFER_HANDLE,
+	VIRTIO_MAGMA_RESP_GET_BUFFER_ID,
+	VIRTIO_MAGMA_RESP_GET_BUFFER_SIZE,
+	VIRTIO_MAGMA_RESP_CLEAN_CACHE,
+	VIRTIO_MAGMA_RESP_SET_CACHE_POLICY,
+	VIRTIO_MAGMA_RESP_GET_BUFFER_CACHE_POLICY,
+	VIRTIO_MAGMA_RESP_GET_BUFFER_IS_MAPPABLE,
+	VIRTIO_MAGMA_RESP_SET_BUFFER_MAPPING_ADDRESS_RANGE,
+	VIRTIO_MAGMA_RESP_MAP,
+	VIRTIO_MAGMA_RESP_MAP_ALIGNED,
+	VIRTIO_MAGMA_RESP_MAP_SPECIFIC,
+	VIRTIO_MAGMA_RESP_UNMAP,
+	VIRTIO_MAGMA_RESP_MAP_BUFFER_GPU,
+	VIRTIO_MAGMA_RESP_UNMAP_BUFFER_GPU,
+	VIRTIO_MAGMA_RESP_COMMIT_BUFFER,
+	VIRTIO_MAGMA_RESP_EXPORT,
+	VIRTIO_MAGMA_RESP_IMPORT,
+	VIRTIO_MAGMA_RESP_CREATE_COMMAND_BUFFER,
+	VIRTIO_MAGMA_RESP_RELEASE_COMMAND_BUFFER,
+	VIRTIO_MAGMA_RESP_SUBMIT_COMMAND_BUFFER,
+	VIRTIO_MAGMA_RESP_EXECUTE_IMMEDIATE_COMMANDS,
+	VIRTIO_MAGMA_RESP_EXECUTE_IMMEDIATE_COMMANDS2,
+	VIRTIO_MAGMA_RESP_CREATE_SEMAPHORE,
+	VIRTIO_MAGMA_RESP_RELEASE_SEMAPHORE,
+	VIRTIO_MAGMA_RESP_GET_SEMAPHORE_ID,
+	VIRTIO_MAGMA_RESP_SIGNAL_SEMAPHORE,
+	VIRTIO_MAGMA_RESP_RESET_SEMAPHORE,
+	VIRTIO_MAGMA_RESP_WAIT_SEMAPHORES,
+	VIRTIO_MAGMA_RESP_EXPORT_SEMAPHORE,
+	VIRTIO_MAGMA_RESP_IMPORT_SEMAPHORE,
+	VIRTIO_MAGMA_RESP_GET_NOTIFICATION_CHANNEL_HANDLE,
+	VIRTIO_MAGMA_RESP_WAIT_NOTIFICATION_CHANNEL,
+	VIRTIO_MAGMA_RESP_READ_NOTIFICATION_CHANNEL,
+	/* magma error responses */
+	VIRTIO_MAGMA_RESP_ERR_UNIMPLEMENTED = 0x1280,
+	VIRTIO_MAGMA_RESP_ERR_INTERNAL,
+	VIRTIO_MAGMA_RESP_ERR_HOST_DISCONNECTED,
+	VIRTIO_MAGMA_RESP_ERR_OUT_OF_MEMORY,
+	VIRTIO_MAGMA_RESP_ERR_INVALID_COMMAND,
+	VIRTIO_MAGMA_RESP_ERR_INVALID_ARGUMENT,
+} __attribute((packed));
+
+inline const char* virtio_magma_ctrl_type_string(enum virtio_magma_ctrl_type type) {
+	switch (type) {
+		case VIRTIO_MAGMA_CMD_QUERY: return "VIRTIO_MAGMA_CMD_QUERY";
+		case VIRTIO_MAGMA_RESP_QUERY: return "VIRTIO_MAGMA_RESP_QUERY";
+		case VIRTIO_MAGMA_CMD_CREATE_CONNECTION: return "VIRTIO_MAGMA_CMD_CREATE_CONNECTION";
+		case VIRTIO_MAGMA_RESP_CREATE_CONNECTION: return "VIRTIO_MAGMA_RESP_CREATE_CONNECTION";
+		case VIRTIO_MAGMA_CMD_RELEASE_CONNECTION: return "VIRTIO_MAGMA_CMD_RELEASE_CONNECTION";
+		case VIRTIO_MAGMA_RESP_RELEASE_CONNECTION: return "VIRTIO_MAGMA_RESP_RELEASE_CONNECTION";
+		case VIRTIO_MAGMA_CMD_GET_ERROR: return "VIRTIO_MAGMA_CMD_GET_ERROR";
+		case VIRTIO_MAGMA_RESP_GET_ERROR: return "VIRTIO_MAGMA_RESP_GET_ERROR";
+		case VIRTIO_MAGMA_CMD_CREATE_CONTEXT: return "VIRTIO_MAGMA_CMD_CREATE_CONTEXT";
+		case VIRTIO_MAGMA_RESP_CREATE_CONTEXT: return "VIRTIO_MAGMA_RESP_CREATE_CONTEXT";
+		case VIRTIO_MAGMA_CMD_RELEASE_CONTEXT: return "VIRTIO_MAGMA_CMD_RELEASE_CONTEXT";
+		case VIRTIO_MAGMA_RESP_RELEASE_CONTEXT: return "VIRTIO_MAGMA_RESP_RELEASE_CONTEXT";
+		case VIRTIO_MAGMA_CMD_CREATE_BUFFER: return "VIRTIO_MAGMA_CMD_CREATE_BUFFER";
+		case VIRTIO_MAGMA_RESP_CREATE_BUFFER: return "VIRTIO_MAGMA_RESP_CREATE_BUFFER";
+		case VIRTIO_MAGMA_CMD_RELEASE_BUFFER: return "VIRTIO_MAGMA_CMD_RELEASE_BUFFER";
+		case VIRTIO_MAGMA_RESP_RELEASE_BUFFER: return "VIRTIO_MAGMA_RESP_RELEASE_BUFFER";
+		case VIRTIO_MAGMA_CMD_DUPLICATE_HANDLE: return "VIRTIO_MAGMA_CMD_DUPLICATE_HANDLE";
+		case VIRTIO_MAGMA_RESP_DUPLICATE_HANDLE: return "VIRTIO_MAGMA_RESP_DUPLICATE_HANDLE";
+		case VIRTIO_MAGMA_CMD_RELEASE_BUFFER_HANDLE: return "VIRTIO_MAGMA_CMD_RELEASE_BUFFER_HANDLE";
+		case VIRTIO_MAGMA_RESP_RELEASE_BUFFER_HANDLE: return "VIRTIO_MAGMA_RESP_RELEASE_BUFFER_HANDLE";
+		case VIRTIO_MAGMA_CMD_GET_BUFFER_ID: return "VIRTIO_MAGMA_CMD_GET_BUFFER_ID";
+		case VIRTIO_MAGMA_RESP_GET_BUFFER_ID: return "VIRTIO_MAGMA_RESP_GET_BUFFER_ID";
+		case VIRTIO_MAGMA_CMD_GET_BUFFER_SIZE: return "VIRTIO_MAGMA_CMD_GET_BUFFER_SIZE";
+		case VIRTIO_MAGMA_RESP_GET_BUFFER_SIZE: return "VIRTIO_MAGMA_RESP_GET_BUFFER_SIZE";
+		case VIRTIO_MAGMA_CMD_CLEAN_CACHE: return "VIRTIO_MAGMA_CMD_CLEAN_CACHE";
+		case VIRTIO_MAGMA_RESP_CLEAN_CACHE: return "VIRTIO_MAGMA_RESP_CLEAN_CACHE";
+		case VIRTIO_MAGMA_CMD_SET_CACHE_POLICY: return "VIRTIO_MAGMA_CMD_SET_CACHE_POLICY";
+		case VIRTIO_MAGMA_RESP_SET_CACHE_POLICY: return "VIRTIO_MAGMA_RESP_SET_CACHE_POLICY";
+		case VIRTIO_MAGMA_CMD_GET_BUFFER_CACHE_POLICY: return "VIRTIO_MAGMA_CMD_GET_BUFFER_CACHE_POLICY";
+		case VIRTIO_MAGMA_RESP_GET_BUFFER_CACHE_POLICY: return "VIRTIO_MAGMA_RESP_GET_BUFFER_CACHE_POLICY";
+		case VIRTIO_MAGMA_CMD_GET_BUFFER_IS_MAPPABLE: return "VIRTIO_MAGMA_CMD_GET_BUFFER_IS_MAPPABLE";
+		case VIRTIO_MAGMA_RESP_GET_BUFFER_IS_MAPPABLE: return "VIRTIO_MAGMA_RESP_GET_BUFFER_IS_MAPPABLE";
+		case VIRTIO_MAGMA_CMD_SET_BUFFER_MAPPING_ADDRESS_RANGE: return "VIRTIO_MAGMA_CMD_SET_BUFFER_MAPPING_ADDRESS_RANGE";
+		case VIRTIO_MAGMA_RESP_SET_BUFFER_MAPPING_ADDRESS_RANGE: return "VIRTIO_MAGMA_RESP_SET_BUFFER_MAPPING_ADDRESS_RANGE";
+		case VIRTIO_MAGMA_CMD_MAP: return "VIRTIO_MAGMA_CMD_MAP";
+		case VIRTIO_MAGMA_RESP_MAP: return "VIRTIO_MAGMA_RESP_MAP";
+		case VIRTIO_MAGMA_CMD_MAP_ALIGNED: return "VIRTIO_MAGMA_CMD_MAP_ALIGNED";
+		case VIRTIO_MAGMA_RESP_MAP_ALIGNED: return "VIRTIO_MAGMA_RESP_MAP_ALIGNED";
+		case VIRTIO_MAGMA_CMD_MAP_SPECIFIC: return "VIRTIO_MAGMA_CMD_MAP_SPECIFIC";
+		case VIRTIO_MAGMA_RESP_MAP_SPECIFIC: return "VIRTIO_MAGMA_RESP_MAP_SPECIFIC";
+		case VIRTIO_MAGMA_CMD_UNMAP: return "VIRTIO_MAGMA_CMD_UNMAP";
+		case VIRTIO_MAGMA_RESP_UNMAP: return "VIRTIO_MAGMA_RESP_UNMAP";
+		case VIRTIO_MAGMA_CMD_MAP_BUFFER_GPU: return "VIRTIO_MAGMA_CMD_MAP_BUFFER_GPU";
+		case VIRTIO_MAGMA_RESP_MAP_BUFFER_GPU: return "VIRTIO_MAGMA_RESP_MAP_BUFFER_GPU";
+		case VIRTIO_MAGMA_CMD_UNMAP_BUFFER_GPU: return "VIRTIO_MAGMA_CMD_UNMAP_BUFFER_GPU";
+		case VIRTIO_MAGMA_RESP_UNMAP_BUFFER_GPU: return "VIRTIO_MAGMA_RESP_UNMAP_BUFFER_GPU";
+		case VIRTIO_MAGMA_CMD_COMMIT_BUFFER: return "VIRTIO_MAGMA_CMD_COMMIT_BUFFER";
+		case VIRTIO_MAGMA_RESP_COMMIT_BUFFER: return "VIRTIO_MAGMA_RESP_COMMIT_BUFFER";
+		case VIRTIO_MAGMA_CMD_EXPORT: return "VIRTIO_MAGMA_CMD_EXPORT";
+		case VIRTIO_MAGMA_RESP_EXPORT: return "VIRTIO_MAGMA_RESP_EXPORT";
+		case VIRTIO_MAGMA_CMD_IMPORT: return "VIRTIO_MAGMA_CMD_IMPORT";
+		case VIRTIO_MAGMA_RESP_IMPORT: return "VIRTIO_MAGMA_RESP_IMPORT";
+		case VIRTIO_MAGMA_CMD_CREATE_COMMAND_BUFFER: return "VIRTIO_MAGMA_CMD_CREATE_COMMAND_BUFFER";
+		case VIRTIO_MAGMA_RESP_CREATE_COMMAND_BUFFER: return "VIRTIO_MAGMA_RESP_CREATE_COMMAND_BUFFER";
+		case VIRTIO_MAGMA_CMD_RELEASE_COMMAND_BUFFER: return "VIRTIO_MAGMA_CMD_RELEASE_COMMAND_BUFFER";
+		case VIRTIO_MAGMA_RESP_RELEASE_COMMAND_BUFFER: return "VIRTIO_MAGMA_RESP_RELEASE_COMMAND_BUFFER";
+		case VIRTIO_MAGMA_CMD_SUBMIT_COMMAND_BUFFER: return "VIRTIO_MAGMA_CMD_SUBMIT_COMMAND_BUFFER";
+		case VIRTIO_MAGMA_RESP_SUBMIT_COMMAND_BUFFER: return "VIRTIO_MAGMA_RESP_SUBMIT_COMMAND_BUFFER";
+		case VIRTIO_MAGMA_CMD_EXECUTE_IMMEDIATE_COMMANDS: return "VIRTIO_MAGMA_CMD_EXECUTE_IMMEDIATE_COMMANDS";
+		case VIRTIO_MAGMA_RESP_EXECUTE_IMMEDIATE_COMMANDS: return "VIRTIO_MAGMA_RESP_EXECUTE_IMMEDIATE_COMMANDS";
+		case VIRTIO_MAGMA_CMD_EXECUTE_IMMEDIATE_COMMANDS2: return "VIRTIO_MAGMA_CMD_EXECUTE_IMMEDIATE_COMMANDS2";
+		case VIRTIO_MAGMA_RESP_EXECUTE_IMMEDIATE_COMMANDS2: return "VIRTIO_MAGMA_RESP_EXECUTE_IMMEDIATE_COMMANDS2";
+		case VIRTIO_MAGMA_CMD_CREATE_SEMAPHORE: return "VIRTIO_MAGMA_CMD_CREATE_SEMAPHORE";
+		case VIRTIO_MAGMA_RESP_CREATE_SEMAPHORE: return "VIRTIO_MAGMA_RESP_CREATE_SEMAPHORE";
+		case VIRTIO_MAGMA_CMD_RELEASE_SEMAPHORE: return "VIRTIO_MAGMA_CMD_RELEASE_SEMAPHORE";
+		case VIRTIO_MAGMA_RESP_RELEASE_SEMAPHORE: return "VIRTIO_MAGMA_RESP_RELEASE_SEMAPHORE";
+		case VIRTIO_MAGMA_CMD_GET_SEMAPHORE_ID: return "VIRTIO_MAGMA_CMD_GET_SEMAPHORE_ID";
+		case VIRTIO_MAGMA_RESP_GET_SEMAPHORE_ID: return "VIRTIO_MAGMA_RESP_GET_SEMAPHORE_ID";
+		case VIRTIO_MAGMA_CMD_SIGNAL_SEMAPHORE: return "VIRTIO_MAGMA_CMD_SIGNAL_SEMAPHORE";
+		case VIRTIO_MAGMA_RESP_SIGNAL_SEMAPHORE: return "VIRTIO_MAGMA_RESP_SIGNAL_SEMAPHORE";
+		case VIRTIO_MAGMA_CMD_RESET_SEMAPHORE: return "VIRTIO_MAGMA_CMD_RESET_SEMAPHORE";
+		case VIRTIO_MAGMA_RESP_RESET_SEMAPHORE: return "VIRTIO_MAGMA_RESP_RESET_SEMAPHORE";
+		case VIRTIO_MAGMA_CMD_WAIT_SEMAPHORES: return "VIRTIO_MAGMA_CMD_WAIT_SEMAPHORES";
+		case VIRTIO_MAGMA_RESP_WAIT_SEMAPHORES: return "VIRTIO_MAGMA_RESP_WAIT_SEMAPHORES";
+		case VIRTIO_MAGMA_CMD_EXPORT_SEMAPHORE: return "VIRTIO_MAGMA_CMD_EXPORT_SEMAPHORE";
+		case VIRTIO_MAGMA_RESP_EXPORT_SEMAPHORE: return "VIRTIO_MAGMA_RESP_EXPORT_SEMAPHORE";
+		case VIRTIO_MAGMA_CMD_IMPORT_SEMAPHORE: return "VIRTIO_MAGMA_CMD_IMPORT_SEMAPHORE";
+		case VIRTIO_MAGMA_RESP_IMPORT_SEMAPHORE: return "VIRTIO_MAGMA_RESP_IMPORT_SEMAPHORE";
+		case VIRTIO_MAGMA_CMD_GET_NOTIFICATION_CHANNEL_HANDLE: return "VIRTIO_MAGMA_CMD_GET_NOTIFICATION_CHANNEL_HANDLE";
+		case VIRTIO_MAGMA_RESP_GET_NOTIFICATION_CHANNEL_HANDLE: return "VIRTIO_MAGMA_RESP_GET_NOTIFICATION_CHANNEL_HANDLE";
+		case VIRTIO_MAGMA_CMD_WAIT_NOTIFICATION_CHANNEL: return "VIRTIO_MAGMA_CMD_WAIT_NOTIFICATION_CHANNEL";
+		case VIRTIO_MAGMA_RESP_WAIT_NOTIFICATION_CHANNEL: return "VIRTIO_MAGMA_RESP_WAIT_NOTIFICATION_CHANNEL";
+		case VIRTIO_MAGMA_CMD_READ_NOTIFICATION_CHANNEL: return "VIRTIO_MAGMA_CMD_READ_NOTIFICATION_CHANNEL";
+		case VIRTIO_MAGMA_RESP_READ_NOTIFICATION_CHANNEL: return "VIRTIO_MAGMA_RESP_READ_NOTIFICATION_CHANNEL";
+		case VIRTIO_MAGMA_RESP_ERR_INTERNAL: return "VIRTIO_MAGMA_RESP_ERR_INTERNAL";
+		case VIRTIO_MAGMA_RESP_ERR_HOST_DISCONNECTED: return "VIRTIO_MAGMA_RESP_ERR_HOST_DISCONNECTED";
+		case VIRTIO_MAGMA_RESP_ERR_OUT_OF_MEMORY: return "VIRTIO_MAGMA_RESP_ERR_OUT_OF_MEMORY";
+		case VIRTIO_MAGMA_RESP_ERR_INVALID_COMMAND: return "VIRTIO_MAGMA_RESP_ERR_INVALID_COMMAND";
+		case VIRTIO_MAGMA_RESP_ERR_INVALID_ARGUMENT: return "VIRTIO_MAGMA_RESP_ERR_INVALID_ARGUMENT";
+		default: return "[invalid virtio_magma_ctrl_type]";
+	}
+}
+
+inline enum virtio_magma_ctrl_type virtio_magma_expected_response_type(enum virtio_magma_ctrl_type type) {
+	switch (type) {
+		case VIRTIO_MAGMA_CMD_QUERY: return VIRTIO_MAGMA_RESP_QUERY;
+		case VIRTIO_MAGMA_CMD_CREATE_CONNECTION: return VIRTIO_MAGMA_RESP_CREATE_CONNECTION;
+		case VIRTIO_MAGMA_CMD_RELEASE_CONNECTION: return VIRTIO_MAGMA_RESP_RELEASE_CONNECTION;
+		case VIRTIO_MAGMA_CMD_GET_ERROR: return VIRTIO_MAGMA_RESP_GET_ERROR;
+		case VIRTIO_MAGMA_CMD_CREATE_CONTEXT: return VIRTIO_MAGMA_RESP_CREATE_CONTEXT;
+		case VIRTIO_MAGMA_CMD_RELEASE_CONTEXT: return VIRTIO_MAGMA_RESP_RELEASE_CONTEXT;
+		case VIRTIO_MAGMA_CMD_CREATE_BUFFER: return VIRTIO_MAGMA_RESP_CREATE_BUFFER;
+		case VIRTIO_MAGMA_CMD_RELEASE_BUFFER: return VIRTIO_MAGMA_RESP_RELEASE_BUFFER;
+		case VIRTIO_MAGMA_CMD_DUPLICATE_HANDLE: return VIRTIO_MAGMA_RESP_DUPLICATE_HANDLE;
+		case VIRTIO_MAGMA_CMD_RELEASE_BUFFER_HANDLE: return VIRTIO_MAGMA_RESP_RELEASE_BUFFER_HANDLE;
+		case VIRTIO_MAGMA_CMD_GET_BUFFER_ID: return VIRTIO_MAGMA_RESP_GET_BUFFER_ID;
+		case VIRTIO_MAGMA_CMD_GET_BUFFER_SIZE: return VIRTIO_MAGMA_RESP_GET_BUFFER_SIZE;
+		case VIRTIO_MAGMA_CMD_CLEAN_CACHE: return VIRTIO_MAGMA_RESP_CLEAN_CACHE;
+		case VIRTIO_MAGMA_CMD_SET_CACHE_POLICY: return VIRTIO_MAGMA_RESP_SET_CACHE_POLICY;
+		case VIRTIO_MAGMA_CMD_GET_BUFFER_CACHE_POLICY: return VIRTIO_MAGMA_RESP_GET_BUFFER_CACHE_POLICY;
+		case VIRTIO_MAGMA_CMD_GET_BUFFER_IS_MAPPABLE: return VIRTIO_MAGMA_RESP_GET_BUFFER_IS_MAPPABLE;
+		case VIRTIO_MAGMA_CMD_SET_BUFFER_MAPPING_ADDRESS_RANGE: return VIRTIO_MAGMA_RESP_SET_BUFFER_MAPPING_ADDRESS_RANGE;
+		case VIRTIO_MAGMA_CMD_MAP: return VIRTIO_MAGMA_RESP_MAP;
+		case VIRTIO_MAGMA_CMD_MAP_ALIGNED: return VIRTIO_MAGMA_RESP_MAP_ALIGNED;
+		case VIRTIO_MAGMA_CMD_MAP_SPECIFIC: return VIRTIO_MAGMA_RESP_MAP_SPECIFIC;
+		case VIRTIO_MAGMA_CMD_UNMAP: return VIRTIO_MAGMA_RESP_UNMAP;
+		case VIRTIO_MAGMA_CMD_MAP_BUFFER_GPU: return VIRTIO_MAGMA_RESP_MAP_BUFFER_GPU;
+		case VIRTIO_MAGMA_CMD_UNMAP_BUFFER_GPU: return VIRTIO_MAGMA_RESP_UNMAP_BUFFER_GPU;
+		case VIRTIO_MAGMA_CMD_COMMIT_BUFFER: return VIRTIO_MAGMA_RESP_COMMIT_BUFFER;
+		case VIRTIO_MAGMA_CMD_EXPORT: return VIRTIO_MAGMA_RESP_EXPORT;
+		case VIRTIO_MAGMA_CMD_IMPORT: return VIRTIO_MAGMA_RESP_IMPORT;
+		case VIRTIO_MAGMA_CMD_CREATE_COMMAND_BUFFER: return VIRTIO_MAGMA_RESP_CREATE_COMMAND_BUFFER;
+		case VIRTIO_MAGMA_CMD_RELEASE_COMMAND_BUFFER: return VIRTIO_MAGMA_RESP_RELEASE_COMMAND_BUFFER;
+		case VIRTIO_MAGMA_CMD_SUBMIT_COMMAND_BUFFER: return VIRTIO_MAGMA_RESP_SUBMIT_COMMAND_BUFFER;
+		case VIRTIO_MAGMA_CMD_EXECUTE_IMMEDIATE_COMMANDS: return VIRTIO_MAGMA_RESP_EXECUTE_IMMEDIATE_COMMANDS;
+		case VIRTIO_MAGMA_CMD_EXECUTE_IMMEDIATE_COMMANDS2: return VIRTIO_MAGMA_RESP_EXECUTE_IMMEDIATE_COMMANDS2;
+		case VIRTIO_MAGMA_CMD_CREATE_SEMAPHORE: return VIRTIO_MAGMA_RESP_CREATE_SEMAPHORE;
+		case VIRTIO_MAGMA_CMD_RELEASE_SEMAPHORE: return VIRTIO_MAGMA_RESP_RELEASE_SEMAPHORE;
+		case VIRTIO_MAGMA_CMD_GET_SEMAPHORE_ID: return VIRTIO_MAGMA_RESP_GET_SEMAPHORE_ID;
+		case VIRTIO_MAGMA_CMD_SIGNAL_SEMAPHORE: return VIRTIO_MAGMA_RESP_SIGNAL_SEMAPHORE;
+		case VIRTIO_MAGMA_CMD_RESET_SEMAPHORE: return VIRTIO_MAGMA_RESP_RESET_SEMAPHORE;
+		case VIRTIO_MAGMA_CMD_WAIT_SEMAPHORES: return VIRTIO_MAGMA_RESP_WAIT_SEMAPHORES;
+		case VIRTIO_MAGMA_CMD_EXPORT_SEMAPHORE: return VIRTIO_MAGMA_RESP_EXPORT_SEMAPHORE;
+		case VIRTIO_MAGMA_CMD_IMPORT_SEMAPHORE: return VIRTIO_MAGMA_RESP_IMPORT_SEMAPHORE;
+		case VIRTIO_MAGMA_CMD_GET_NOTIFICATION_CHANNEL_HANDLE: return VIRTIO_MAGMA_RESP_GET_NOTIFICATION_CHANNEL_HANDLE;
+		case VIRTIO_MAGMA_CMD_WAIT_NOTIFICATION_CHANNEL: return VIRTIO_MAGMA_RESP_WAIT_NOTIFICATION_CHANNEL;
+		case VIRTIO_MAGMA_CMD_READ_NOTIFICATION_CHANNEL: return VIRTIO_MAGMA_RESP_READ_NOTIFICATION_CHANNEL;
+		default: return VIRTIO_MAGMA_RESP_ERR_INVALID_COMMAND;
+	}
+}
 
 struct virtio_magma_ctrl_hdr {
-    __le32 type;
-    __le32 flags;
-};
+	__le32 type;
+	__le32 flags;
+} __attribute((packed));
 
-struct virtio_magma_get_driver {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le32 page_size;
-};
-
-struct virtio_magma_get_driver_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 pfn;
-    __le64 size;
-};
-
-struct virtio_magma_query {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 field_id;
-};
+struct virtio_magma_query_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le32 file_descriptor;
+	__le64 id;
+} __attribute((packed));
 
 struct virtio_magma_query_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 field_value_out;
-    __le32 status_return;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 value_out;
+	__le64 result_return;
+} __attribute((packed));
 
-struct virtio_magma_create_connection {
-    struct virtio_magma_ctrl_hdr hdr;
-};
+struct virtio_magma_create_connection_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le32 file_descriptor;
+} __attribute((packed));
 
 struct virtio_magma_create_connection_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection_return;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection_out;
+	__le64 result_return;
+} __attribute((packed));
 
-struct virtio_magma_release_connection {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-};
+struct virtio_magma_release_connection_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+} __attribute((packed));
 
 struct virtio_magma_release_connection_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+} __attribute((packed));
 
-struct virtio_magma_get_error {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-};
+struct virtio_magma_get_error_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+} __attribute((packed));
 
 struct virtio_magma_get_error_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le32 status_return;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 result_return;
+} __attribute((packed));
 
-struct virtio_magma_create_context {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-};
+struct virtio_magma_create_context_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+} __attribute((packed));
 
 struct virtio_magma_create_context_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le32 context_id_out;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 context_id_out;
+} __attribute((packed));
 
-struct virtio_magma_release_context {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-    __le32 context_id;
-};
+struct virtio_magma_release_context_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le32 context_id;
+} __attribute((packed));
 
 struct virtio_magma_release_context_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+} __attribute((packed));
 
-struct virtio_magma_create_buffer {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-    __le64 size;
-};
+struct virtio_magma_create_buffer_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le64 size;
+} __attribute((packed));
 
 struct virtio_magma_create_buffer_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 size_out;
-    __le64 buffer_out;
-    __le32 status_return;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 size_out;
+	__le64 buffer_out;
+	__le64 result_return;
+} __attribute((packed));
 
-struct virtio_magma_release_buffer {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-    __le64 buffer;
-};
+struct virtio_magma_release_buffer_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le64 buffer;
+} __attribute((packed));
 
 struct virtio_magma_release_buffer_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+} __attribute((packed));
 
-struct virtio_magma_get_buffer_id {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 buffer;
-};
+struct virtio_magma_duplicate_handle_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le32 buffer_handle;
+} __attribute((packed));
+
+struct virtio_magma_duplicate_handle_resp {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 buffer_handle_out;
+	__le64 result_return;
+} __attribute((packed));
+
+struct virtio_magma_release_buffer_handle_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le32 buffer_handle;
+} __attribute((packed));
+
+struct virtio_magma_release_buffer_handle_resp {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 result_return;
+} __attribute((packed));
+
+struct virtio_magma_get_buffer_id_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 buffer;
+} __attribute((packed));
 
 struct virtio_magma_get_buffer_id_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 id_return;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 result_return;
+} __attribute((packed));
 
-struct virtio_magma_get_buffer_size {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 buffer;
-};
+struct virtio_magma_get_buffer_size_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 buffer;
+} __attribute((packed));
 
 struct virtio_magma_get_buffer_size_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 size_return;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 result_return;
+} __attribute((packed));
 
-struct virtio_magma_clean_cache {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 buffer;
-    __le64 offset;
-    __le64 size;
-    __le32 operation;
-};
+struct virtio_magma_clean_cache_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 buffer;
+	__le64 offset;
+	__le64 size;
+	__le64 operation;
+} __attribute((packed));
 
 struct virtio_magma_clean_cache_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le32 status_return;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 result_return;
+} __attribute((packed));
 
-struct virtio_magma_set_cache_policy {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 buffer;
-    __le32 policy;
-};
+struct virtio_magma_set_cache_policy_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 buffer;
+	__le64 policy;
+} __attribute((packed));
 
 struct virtio_magma_set_cache_policy_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le32 status_return;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 result_return;
+} __attribute((packed));
 
-struct virtio_magma_map {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-    __le64 buffer;
-};
+struct virtio_magma_get_buffer_cache_policy_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 buffer;
+} __attribute((packed));
+
+struct virtio_magma_get_buffer_cache_policy_resp {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 cache_policy_out;
+	__le64 result_return;
+} __attribute((packed));
+
+struct virtio_magma_get_buffer_is_mappable_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 buffer;
+	__le32 flags;
+} __attribute((packed));
+
+struct virtio_magma_get_buffer_is_mappable_resp {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 is_mappable_out;
+	__le64 result_return;
+} __attribute((packed));
+
+struct virtio_magma_set_buffer_mapping_address_range_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 buffer;
+	__le32 handle;
+} __attribute((packed));
+
+struct virtio_magma_set_buffer_mapping_address_range_resp {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 result_return;
+} __attribute((packed));
+
+struct virtio_magma_map_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le64 buffer;
+} __attribute((packed));
 
 struct virtio_magma_map_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 addr_out;
-    __le32 status_return;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 addr_out;
+	__le64 result_return;
+} __attribute((packed));
 
-struct virtio_magma_map_aligned {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-    __le64 buffer;
-    __le64 alignment;
-};
+struct virtio_magma_map_aligned_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le64 buffer;
+	__le64 alignment;
+} __attribute((packed));
 
 struct virtio_magma_map_aligned_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 addr_out;
-    __le32 status_return;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 addr_out;
+	__le64 result_return;
+} __attribute((packed));
 
-struct virtio_magma_map_specific {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-    __le64 buffer;
-    __le64 addr;
-};
+struct virtio_magma_map_specific_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le64 buffer;
+	__le64 addr;
+	__le64 offset;
+	__le64 length;
+} __attribute((packed));
 
 struct virtio_magma_map_specific_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le32 status_return;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 result_return;
+} __attribute((packed));
 
-struct virtio_magma_unmap {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-    __le64 buffer;
-};
+struct virtio_magma_unmap_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le64 buffer;
+} __attribute((packed));
 
 struct virtio_magma_unmap_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le32 status_return;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 result_return;
+} __attribute((packed));
 
-struct virtio_magma_map_buffer_gpu {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-    __le64 buffer;
-    __le64 page_offset;
-    __le64 page_count;
-    __le64 gpu_va;
-    __le64 map_flags;
-};
+struct virtio_magma_map_buffer_gpu_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le64 buffer;
+	__le64 page_offset;
+	__le64 page_count;
+	__le64 gpu_va;
+	__le64 map_flags;
+} __attribute((packed));
 
 struct virtio_magma_map_buffer_gpu_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+} __attribute((packed));
 
-struct virtio_magma_unmap_buffer_gpu {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-    __le64 buffer;
-    __le64 gpu_va;
-};
+struct virtio_magma_unmap_buffer_gpu_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le64 buffer;
+	__le64 gpu_va;
+} __attribute((packed));
 
 struct virtio_magma_unmap_buffer_gpu_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+} __attribute((packed));
 
-struct virtio_magma_commit_buffer {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-    __le64 buffer;
-    __le64 page_offset;
-    __le64 page_count;
-};
+struct virtio_magma_commit_buffer_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le64 buffer;
+	__le64 page_offset;
+	__le64 page_count;
+} __attribute((packed));
 
 struct virtio_magma_commit_buffer_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+} __attribute((packed));
 
-struct virtio_magma_export {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-    __le64 buffer;
-};
+struct virtio_magma_export_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le64 buffer;
+} __attribute((packed));
 
 struct virtio_magma_export_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le32 buffer_handle_out;
-    __le32 status_return;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 buffer_handle_out;
+	__le64 result_return;
+} __attribute((packed));
 
-struct virtio_magma_import {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-};
+struct virtio_magma_import_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le32 buffer_handle;
+} __attribute((packed));
 
 struct virtio_magma_import_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 buffer_out;
-    __le32 buffer_handle;
-    __le32 status_return;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 buffer_out;
+	__le64 result_return;
+} __attribute((packed));
 
-struct virtio_magma_create_command_buffer {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-    __le64 size;
-};
+struct virtio_magma_create_command_buffer_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le64 size;
+} __attribute((packed));
 
 struct virtio_magma_create_command_buffer_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 buffer_out;
-    __le32 status_return;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 buffer_out;
+	__le64 result_return;
+} __attribute((packed));
 
-struct virtio_magma_release_command_buffer {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-    __le64 command_buffer;
-};
+struct virtio_magma_release_command_buffer_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le64 command_buffer;
+} __attribute((packed));
 
 struct virtio_magma_release_command_buffer_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+} __attribute((packed));
 
-struct virtio_magma_submit_command_buffer {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-    __le64 command_buffer;
-    __le32 context_id;
-};
+struct virtio_magma_submit_command_buffer_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le64 command_buffer;
+	__le32 context_id;
+} __attribute((packed));
 
 struct virtio_magma_submit_command_buffer_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+} __attribute((packed));
 
-struct virtio_magma_execute_immediate_commands {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-    __le64 command_count;
-    __le64 commands; // magma_system_inline_command_buffer[command_count]
-    __le32 context_id;
-};
+struct virtio_magma_execute_immediate_commands_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le32 context_id;
+	__le64 command_count;
+	__le64 command_buffers;
+} __attribute((packed));
 
 struct virtio_magma_execute_immediate_commands_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+} __attribute((packed));
 
-struct virtio_magma_create_semaphore {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-};
+struct virtio_magma_execute_immediate_commands2_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le32 context_id;
+	__le64 command_count;
+	__le64 command_buffers;
+} __attribute((packed));
+
+struct virtio_magma_execute_immediate_commands2_resp {
+	struct virtio_magma_ctrl_hdr hdr;
+} __attribute((packed));
+
+struct virtio_magma_create_semaphore_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+} __attribute((packed));
 
 struct virtio_magma_create_semaphore_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 semaphore_out;
-    __le32 status_return;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 semaphore_out;
+	__le64 result_return;
+} __attribute((packed));
 
-struct virtio_magma_release_semaphore {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-    __le64 semaphore;
-};
+struct virtio_magma_release_semaphore_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le64 semaphore;
+} __attribute((packed));
 
 struct virtio_magma_release_semaphore_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+} __attribute((packed));
 
-struct virtio_magma_get_semaphore_id {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 semaphore;
-};
+struct virtio_magma_get_semaphore_id_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 semaphore;
+} __attribute((packed));
 
 struct virtio_magma_get_semaphore_id_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 id_return;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 result_return;
+} __attribute((packed));
 
-struct virtio_magma_signal_semaphore {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 semaphore;
-};
+struct virtio_magma_signal_semaphore_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 semaphore;
+} __attribute((packed));
 
 struct virtio_magma_signal_semaphore_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+} __attribute((packed));
 
-struct virtio_magma_reset_semaphore {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 semaphore;
-};
+struct virtio_magma_reset_semaphore_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 semaphore;
+} __attribute((packed));
 
 struct virtio_magma_reset_semaphore_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+} __attribute((packed));
 
-struct virtio_magma_wait_semaphores {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 timeout_ms;
-    __le64 semaphores; // magma_semaphore_t[count]
-    __le32 count;
-    __le32 status_return;
-    char wait_all;
-};
+struct virtio_magma_wait_semaphores_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 semaphores;
+	__le32 count;
+	__le64 timeout_ms;
+	u8 wait_all;
+} __attribute((packed));
 
 struct virtio_magma_wait_semaphores_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 result_return;
+} __attribute((packed));
 
-struct virtio_magma_export_semaphore {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 semaphore;
-    __le64 connection;
-};
+struct virtio_magma_export_semaphore_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le64 semaphore;
+} __attribute((packed));
 
 struct virtio_magma_export_semaphore_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le32 semaphore_handle_out;
-    __le32 status_return;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 semaphore_handle_out;
+	__le64 result_return;
+} __attribute((packed));
 
-struct virtio_magma_import_semaphore {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-    __le32 semaphore_handle;
-};
+struct virtio_magma_import_semaphore_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le32 semaphore_handle;
+} __attribute((packed));
 
 struct virtio_magma_import_semaphore_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 semaphore_out;
-    __le32 status_return;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 semaphore_out;
+	__le64 result_return;
+} __attribute((packed));
 
-struct virtio_magma_read_notification_channel {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 connection;
-    __le64 buffer;
-    __le64 buffer_size;
-};
+struct virtio_magma_get_notification_channel_handle_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+} __attribute((packed));
+
+struct virtio_magma_get_notification_channel_handle_resp {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le32 result_return;
+} __attribute((packed));
+
+struct virtio_magma_wait_notification_channel_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le64 timeout_ns;
+} __attribute((packed));
+
+struct virtio_magma_wait_notification_channel_resp {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 result_return;
+} __attribute((packed));
+
+struct virtio_magma_read_notification_channel_ctrl {
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 connection;
+	__le64 buffer;
+	__le64 buffer_size;
+} __attribute((packed));
 
 struct virtio_magma_read_notification_channel_resp {
-    struct virtio_magma_ctrl_hdr hdr;
-    __le64 buffer_size_out;
-    __le32 status_return;
-};
+	struct virtio_magma_ctrl_hdr hdr;
+	__le64 buffer_size_out;
+	__le64 result_return;
+} __attribute((packed));
 
-
-#endif // _LINUX_VIRTIO_MAGMA_H
+#endif /* _LINUX_VIRTIO_MAGMA_H */
diff --git a/include/uapi/linux/virtmagma.h b/include/uapi/linux/virtmagma.h
index 68737be7..5da7a3a 100644
--- a/include/uapi/linux/virtmagma.h
+++ b/include/uapi/linux/virtmagma.h
@@ -28,260 +28,19 @@
 	__u32 version_out;
 };
 
-struct virtmagma_ioctl_args_get_driver {
-	__s32 unused;
+struct virtmagma_ioctl_args_get_mmfd {
+	__s32 fd_out;
 };
 
-struct virtmagma_ioctl_args_query {
-	__u64 id;
-	__u64 value_out;
-	__u32 status_return;
-};
-
-struct virtmagma_ioctl_args_create_connection {
-	__s32 connection_return;
-};
-
-struct virtmagma_ioctl_args_release_connection {
-	__s32 connection;
-};
-
-struct virtmagma_ioctl_args_get_error {
-	__s32 connection;
-	__u32 status_return;
-};
-
-struct virtmagma_ioctl_args_create_context {
-	__s32 connection;
-	__u32 context_id_out;
-};
-
-struct virtmagma_ioctl_args_release_context {
-	__s32 connection;
-	__u32 context_id;
-};
-
-struct virtmagma_ioctl_args_create_buffer {
-	__u64 size;
-	__u64 size_out;
-	__u64 buffer_out;
-	__s32 connection;
-	__u32 status_return;
-};
-
-struct virtmagma_ioctl_args_release_buffer {
-	__u64 buffer;
-	__s32 connection;
-};
-
-struct virtmagma_ioctl_args_get_buffer_id {
-	__u64 buffer;
-	__u64 id_return;
-};
-
-struct virtmagma_ioctl_args_get_buffer_size {
-	__u64 buffer;
-	__u64 size_return;
-};
-
-struct virtmagma_ioctl_args_clean_cache {
-	__u64 buffer;
-	__u64 offset;
-	__u64 size;
-	__u32 operation;
-	__u32 status_return;
-};
-
-struct virtmagma_ioctl_args_set_cache_policy {
-	__u64 buffer;
-	__u32 policy;
-	__u32 status_return;
-};
-
-struct virtmagma_ioctl_args_map {
-	__u64 buffer;
-	__u64 addr_out;
-	__s32 connection;
-	__u32 status_return;
-};
-
-struct virtmagma_ioctl_args_map_aligned {
-	__u64 buffer;
-	__u64 alignment;
-	__u64 addr_out;
-	__s32 connection;
-	__u32 status_return;
-};
-
-struct virtmagma_ioctl_args_map_specific {
-	__u64 buffer;
-	__u64 addr;
-	__s32 connection;
-	__u32 status_return;
-};
-
-struct virtmagma_ioctl_args_unmap {
-	__u64 buffer;
-	__s32 connection;
-	__u32 status_return;
-};
-
-struct virtmagma_ioctl_args_map_buffer_gpu {
-	__u64 buffer;
-	__u64 page_offset;
-	__u64 page_count;
-	__u64 gpu_va;
-	__u64 map_flags;
-	__s32 connection;
-};
-
-struct virtmagma_ioctl_args_unmap_buffer_gpu {
-	__u64 buffer;
-	__u64 gpu_va;
-	__s32 connection;
-};
-
-struct virtmagma_ioctl_args_commit_buffer {
-	__u64 buffer;
-	__u64 page_offset;
-	__u64 page_count;
-	__s32 connection;
-};
-
-struct virtmagma_ioctl_args_export {
-	__u64 buffer;
-	__u32 buffer_handle_out;
-	__u32 status_return;
-	__s32 connection;
-};
-
-struct virtmagma_ioctl_args_import {
-	__u64 buffer_out;
-	__u32 buffer_handle;
-	__u32 status_return;
-	__s32 connection;
-};
-
-struct virtmagma_ioctl_args_create_command_buffer {
-	__u64 size;
-	__u64 buffer_out;
-	__u32 status_return;
-	__s32 connection;
-};
-
-struct virtmagma_ioctl_args_release_command_buffer {
-	__u64 command_buffer;
-	__s32 connection;
-};
-
-struct virtmagma_ioctl_args_submit_command_buffer {
-	__u64 command_buffer;
-	__u32 context_id;
-	__s32 connection;
-};
-
-struct virtmagma_ioctl_args_execute_immediate_commands {
-	__u64 command_count;
-	__u64 commands_addr; /* magma_system_inline_command_buffer[command_count] */
-	__u32 context_id;
-	__s32 connection;
-};
-
-struct virtmagma_ioctl_args_create_semaphore {
-	__u64 semaphore_out;
-	__s32 connection;
-	__u32 status_return;
-};
-
-struct virtmagma_ioctl_args_release_semaphore {
-	__u64 semaphore;
-	__s32 connection;
-};
-
-struct virtmagma_ioctl_args_get_semaphore_id {
-	__u64 semaphore;
-	__u64 id_return;
-};
-
-struct virtmagma_ioctl_args_signal_semaphore {
-	__u64 semaphore;
-};
-
-struct virtmagma_ioctl_args_reset_semaphore {
-	__u64 semaphore;
-};
-
-struct virtmagma_ioctl_args_wait_semaphores {
-	__u64 timeout_ms;
-	__u64 semaphores_addr; /* magma_semaphore_t[count] */
-	__u32 count;
-	__u32 status_return;
-	__u8 wait_all;
-};
-
-struct virtmagma_ioctl_args_export_semaphore {
-	__u64 semaphore;
-	__s32 connection;
-	__u32 semaphore_handle_out;
-	__u32 status_return;
-};
-
-struct virtmagma_ioctl_args_import_semaphore {
-	__u64 semaphore_out;
-	__s32 connection;
-	__u32 semaphore_handle;
-	__u32 status_return;
-};
-
-struct virtmagma_ioctl_args_get_notification_channel_fd {
-	__s32 connection;
-	__s32 fd_return;
-};
-
-struct virtmagma_ioctl_args_read_notification_channel {
-	__u64 buffer;
-	__u64 buffer_size;
-	__u64 buffer_size_out;
-	__s32 connection;
-	__u32 status_return;
+struct virtmagma_ioctl_args_magma_command {
+	__u64 request_address;
+	__u64 request_size;
+	__u64 response_address;
+	__u64 response_size;
 };
 
 #define VIRTMAGMA_IOCTL_HANDSHAKE VIRTMAGMA_IOWR(0x00, struct virtmagma_ioctl_args_handshake)
-#define VIRTMAGMA_IOCTL_GET_DRIVER VIRTMAGMA_IOWR(0x01, struct virtmagma_ioctl_args_get_driver)
-#define VIRTMAGMA_IOCTL_QUERY VIRTMAGMA_IOWR(0x02, struct virtmagma_ioctl_args_query)
-#define VIRTMAGMA_IOCTL_CREATE_CONNECTION VIRTMAGMA_IOWR(0x03, struct virtmagma_ioctl_args_create_connection)
-#define VIRTMAGMA_IOCTL_RELEASE_CONNECTION VIRTMAGMA_IOWR(0x04, struct virtmagma_ioctl_args_release_connection)
-#define VIRTMAGMA_IOCTL_GET_ERROR VIRTMAGMA_IOWR(0x05, struct virtmagma_ioctl_args_get_error)
-#define VIRTMAGMA_IOCTL_CREATE_CONTEXT VIRTMAGMA_IOWR(0x06, struct virtmagma_ioctl_args_create_context)
-#define VIRTMAGMA_IOCTL_RELEASE_CONTEXT VIRTMAGMA_IOWR(0x07, struct virtmagma_ioctl_args_release_context)
-#define VIRTMAGMA_IOCTL_CREATE_BUFFER VIRTMAGMA_IOWR(0x08, struct virtmagma_ioctl_args_create_buffer)
-#define VIRTMAGMA_IOCTL_RELEASE_BUFFER VIRTMAGMA_IOWR(0x09, struct virtmagma_ioctl_args_release_buffer)
-#define VIRTMAGMA_IOCTL_GET_BUFFER_ID VIRTMAGMA_IOWR(0x0A, struct virtmagma_ioctl_args_get_buffer_id)
-#define VIRTMAGMA_IOCTL_GET_BUFFER_SIZE VIRTMAGMA_IOWR(0x0B, struct virtmagma_ioctl_args_get_buffer_size)
-#define VIRTMAGMA_IOCTL_CLEAN_CACHE VIRTMAGMA_IOWR(0x0C, struct virtmagma_ioctl_args_clean_cache)
-#define VIRTMAGMA_IOCTL_SET_CACHE_POLICY VIRTMAGMA_IOWR(0x0D, struct virtmagma_ioctl_args_set_cache_policy)
-#define VIRTMAGMA_IOCTL_MAP VIRTMAGMA_IOWR(0x0E, struct virtmagma_ioctl_args_map)
-#define VIRTMAGMA_IOCTL_MAP_ALIGNED VIRTMAGMA_IOWR(0x0F, struct virtmagma_ioctl_args_map_aligned)
-#define VIRTMAGMA_IOCTL_MAP_SPECIFIC VIRTMAGMA_IOWR(0x10, struct virtmagma_ioctl_args_map_specific)
-#define VIRTMAGMA_IOCTL_UNMAP VIRTMAGMA_IOWR(0x11, struct virtmagma_ioctl_args_unmap)
-#define VIRTMAGMA_IOCTL_MAP_BUFFER_GPU VIRTMAGMA_IOWR(0x12, struct virtmagma_ioctl_args_map_buffer_gpu)
-#define VIRTMAGMA_IOCTL_UNMAP_BUFFER_GPU VIRTMAGMA_IOWR(0x13, struct virtmagma_ioctl_args_unmap_buffer_gpu)
-#define VIRTMAGMA_IOCTL_COMMIT_BUFFER VIRTMAGMA_IOWR(0x14, struct virtmagma_ioctl_args_commit_buffer)
-#define VIRTMAGMA_IOCTL_EXPORT VIRTMAGMA_IOWR(0x15, struct virtmagma_ioctl_args_export)
-#define VIRTMAGMA_IOCTL_IMPORT VIRTMAGMA_IOWR(0x16, struct virtmagma_ioctl_args_import)
-#define VIRTMAGMA_IOCTL_CREATE_COMMAND_BUFFER VIRTMAGMA_IOWR(0x17, struct virtmagma_ioctl_args_create_command_buffer)
-#define VIRTMAGMA_IOCTL_RELEASE_COMMAND_BUFFER VIRTMAGMA_IOWR(0x18, struct virtmagma_ioctl_args_release_command_buffer)
-#define VIRTMAGMA_IOCTL_SUBMIT_COMMAND_BUFFER VIRTMAGMA_IOWR(0x19, struct virtmagma_ioctl_args_submit_command_buffer)
-#define VIRTMAGMA_IOCTL_EXECUTE_IMMEDIATE_COMMANDS VIRTMAGMA_IOWR(0x1A, struct virtmagma_ioctl_args_execute_immediate_commands)
-#define VIRTMAGMA_IOCTL_CREATE_SEMAPHORE VIRTMAGMA_IOWR(0x1B, struct virtmagma_ioctl_args_create_semaphore)
-#define VIRTMAGMA_IOCTL_RELEASE_SEMAPHORE VIRTMAGMA_IOWR(0x1C, struct virtmagma_ioctl_args_release_semaphore)
-#define VIRTMAGMA_IOCTL_GET_SEMAPHORE_ID VIRTMAGMA_IOWR(0x1D, struct virtmagma_ioctl_args_get_semaphore_id)
-#define VIRTMAGMA_IOCTL_SIGNAL_SEMAPHORE VIRTMAGMA_IOWR(0x1E, struct virtmagma_ioctl_args_signal_semaphore)
-#define VIRTMAGMA_IOCTL_RESET_SEMAPHORE VIRTMAGMA_IOWR(0x1F, struct virtmagma_ioctl_args_reset_semaphore)
-#define VIRTMAGMA_IOCTL_WAIT_SEMAPHORES VIRTMAGMA_IOWR(0x20, struct virtmagma_ioctl_args_wait_semaphores)
-#define VIRTMAGMA_IOCTL_EXPORT_SEMAPHORE VIRTMAGMA_IOWR(0x21, struct virtmagma_ioctl_args_export_semaphore)
-#define VIRTMAGMA_IOCTL_IMPORT_SEMAPHORE VIRTMAGMA_IOWR(0x22, struct virtmagma_ioctl_args_import_semaphore)
-#define VIRTMAGMA_IOCTL_GET_NOTIFICATION_CHANNEL_FD VIRTMAGMA_IOWR(0x23, struct virtmagma_ioctl_args_get_notification_channel_fd)
-#define VIRTMAGMA_IOCTL_READ_NOTIFICATION_CHANNEL VIRTMAGMA_IOWR(0x24, struct virtmagma_ioctl_args_read_notification_channel)
+#define VIRTMAGMA_IOCTL_GET_MMFD VIRTMAGMA_IOWR(0x01, struct virtmagma_ioctl_args_get_mmfd)
+#define VIRTMAGMA_IOCTL_MAGMA_COMMAND VIRTMAGMA_IOWR(0x02, struct virtmagma_ioctl_args_magma_command)
 
 #endif /* _LINUX_VIRTMAGMA_H */