Re: [RFC v3 2/3] virtio: Introduce Vdmabuf driver

On Tue, Feb 02, 2021 at 11:35:16PM -0800, Vivek Kasireddy wrote:

This driver "transfers" a dmabuf created on the Guest to the Host. A common use-case for such a transfer includes sharing the scanout buffer created by a display server or a compositor running in the Guest with Qemu UI -- running on the Host.

The "transfer" is accomplished by sharing the PFNs of all the pages associated with the dmabuf and having a new dmabuf created on the Host that is backed up by the pages mapped from the Guest.

Signed-off-by: Dongwon Kim dongwon.kim@intel.com Signed-off-by: Vivek Kasireddy vivek.kasireddy@intel.com

---

drivers/virtio/Kconfig | 8 + drivers/virtio/Makefile | 1 + drivers/virtio/virtio_vdmabuf.c | 1090 +++++++++++++++++++++++++++ include/linux/virtio_vdmabuf.h | 271 +++++++ include/uapi/linux/virtio_ids.h | 1 + include/uapi/linux/virtio_vdmabuf.h | 99 +++ 6 files changed, 1470 insertions(+) create mode 100644 drivers/virtio/virtio_vdmabuf.c create mode 100644 include/linux/virtio_vdmabuf.h create mode 100644 include/uapi/linux/virtio_vdmabuf.h

diff --git a/drivers/virtio/Kconfig b/drivers/virtio/Kconfig index 7b41130d3f35..e563c12f711e 100644 --- a/drivers/virtio/Kconfig +++ b/drivers/virtio/Kconfig @@ -139,4 +139,12 @@ config VIRTIO_DMA_SHARED_BUFFER This option adds a flavor of dma buffers that are backed by virtio resources.

+config VIRTIO_VDMABUF

• bool "Enables Vdmabuf driver in guest os"
• default n
• depends on VIRTIO
• help

• This driver provides a way to share the dmabufs created in
  

• the Guest with the Host.
  

endif # VIRTIO_MENU diff --git a/drivers/virtio/Makefile b/drivers/virtio/Makefile index 591e6f72aa54..b4bb0738009c 100644 --- a/drivers/virtio/Makefile +++ b/drivers/virtio/Makefile @@ -9,3 +9,4 @@ obj-$(CONFIG_VIRTIO_INPUT) += virtio_input.o obj-$(CONFIG_VIRTIO_VDPA) += virtio_vdpa.o obj-$(CONFIG_VIRTIO_MEM) += virtio_mem.o obj-$(CONFIG_VIRTIO_DMA_SHARED_BUFFER) += virtio_dma_buf.o +obj-$(CONFIG_VIRTIO_VDMABUF) += virtio_vdmabuf.o diff --git a/drivers/virtio/virtio_vdmabuf.c b/drivers/virtio/virtio_vdmabuf.c new file mode 100644 index 000000000000..c28f144eb126 --- /dev/null +++ b/drivers/virtio/virtio_vdmabuf.c @@ -0,0 +1,1090 @@ +// SPDX-License-Identifier: (MIT OR GPL-2.0)

+/*

• • Copyright © 2021 Intel Corporation
• • Permission is hereby granted, free of charge, to any person obtaining a
• • copy of this software and associated documentation files (the "Software"),
• • to deal in the Software without restriction, including without limitation
• • the rights to use, copy, modify, merge, publish, distribute, sublicense,
• • and/or sell copies of the Software, and to permit persons to whom the
• • Software is furnished to do so, subject to the following conditions:
• • The above copyright notice and this permission notice (including the next
• • paragraph) shall be included in all copies or substantial portions of the
• • Software.
• • THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
• • IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
• • FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
• • THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
• • LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
• • FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
• • IN THE SOFTWARE.
• • Authors:
• • Dongwon Kim dongwon.kim@intel.com
• • Mateusz Polrola mateusz.polrola@gmail.com
• • Vivek Kasireddy vivek.kasireddy@intel.com
• */

+#include <linux/init.h> +#include <linux/kernel.h> +#include <linux/errno.h> +#include <linux/module.h> +#include <linux/device.h> +#include <linux/uaccess.h> +#include <linux/miscdevice.h> +#include <linux/delay.h> +#include <linux/random.h> +#include <linux/poll.h> +#include <linux/spinlock.h> +#include <linux/dma-buf.h> +#include <linux/virtio.h> +#include <linux/virtio_ids.h> +#include <linux/virtio_config.h> +#include <linux/virtio_vdmabuf.h>

+#define VIRTIO_VDMABUF_MAX_ID INT_MAX +#define REFS_PER_PAGE (PAGE_SIZE/sizeof(long)) +#define NEW_BUF_ID_GEN(vmid, cnt) (((vmid & 0xFFFFFFFF) << 32) | \

• 		    ((cnt) & 0xFFFFFFFF))
  

+/* one global drv object */ +static struct virtio_vdmabuf_info *drv_info;

+struct virtio_vdmabuf {

• /* virtio device structure */
• struct virtio_device *vdev;
• /* virtual queue array */
• struct virtqueue *vqs[VDMABUF_VQ_MAX];
• /* ID of guest OS */
• u64 vmid;
• /* spin lock that needs to be acquired before accessing

• * virtual queue
  

• */
  

• spinlock_t vq_lock;
• struct mutex recv_lock;
• struct mutex send_lock;
• struct list_head msg_list;
• /* workqueue */
• struct workqueue_struct *wq;
• struct work_struct recv_work;
• struct work_struct send_work;
• struct work_struct send_msg_work;
• struct virtio_vdmabuf_event_queue *evq;

+};

+static virtio_vdmabuf_buf_id_t get_buf_id(struct virtio_vdmabuf *vdmabuf) +{

• virtio_vdmabuf_buf_id_t buf_id = {0, {0, 0} };
• static int count = 0;
• count = count < VIRTIO_VDMABUF_MAX_ID ? count + 1 : 0;
• buf_id.id = NEW_BUF_ID_GEN(vdmabuf->vmid, count);
• /* random data embedded in the id for security */
• get_random_bytes(&buf_id.rng_key[0], 8);
• return buf_id;

+}

+/* sharing pages for original DMABUF with Host */ +static struct virtio_vdmabuf_shared_pages +*virtio_vdmabuf_share_buf(struct page **pages, int nents,

• 	  int first_ofst, int last_len)
  

+{

• struct virtio_vdmabuf_shared_pages *pages_info;
• int i;
• int n_l2refs = nents/REFS_PER_PAGE +

•        ((nents % REFS_PER_PAGE) ? 1 : 0);
  

• pages_info = kvcalloc(1, sizeof(*pages_info), GFP_KERNEL);
• if (!pages_info)

• return NULL;
  

• pages_info->pages = pages;
• pages_info->nents = nents;
• pages_info->first_ofst = first_ofst;
• pages_info->last_len = last_len;
• pages_info->l3refs = (gpa_t *)__get_free_page(GFP_KERNEL);
• if (!pages_info->l3refs) {

• kvfree(pages_info);
  

• return NULL;
  

• }
• pages_info->l2refs = (gpa_t **)__get_free_pages(GFP_KERNEL,

• 			get_order(n_l2refs * PAGE_SIZE));
  

• if (!pages_info->l2refs) {

• free_page((gpa_t)pages_info->l3refs);
  

• kvfree(pages_info);
  

• return NULL;
  

• }
• /* Share physical address of pages */
• for (i = 0; i < nents; i++)

• pages_info->l2refs[i] = (gpa_t *)page_to_phys(pages[i]);
  

• for (i = 0; i < n_l2refs; i++)

• pages_info->l3refs[i] =
  

• 	virt_to_phys((void *)pages_info->l2refs +
  

• 		     i * PAGE_SIZE);
  

• pages_info->ref = (gpa_t)virt_to_phys(pages_info->l3refs);
• return pages_info;

+}

+/* stop sharing pages */ +static void +virtio_vdmabuf_free_buf(struct virtio_vdmabuf_shared_pages *pages_info) +{

• int n_l2refs = (pages_info->nents/REFS_PER_PAGE +

•        ((pages_info->nents % REFS_PER_PAGE) ? 1 : 0));
  

• free_pages((gpa_t)pages_info->l2refs, get_order(n_l2refs * PAGE_SIZE));
• free_page((gpa_t)pages_info->l3refs);
• kvfree(pages_info);

+}

+static int send_msg_to_host(enum virtio_vdmabuf_cmd cmd, int *op) +{

• struct virtio_vdmabuf *vdmabuf = drv_info->priv;
• struct virtio_vdmabuf_msg *msg;
• int i;
• switch (cmd) {
• case VIRTIO_VDMABUF_CMD_NEED_VMID:

• msg = kvcalloc(1, sizeof(struct virtio_vdmabuf_msg),
  

• 	       GFP_KERNEL);
  

• if (!msg)
  

• 	return -ENOMEM;
  

• if (op)
  

• 	for (i = 0; i < 4; i++)
  

• 		msg->op[i] = op[i];
  

• break;
  

• case VIRTIO_VDMABUF_CMD_EXPORT:

• msg = kvcalloc(1, sizeof(struct virtio_vdmabuf_msg),
  

• 	       GFP_KERNEL);
  

• if (!msg)
  

• 	return -ENOMEM;
  

• memcpy(&msg->op[0], &op[0], 9 * sizeof(int) + op[9]);
  

• break;
  

• default:

• /* no command found */
  

• return -EINVAL;
  

• }
• msg->cmd = cmd;
• list_add_tail(&msg->list, &vdmabuf->msg_list);
• queue_work(vdmabuf->wq, &vdmabuf->send_msg_work);
• return 0;

+}

+static int add_event_buf_rel(struct virtio_vdmabuf_buf *buf_info) +{

• struct virtio_vdmabuf *vdmabuf = drv_info->priv;
• struct virtio_vdmabuf_event *e_oldest, *e_new;
• struct virtio_vdmabuf_event_queue *eq = vdmabuf->evq;
• unsigned long irqflags;
• e_new = kvzalloc(sizeof(*e_new), GFP_KERNEL);
• if (!e_new)

• return -ENOMEM;
  

• e_new->e_data.hdr.buf_id = buf_info->buf_id;
• e_new->e_data.data = (void *)buf_info->priv;
• e_new->e_data.hdr.size = buf_info->sz_priv;
• spin_lock_irqsave(&eq->e_lock, irqflags);
• /* check current number of events and if it hits the max num (32)

• * then remove the oldest event in the list
  

• */
  

• if (eq->pending > 31) {

• e_oldest = list_first_entry(&eq->e_list,
  

• 			    struct virtio_vdmabuf_event, link);
  

• list_del(&e_oldest->link);
  

• eq->pending--;
  

• kvfree(e_oldest);
  

• }
• list_add_tail(&e_new->link, &eq->e_list);
• eq->pending++;
• wake_up_interruptible(&eq->e_wait);
• spin_unlock_irqrestore(&eq->e_lock, irqflags);
• return 0;

+}

+static void virtio_vdmabuf_clear_buf(struct virtio_vdmabuf_buf *exp) +{

• /* Start cleanup of buffer in reverse order to exporting */
• virtio_vdmabuf_free_buf(exp->pages_info);
• dma_buf_unmap_attachment(exp->attach, exp->sgt,

• 		 DMA_BIDIRECTIONAL);
  

• if (exp->dma_buf) {

• dma_buf_detach(exp->dma_buf, exp->attach);
  

• /* close connection to dma-buf completely */
  

• dma_buf_put(exp->dma_buf);
  

• exp->dma_buf = NULL;
  

• }

+}

+static int remove_buf(struct virtio_vdmabuf *vdmabuf,

•       struct virtio_vdmabuf_buf *exp)
  

+{

• int ret;
• ret = add_event_buf_rel(exp);
• if (ret)

• return ret;
  

• virtio_vdmabuf_clear_buf(exp);
• ret = virtio_vdmabuf_del_buf(drv_info, &exp->buf_id);
• if (ret)

• return ret;
  

• if (exp->sz_priv > 0 && !exp->priv)

• kvfree(exp->priv);
  

• kvfree(exp);
• return 0;

+}

+static int parse_msg_from_host(struct virtio_vdmabuf *vdmabuf,

•      	       struct virtio_vdmabuf_msg *msg)
  

+{

• struct virtio_vdmabuf_buf *exp;
• virtio_vdmabuf_buf_id_t buf_id;
• int ret;
• switch (msg->cmd) {
• case VIRTIO_VDMABUF_CMD_NEED_VMID:

• vdmabuf->vmid = msg->op[0];
  

• break;
  

• case VIRTIO_VDMABUF_CMD_DMABUF_REL:

• memcpy(&buf_id, msg->op, sizeof(buf_id));
  

• exp = virtio_vdmabuf_find_buf(drv_info, &buf_id);
  

• if (!exp) {
  

• 	dev_err(drv_info->dev, "can't find buffer\n");
  

• 	return -EINVAL;
  

• }
  

• ret = remove_buf(vdmabuf, exp);
  

• if (ret)
  

• 	return ret;
  

• break;
  

• case VIRTIO_VDMABUF_CMD_EXPORT:

• break;
  

• default:

• dev_err(drv_info->dev, "empty cmd\n");
  

• return -EINVAL;
  

• }
• return 0;

+}

+static void virtio_vdmabuf_recv_work(struct work_struct *work) +{

• struct virtio_vdmabuf *vdmabuf =

• container_of(work, struct virtio_vdmabuf, recv_work);
  

• struct virtqueue *vq = vdmabuf->vqs[VDMABUF_VQ_RECV];
• struct virtio_vdmabuf_msg *msg;
• int sz;
• mutex_lock(&vdmabuf->recv_lock);
• do {

• virtqueue_disable_cb(vq);
  

• for (;;) {
  

• 	msg = virtqueue_get_buf(vq, &sz);
  

• 	if (!msg)
  

• 		break;
  

• 	/* valid size */
  

• 	if (sz == sizeof(struct virtio_vdmabuf_msg)) {
  

• 		if (parse_msg_from_host(vdmabuf, msg))
  

• 			dev_err(drv_info->dev,
  

• 				"msg parse error\n");
  

• 		kvfree(msg);
  

• 	} else {
  

• 		dev_err(drv_info->dev,
  

• 			"received malformed message\n");
  

• 	}
  

• }
  

• } while (!virtqueue_enable_cb(vq));
• mutex_unlock(&vdmabuf->recv_lock);

+}

+static void virtio_vdmabuf_fill_recv_msg(struct virtio_vdmabuf *vdmabuf) +{

• struct virtqueue *vq = vdmabuf->vqs[VDMABUF_VQ_RECV];
• struct scatterlist sg;
• struct virtio_vdmabuf_msg *msg;
• int ret;
• msg = kvzalloc(sizeof(*msg), GFP_KERNEL);
• if (!msg)

• return;
  

• sg_init_one(&sg, msg, sizeof(struct virtio_vdmabuf_msg));
• ret = virtqueue_add_inbuf(vq, &sg, 1, msg, GFP_KERNEL);
• if (ret)

• return;
  

• virtqueue_kick(vq);

+}

+static void virtio_vdmabuf_send_msg_work(struct work_struct *work) +{

• struct virtio_vdmabuf *vdmabuf =

• container_of(work, struct virtio_vdmabuf, send_msg_work);
  

• struct virtqueue *vq = vdmabuf->vqs[VDMABUF_VQ_SEND];
• struct scatterlist sg;
• struct virtio_vdmabuf_msg *msg;
• bool added = false;
• int ret;
• mutex_lock(&vdmabuf->send_lock);
• for (;;) {

• if (list_empty(&vdmabuf->msg_list))
  

• 	break;
  

• virtio_vdmabuf_fill_recv_msg(vdmabuf);
  

• msg = list_first_entry(&vdmabuf->msg_list,
  

• 		       struct virtio_vdmabuf_msg, list);
  

• list_del_init(&msg->list);
  

• sg_init_one(&sg, msg, sizeof(struct virtio_vdmabuf_msg));
  

• ret = virtqueue_add_outbuf(vq, &sg, 1, msg, GFP_KERNEL);
  

• if (ret < 0) {
  

• 	dev_err(drv_info->dev,
  

• 		"failed to add msg to vq\n");
  

• 	break;
  

• }
  

• added = true;	
  

• }
• if (added)

• virtqueue_kick(vq);
  

• mutex_unlock(&vdmabuf->send_lock);

+}

+static void virtio_vdmabuf_send_work(struct work_struct *work) +{

• struct virtio_vdmabuf *vdmabuf =

• container_of(work, struct virtio_vdmabuf, send_work);
  

• struct virtqueue *vq = vdmabuf->vqs[VDMABUF_VQ_SEND];
• struct virtio_vdmabuf_msg *msg;
• unsigned int sz;
• bool added = false;
• mutex_lock(&vdmabuf->send_lock);
• do {

• virtqueue_disable_cb(vq);
  

• for (;;) {
  

• 	msg = virtqueue_get_buf(vq, &sz);
  

• 	if (!msg)
  

• 		break;
  

• 	if (parse_msg_from_host(vdmabuf, msg))
  

• 		dev_err(drv_info->dev,
  

• 			"msg parse error\n");
  

• 	kvfree(msg);
  

• 	added = true;
  

• }
  

• } while (!virtqueue_enable_cb(vq));
• mutex_unlock(&vdmabuf->send_lock);
• if (added)

• queue_work(vdmabuf->wq, &vdmabuf->send_msg_work);
  

+}

+static void virtio_vdmabuf_recv_cb(struct virtqueue *vq) +{

• struct virtio_vdmabuf *vdmabuf = vq->vdev->priv;
• if (!vdmabuf)

• return;
  

• queue_work(vdmabuf->wq, &vdmabuf->recv_work);

+}

+static void virtio_vdmabuf_send_cb(struct virtqueue *vq) +{

• struct virtio_vdmabuf *vdmabuf = vq->vdev->priv;
• if (!vdmabuf)

• return;
  

• queue_work(vdmabuf->wq, &vdmabuf->send_work);

+}

+static int remove_all_bufs(struct virtio_vdmabuf *vdmabuf) +{

• struct virtio_vdmabuf_buf *found;
• struct hlist_node *tmp;
• int bkt;
• int ret;
• hash_for_each_safe(drv_info->buf_list, bkt, tmp, found, node) {

• ret = remove_buf(vdmabuf, found);
  

• if (ret)
  

• 	return ret;
  

• }
• return 0;

+}

+static int virtio_vdmabuf_open(struct inode *inode, struct file *filp) +{

• int ret;
• if (!drv_info) {

• pr_err("virtio vdmabuf driver is not ready\n");
  

• return -EINVAL;
  

• }
• ret = send_msg_to_host(VIRTIO_VDMABUF_CMD_NEED_VMID, 0);
• if (ret < 0)

• dev_err(drv_info->dev, "fail to receive vmid\n");
  

• filp->private_data = drv_info->priv;
• return 0;

+}

+static int virtio_vdmabuf_release(struct inode *inode, struct file *filp) +{

• return 0;

+}

+/* Notify Host about the new vdmabuf */ +static int export_notify(struct virtio_vdmabuf_buf *exp, struct page **pages) +{

• int *op;
• int ret;
• op = kvcalloc(1, sizeof(int) * 65, GFP_KERNEL);
• if (!op)

• return -ENOMEM;
  

• memcpy(op, &exp->buf_id, sizeof(exp->buf_id));
• /* if new pages are to be shared */
• if (pages) {

• op[4] = exp->pages_info->nents;
  

• op[5] = exp->pages_info->first_ofst;
  

• op[6] = exp->pages_info->last_len;
  

• memcpy(&op[7], &exp->pages_info->ref, sizeof(gpa_t));
  

• }
• op[9] = exp->sz_priv;
• /* driver/application specific private info */
• memcpy(&op[10], exp->priv, op[9]);
• ret = send_msg_to_host(VIRTIO_VDMABUF_CMD_EXPORT, op);
• kvfree(op);
• return ret;

+}

+/* return total number of pages referenced by a sgt

• • for pre-calculation of # of pages behind a given sgt
• */

+static int num_pgs(struct sg_table *sgt) +{

• struct scatterlist *sgl;
• int len, i;
• /* at least one page */
• int n_pgs = 1;
• sgl = sgt->sgl;
• len = sgl->length - PAGE_SIZE + sgl->offset;
• /* round-up */
• n_pgs += ((len + PAGE_SIZE - 1)/PAGE_SIZE);
• for (i = 1; i < sgt->nents; i++) {

• sgl = sg_next(sgl);
  

• /* round-up */
  

• n_pgs += ((sgl->length + PAGE_SIZE - 1) /
  

• 	  PAGE_SIZE); /* round-up */
  

• }
• return n_pgs;

+}

+/* extract pages referenced by sgt */ +static struct page **extr_pgs(struct sg_table *sgt, int *nents, int *last_len)

Nack, this doesn't work on dma-buf. And it'll blow up at runtime when you enable the very recently merged CONFIG_DMABUF_DEBUG (would be good to test with that, just to make sure).

Aside from this, for virtio/kvm use-cases we've already merged the udmabuf driver. Does this not work for your usecase?

Adding Gerd as the subject expert for this area.

Thanks, Daniel

+{

• struct scatterlist *sgl;
• struct page **pages;
• struct page **temp_pgs;
• int i, j;
• int len;
• *nents = num_pgs(sgt);
• pages = kvmalloc_array(*nents, sizeof(struct page *), GFP_KERNEL);
• if (!pages)

• return NULL;
  

• sgl = sgt->sgl;
• temp_pgs = pages;
• *temp_pgs++ = sg_page(sgl);
• len = sgl->length - PAGE_SIZE + sgl->offset;
• i = 1;
• while (len > 0) {

• *temp_pgs++ = nth_page(sg_page(sgl), i++);
  

• len -= PAGE_SIZE;
  

• }
• for (i = 1; i < sgt->nents; i++) {

• sgl = sg_next(sgl);
  

• *temp_pgs++ = sg_page(sgl);
  

• len = sgl->length - PAGE_SIZE;
  

• j = 1;
  

• while (len > 0) {
  

• 	*temp_pgs++ = nth_page(sg_page(sgl), j++);
  

• 	len -= PAGE_SIZE;
  

• }
  

• }
• *last_len = len + PAGE_SIZE;
• return pages;

+}

+/* ioctl - exporting new vdmabuf

• • int dmabuf_fd - File handle of original DMABUF
    

• • virtio_vdmabuf_buf_id_t buf_id - returned vdmabuf ID
    

• • int sz_priv - size of private data from userspace
    

• • char *priv - buffer of user private data
    

• */

+static int export_ioctl(struct file *filp, void *data) +{

• struct virtio_vdmabuf *vdmabuf = drv_info->priv;
• struct virtio_vdmabuf_export *attr = data;
• struct dma_buf *dmabuf;
• struct dma_buf_attachment *attach;
• struct sg_table *sgt;
• struct virtio_vdmabuf_buf *exp;
• struct page **pages;
• int nents, last_len;
• virtio_vdmabuf_buf_id_t buf_id;
• int ret = 0;
• if (vdmabuf->vmid <= 0)

• return -EINVAL;
  

• dmabuf = dma_buf_get(attr->fd);
• if (IS_ERR(dmabuf))

• return PTR_ERR(dmabuf);
  

• mutex_lock(&drv_info->g_mutex);
• buf_id = get_buf_id(vdmabuf);
• attach = dma_buf_attach(dmabuf, drv_info->dev);
• if (IS_ERR(attach)) {

• ret = PTR_ERR(attach);
  

• goto fail_attach;
  

• }
• sgt = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL);
• if (IS_ERR(sgt)) {

• ret = PTR_ERR(sgt);
  

• goto fail_map_attachment;
  

• }
• /* allocate a new exp */
• exp = kvcalloc(1, sizeof(*exp), GFP_KERNEL);
• if (!exp) {

• ret = -ENOMEM;
  

• goto fail_sgt_info_creation;
  

• }
• /* possible truncation */
• if (attr->sz_priv > MAX_SIZE_PRIV_DATA)

• exp->sz_priv = MAX_SIZE_PRIV_DATA;
  

• else

• exp->sz_priv = attr->sz_priv;
  

• /* creating buffer for private data */
• if (exp->sz_priv != 0) {

• exp->priv = kvcalloc(1, exp->sz_priv, GFP_KERNEL);
  

• if (!exp->priv) {
  

• 	ret = -ENOMEM;
  

• 	goto fail_priv_creation;
  

• }
  

• }
• exp->buf_id = buf_id;
• exp->attach = attach;
• exp->sgt = sgt;
• exp->dma_buf = dmabuf;
• exp->valid = 1;
• if (exp->sz_priv) {

• /* copy private data to sgt_info */
  

• ret = copy_from_user(exp->priv, attr->priv, exp->sz_priv);
  

• if (ret) {
  

• 	ret = -EINVAL;
  

• 	goto fail_exp;
  

• }
  

• }
• pages = extr_pgs(sgt, &nents, &last_len);
• if (pages == NULL) {

• ret = -ENOMEM;
  

• goto fail_exp;
  

• }
• exp->pages_info = virtio_vdmabuf_share_buf(pages, nents,

• 				   sgt->sgl->offset,
  

• 			 	   last_len);
  

• if (!exp->pages_info) {

• ret = -ENOMEM;
  

• goto fail_create_pages_info;
  

• }
• attr->buf_id = exp->buf_id;
• ret = export_notify(exp, pages);
• if (ret < 0)

• goto fail_send_request;
  

• /* now register it to the export list */
• virtio_vdmabuf_add_buf(drv_info, exp);
• exp->filp = filp;
• mutex_unlock(&drv_info->g_mutex);
• return ret;

+/* Clean-up if error occurs */ +fail_send_request:

• virtio_vdmabuf_free_buf(exp->pages_info);

+fail_create_pages_info:

• kvfree(pages);

+fail_exp:

• kvfree(exp->priv);

+fail_priv_creation:

• kvfree(exp);

+fail_sgt_info_creation:

• dma_buf_unmap_attachment(attach, sgt,

• 		 DMA_BIDIRECTIONAL);
  

+fail_map_attachment:

• dma_buf_detach(dmabuf, attach);

+fail_attach:

• dma_buf_put(dmabuf);
• mutex_unlock(&drv_info->g_mutex);
• return ret;

+}

+static const struct virtio_vdmabuf_ioctl_desc virtio_vdmabuf_ioctls[] = {

• VIRTIO_VDMABUF_IOCTL_DEF(VIRTIO_VDMABUF_IOCTL_EXPORT, export_ioctl, 0),

+};

+static long virtio_vdmabuf_ioctl(struct file *filp, unsigned int cmd,

•        		 unsigned long param)
  

+{

• const struct virtio_vdmabuf_ioctl_desc *ioctl = NULL;
• unsigned int nr = _IOC_NR(cmd);
• int ret;
• virtio_vdmabuf_ioctl_t func;
• char *kdata;
• if (nr >= ARRAY_SIZE(virtio_vdmabuf_ioctls)) {

• dev_err(drv_info->dev, "invalid ioctl\n");
  

• return -EINVAL;
  

• }
• ioctl = &virtio_vdmabuf_ioctls[nr];
• func = ioctl->func;
• if (unlikely(!func)) {

• dev_err(drv_info->dev, "no function\n");
  

• return -EINVAL;
  

• }
• kdata = kvmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
• if (!kdata)

• return -ENOMEM;
  

• if (copy_from_user(kdata, (void __user *)param,

• 	   _IOC_SIZE(cmd)) != 0) {
  

• dev_err(drv_info->dev,
  

• 	"failed to copy from user arguments\n");
  

• ret = -EFAULT;
  

• goto ioctl_error;
  

• }
• ret = func(filp, kdata);
• if (copy_to_user((void __user *)param, kdata,

• 	 _IOC_SIZE(cmd)) != 0) {
  

• dev_err(drv_info->dev,
  

• 	"failed to copy to user arguments\n");
  

• ret = -EFAULT;
  

• goto ioctl_error;
  

• }

+ioctl_error:

• kvfree(kdata);
• return ret;

+}

+static unsigned int virtio_vdmabuf_event_poll(struct file *filp,

• 	    	    	      struct poll_table_struct *wait)
  

+{

• struct virtio_vdmabuf *vdmabuf = filp->private_data;
• poll_wait(filp, &vdmabuf->evq->e_wait, wait);
• if (!list_empty(&vdmabuf->evq->e_list))

• return POLLIN | POLLRDNORM;
  

• return 0;

+}

+static ssize_t virtio_vdmabuf_event_read(struct file *filp, char __user *buf,

• 	       		 size_t cnt, loff_t *ofst)
  

+{

• struct virtio_vdmabuf *vdmabuf = filp->private_data;
• int ret;
• /* make sure user buffer can be written */
• if (!access_ok(buf, sizeof (*buf))) {

• dev_err(drv_info->dev, "user buffer can't be written.\n");
  

• return -EINVAL;
  

• }
• ret = mutex_lock_interruptible(&vdmabuf->evq->e_readlock);
• if (ret)

• return ret;
  

• for (;;) {

• struct virtio_vdmabuf_event *e = NULL;
  

• spin_lock_irq(&vdmabuf->evq->e_lock);
  

• if (!list_empty(&vdmabuf->evq->e_list)) {
  

• 	e = list_first_entry(&vdmabuf->evq->e_list,
  

• 			     struct virtio_vdmabuf_event, link);
  

• 	list_del(&e->link);
  

• }
  

• spin_unlock_irq(&vdmabuf->evq->e_lock);
  

• if (!e) {
  

• 	if (ret)
  

• 		break;
  

• 	if (filp->f_flags & O_NONBLOCK) {
  

• 		ret = -EAGAIN;
  

• 		break;
  

• 	}
  

• 	mutex_unlock(&vdmabuf->evq->e_readlock);
  

• 	ret = wait_event_interruptible(vdmabuf->evq->e_wait,
  

• 			!list_empty(&vdmabuf->evq->e_list));
  

• 	if (ret == 0)
  

• 		ret = mutex_lock_interruptible(
  

• 				&vdmabuf->evq->e_readlock);
  

• 	if (ret)
  

• 		return ret;
  

• } else {
  

• 	unsigned int len = (sizeof(e->e_data.hdr) +
  

• 			    e->e_data.hdr.size);
  

• 	if (len > cnt - ret) {
  

+put_back_event:

• 		spin_lock_irq(&vdmabuf->evq->e_lock);
  

• 		list_add(&e->link, &vdmabuf->evq->e_list);
  

• 		spin_unlock_irq(&vdmabuf->evq->e_lock);
  

• 		break;
  

• 	}
  

• 	if (copy_to_user(buf + ret, &e->e_data.hdr,
  

• 			 sizeof(e->e_data.hdr))) {
  

• 		if (ret == 0)
  

• 			ret = -EFAULT;
  

• 		goto put_back_event;
  

• 	}
  

• 	ret += sizeof(e->e_data.hdr);
  

• 	if (copy_to_user(buf + ret, e->e_data.data,
  

• 			 e->e_data.hdr.size)) {
  

• 		/* error while copying void *data */
  

• 		struct virtio_vdmabuf_e_hdr dummy_hdr = {0};
  

• 		ret -= sizeof(e->e_data.hdr);
  

• 		/* nullifying hdr of the event in user buffer */
  

• 		if (copy_to_user(buf + ret, &dummy_hdr,
  

• 				 sizeof(dummy_hdr)))
  

• 			dev_err(drv_info->dev,
  

• 			   "fail to nullify invalid hdr\n");
  

• 		ret = -EFAULT;
  

• 		goto put_back_event;
  

• 	}
  

• 	ret += e->e_data.hdr.size;
  

• 	vdmabuf->evq->pending--;
  

• 	kvfree(e);
  

• }
  

• }
• mutex_unlock(&vdmabuf->evq->e_readlock);
• return ret;

+}

+static const struct file_operations virtio_vdmabuf_fops = {

• .owner = THIS_MODULE,
• .open = virtio_vdmabuf_open,
• .release = virtio_vdmabuf_release,
• .read = virtio_vdmabuf_event_read,
• .poll = virtio_vdmabuf_event_poll,
• .unlocked_ioctl = virtio_vdmabuf_ioctl,

+};

+static struct miscdevice virtio_vdmabuf_miscdev = {

• .minor = MISC_DYNAMIC_MINOR,
• .name = "virtio-vdmabuf",
• .fops = &virtio_vdmabuf_fops,

+};

+static int virtio_vdmabuf_probe(struct virtio_device *vdev) +{

• vq_callback_t *cbs[] = {

• virtio_vdmabuf_recv_cb,
  

• virtio_vdmabuf_send_cb,
  

• };
• static const char *const names[] = {

• "recv",
  

• "send",
  

• };
• struct virtio_vdmabuf *vdmabuf;
• int ret = 0;
• if (!drv_info)

• return -EINVAL;
  

• vdmabuf = drv_info->priv;
• if (!vdmabuf)

• return -EINVAL;
  

• vdmabuf->vdev = vdev;
• vdev->priv = vdmabuf;
• /* initialize spinlock for synchronizing virtqueue accesses */
• spin_lock_init(&vdmabuf->vq_lock);
• ret = virtio_find_vqs(vdmabuf->vdev, VDMABUF_VQ_MAX, vdmabuf->vqs,

• 	      cbs, names, NULL);
  

• if (ret) {

• dev_err(drv_info->dev, "Cannot find any vqs\n");
  

• return ret;
  

• }
• INIT_LIST_HEAD(&vdmabuf->msg_list);
• INIT_WORK(&vdmabuf->recv_work, virtio_vdmabuf_recv_work);
• INIT_WORK(&vdmabuf->send_work, virtio_vdmabuf_send_work);
• INIT_WORK(&vdmabuf->send_msg_work, virtio_vdmabuf_send_msg_work);
• return ret;

+}

+static void virtio_vdmabuf_remove(struct virtio_device *vdev) +{

• struct virtio_vdmabuf *vdmabuf;
• if (!drv_info)

• return;
  

• vdmabuf = drv_info->priv;
• flush_work(&vdmabuf->recv_work);
• flush_work(&vdmabuf->send_work);
• flush_work(&vdmabuf->send_msg_work);
• vdev->config->reset(vdev);
• vdev->config->del_vqs(vdev);

+}

+static struct virtio_device_id id_table[] = {

• { VIRTIO_ID_VDMABUF, VIRTIO_DEV_ANY_ID },
• { 0 },

+};

+static struct virtio_driver virtio_vdmabuf_vdev_drv = {

• .driver.name = KBUILD_MODNAME,
• .driver.owner = THIS_MODULE,
• .id_table = id_table,
• .probe = virtio_vdmabuf_probe,
• .remove = virtio_vdmabuf_remove,

+};

+static int __init virtio_vdmabuf_init(void) +{

• struct virtio_vdmabuf *vdmabuf;
• int ret = 0;
• drv_info = NULL;
• ret = misc_register(&virtio_vdmabuf_miscdev);
• if (ret) {

• pr_err("virtio-vdmabuf misc driver can't be registered\n");
  

• return ret;
  

• }
• ret = dma_set_mask_and_coherent(virtio_vdmabuf_miscdev.this_device,

• 			DMA_BIT_MASK(64));
  

• if (ret < 0) {

• misc_deregister(&virtio_vdmabuf_miscdev);
  

• return -EINVAL;
  

• }
• drv_info = kvcalloc(1, sizeof(*drv_info), GFP_KERNEL);
• if (!drv_info) {

• misc_deregister(&virtio_vdmabuf_miscdev);
  

• return -ENOMEM;
  

• }
• vdmabuf = kvcalloc(1, sizeof(*vdmabuf), GFP_KERNEL);
• if (!vdmabuf) {

• kvfree(drv_info);
  

• misc_deregister(&virtio_vdmabuf_miscdev);
  

• return -ENOMEM;
  

• }
• vdmabuf->evq = kvcalloc(1, sizeof(*(vdmabuf->evq)), GFP_KERNEL);
• if (!vdmabuf->evq) {

• kvfree(drv_info);
  

• kvfree(vdmabuf);
  

• misc_deregister(&virtio_vdmabuf_miscdev);
  

• return -ENOMEM;
  

• }
• drv_info->priv = (void *)vdmabuf;
• drv_info->dev = virtio_vdmabuf_miscdev.this_device;
• mutex_init(&drv_info->g_mutex);
• mutex_init(&vdmabuf->evq->e_readlock);
• spin_lock_init(&vdmabuf->evq->e_lock);
• INIT_LIST_HEAD(&vdmabuf->evq->e_list);
• init_waitqueue_head(&vdmabuf->evq->e_wait);
• hash_init(drv_info->buf_list);
• vdmabuf->evq->pending = 0;
• vdmabuf->wq = create_workqueue("virtio_vdmabuf_wq");
• ret = register_virtio_driver(&virtio_vdmabuf_vdev_drv);
• if (ret) {

• dev_err(drv_info->dev, "vdmabuf driver can't be registered\n");
  

• misc_deregister(&virtio_vdmabuf_miscdev);
  

• kvfree(vdmabuf);
  

• kvfree(drv_info);
  

• return -EFAULT;
  

• }
• return 0;

+}

+static void __exit virtio_vdmabuf_deinit(void) +{

• struct virtio_vdmabuf *vdmabuf = drv_info->priv;
• struct virtio_vdmabuf_event *e, *et;
• unsigned long irqflags;
• misc_deregister(&virtio_vdmabuf_miscdev);
• unregister_virtio_driver(&virtio_vdmabuf_vdev_drv);
• if (vdmabuf->wq)

• destroy_workqueue(vdmabuf->wq);
  

• spin_lock_irqsave(&vdmabuf->evq->e_lock, irqflags);
• list_for_each_entry_safe(e, et, &vdmabuf->evq->e_list,

• 		 link) {
  

• list_del(&e->link);
  

• kvfree(e);
  

• vdmabuf->evq->pending--;
  

• }
• spin_unlock_irqrestore(&vdmabuf->evq->e_lock, irqflags);
• /* freeing all exported buffers */
• remove_all_bufs(vdmabuf);
• kvfree(vdmabuf->evq);
• kvfree(vdmabuf);
• kvfree(drv_info);

+}

+module_init(virtio_vdmabuf_init); +module_exit(virtio_vdmabuf_deinit);

+MODULE_DEVICE_TABLE(virtio, virtio_vdmabuf_id_table); +MODULE_DESCRIPTION("Virtio Vdmabuf frontend driver"); +MODULE_LICENSE("GPL and additional rights"); diff --git a/include/linux/virtio_vdmabuf.h b/include/linux/virtio_vdmabuf.h new file mode 100644 index 000000000000..9500bf4a54ac --- /dev/null +++ b/include/linux/virtio_vdmabuf.h @@ -0,0 +1,271 @@ +/* SPDX-License-Identifier: (MIT OR GPL-2.0) */

+/*

• • Copyright © 2021 Intel Corporation
• • Permission is hereby granted, free of charge, to any person obtaining a
• • copy of this software and associated documentation files (the "Software"),
• • to deal in the Software without restriction, including without limitation
• • the rights to use, copy, modify, merge, publish, distribute, sublicense,
• • and/or sell copies of the Software, and to permit persons to whom the
• • Software is furnished to do so, subject to the following conditions:
• • The above copyright notice and this permission notice (including the next
• • paragraph) shall be included in all copies or substantial portions of the
• • Software.
• • THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
• • IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
• • FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
• • THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
• • LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
• • FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
• • IN THE SOFTWARE.
• */

+#ifndef _LINUX_VIRTIO_VDMABUF_H +#define _LINUX_VIRTIO_VDMABUF_H

+#include <uapi/linux/virtio_vdmabuf.h> +#include <linux/hashtable.h> +#include <linux/kvm_types.h>

+struct virtio_vdmabuf_shared_pages {

• /* cross-VM ref addr for the buffer */
• gpa_t ref;
• /* page array */
• struct page **pages;
• gpa_t **l2refs;
• gpa_t *l3refs;
• /* data offset in the first page

• * and data length in the last page
  

• */
  

• int first_ofst;
• int last_len;
• /* number of shared pages */
• int nents;

+};

+struct virtio_vdmabuf_buf {

• virtio_vdmabuf_buf_id_t buf_id;
• struct dma_buf_attachment *attach;
• struct dma_buf *dma_buf;
• struct sg_table *sgt;
• struct virtio_vdmabuf_shared_pages *pages_info;
• int vmid;
• /* validity of the buffer */
• bool valid;
• /* set if the buffer is imported via import_ioctl */
• bool imported;
• /* size of private */
• size_t sz_priv;
• /* private data associated with the exported buffer */
• void *priv;
• struct file *filp;
• struct hlist_node node;

+};

+struct virtio_vdmabuf_event {

• struct virtio_vdmabuf_e_data e_data;
• struct list_head link;

+};

+struct virtio_vdmabuf_event_queue {

• wait_queue_head_t e_wait;
• struct list_head e_list;
• spinlock_t e_lock;
• struct mutex e_readlock;
• /* # of pending events */
• int pending;

+};

+/* driver information */ +struct virtio_vdmabuf_info {

• struct device *dev;
• struct list_head head_vdmabuf_list;
• struct list_head kvm_instances;
• DECLARE_HASHTABLE(buf_list, 7);
• void *priv;
• struct mutex g_mutex;
• struct notifier_block kvm_notifier;

+};

+/* IOCTL definitions

• */

+typedef int (*virtio_vdmabuf_ioctl_t)(struct file *filp, void *data);

+struct virtio_vdmabuf_ioctl_desc {

• unsigned int cmd;
• int flags;
• virtio_vdmabuf_ioctl_t func;
• const char *name;

+};

+#define VIRTIO_VDMABUF_IOCTL_DEF(ioctl, _func, _flags) \

• [_IOC_NR(ioctl)] = { \

• 	.cmd = ioctl,		\
  

• 	.func = _func,		\
  

• 	.flags = _flags,	\
  

• 	.name = #ioctl		\
  

+}

+#define VIRTIO_VDMABUF_VMID(buf_id) ((((buf_id).id) >> 32) & 0xFFFFFFFF)

+/* Messages between Host and Guest */

+/* List of commands from Guest to Host:

• • ---

• • A. NEED_VMID
• • guest asks the host to provide its vmid
• • req:
• • cmd: VIRTIO_VDMABUF_NEED_VMID
• • ack:
• • cmd: same as req
• • op[0] : vmid of guest

• • ---

• • B. EXPORT
• • export dmabuf to host
• • req:
• • cmd: VIRTIO_VDMABUF_CMD_EXPORT
• • op0~op3 : HDMABUF ID
• • op4 : number of pages to be shared
• • op5 : offset of data in the first page
• • op6 : length of data in the last page
• • op7 : upper 32 bit of top-level ref of shared buf
• • op8 : lower 32 bit of top-level ref of shared buf
• • op9 : size of private data
• • op10 ~ op64: User private date associated with the buffer

• •        (e.g. graphic buffer's meta info)
    

• • ---

• • List of commands from Host to Guest

• • ---

• • A. RELEASE
• • notifying guest that the shared buffer is released by an importer
• • req:
• • cmd: VIRTIO_VDMABUF_CMD_DMABUF_REL
• • op0~op3 : VDMABUF ID

• • ---

• */

+/* msg structures */ +struct virtio_vdmabuf_msg {

• struct list_head list;
• unsigned int cmd;
• unsigned int op[64];

+};

+enum {

• VDMABUF_VQ_RECV = 0,
• VDMABUF_VQ_SEND = 1,
• VDMABUF_VQ_MAX = 2,

+};

+enum virtio_vdmabuf_cmd {

• VIRTIO_VDMABUF_CMD_NEED_VMID,
• VIRTIO_VDMABUF_CMD_EXPORT = 0x10,
• VIRTIO_VDMABUF_CMD_DMABUF_REL

+};

+enum virtio_vdmabuf_ops {

• VIRTIO_VDMABUF_HDMABUF_ID_ID = 0,
• VIRTIO_VDMABUF_HDMABUF_ID_RNG_KEY0,
• VIRTIO_VDMABUF_HDMABUF_ID_RNG_KEY1,
• VIRTIO_VDMABUF_NUM_PAGES_SHARED = 4,
• VIRTIO_VDMABUF_FIRST_PAGE_DATA_OFFSET,
• VIRTIO_VDMABUF_LAST_PAGE_DATA_LENGTH,
• VIRTIO_VDMABUF_REF_ADDR_UPPER_32BIT,
• VIRTIO_VDMABUF_REF_ADDR_LOWER_32BIT,
• VIRTIO_VDMABUF_PRIVATE_DATA_SIZE,
• VIRTIO_VDMABUF_PRIVATE_DATA_START

+};

+/* adding exported/imported vdmabuf info to hash */ +static inline int +virtio_vdmabuf_add_buf(struct virtio_vdmabuf_info *info,

•                   struct virtio_vdmabuf_buf *new)
  

+{

• hash_add(info->buf_list, &new->node, new->buf_id.id);
• return 0;

+}

+/* comparing two vdmabuf IDs */ +static inline bool +is_same_buf(virtio_vdmabuf_buf_id_t a,

•        virtio_vdmabuf_buf_id_t b)
  

+{

• int i;
• if (a.id != b.id)

• return 1;
  

• /* compare keys */
• for (i = 0; i < 2; i++) {

• if (a.rng_key[i] != b.rng_key[i])
  

• 	return false;
  

• }
• return true;

+}

+/* find buf for given vdmabuf ID */ +static inline struct virtio_vdmabuf_buf +*virtio_vdmabuf_find_buf(struct virtio_vdmabuf_info *info,

• 	 virtio_vdmabuf_buf_id_t *buf_id)
  

+{

• struct virtio_vdmabuf_buf *found;
• hash_for_each_possible(info->buf_list, found, node, buf_id->id)

• if (is_same_buf(found->buf_id, *buf_id))
  

• 	return found;
  

• return NULL;

+}

+/* delete buf from hash */ +static inline int +virtio_vdmabuf_del_buf(struct virtio_vdmabuf_info *info,

•                   virtio_vdmabuf_buf_id_t *buf_id)
  

+{

• struct virtio_vdmabuf_buf *found;
• found = virtio_vdmabuf_find_buf(info, buf_id);
• if (!found)

• return -ENOENT;
  

• hash_del(&found->node);
• return 0;

+}

+#endif diff --git a/include/uapi/linux/virtio_ids.h b/include/uapi/linux/virtio_ids.h index bc1c0621f5ed..39c94637ddee 100644 --- a/include/uapi/linux/virtio_ids.h +++ b/include/uapi/linux/virtio_ids.h @@ -54,5 +54,6 @@ #define VIRTIO_ID_FS 26 /* virtio filesystem */ #define VIRTIO_ID_PMEM 27 /* virtio pmem */ #define VIRTIO_ID_MAC80211_HWSIM 29 /* virtio mac80211-hwsim */ +#define VIRTIO_ID_VDMABUF 40 /* virtio vdmabuf */

#endif /* _LINUX_VIRTIO_IDS_H */ diff --git a/include/uapi/linux/virtio_vdmabuf.h b/include/uapi/linux/virtio_vdmabuf.h new file mode 100644 index 000000000000..7bddaa04ddd6 --- /dev/null +++ b/include/uapi/linux/virtio_vdmabuf.h @@ -0,0 +1,99 @@ +// SPDX-License-Identifier: (MIT OR GPL-2.0)

+/*

• • Copyright © 2021 Intel Corporation
• • Permission is hereby granted, free of charge, to any person obtaining a
• • copy of this software and associated documentation files (the "Software"),
• • to deal in the Software without restriction, including without limitation
• • the rights to use, copy, modify, merge, publish, distribute, sublicense,
• • and/or sell copies of the Software, and to permit persons to whom the
• • Software is furnished to do so, subject to the following conditions:
• • The above copyright notice and this permission notice (including the next
• • paragraph) shall be included in all copies or substantial portions of the
• • Software.
• • THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
• • IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
• • FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
• • THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
• • LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
• • FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
• • IN THE SOFTWARE.
• */

+#ifndef _UAPI_LINUX_VIRTIO_VDMABUF_H +#define _UAPI_LINUX_VIRTIO_VDMABUF_H

+#define MAX_SIZE_PRIV_DATA 192

+typedef struct {

• __u64 id;
• /* 8B long Random number */
• int rng_key[2];

+} virtio_vdmabuf_buf_id_t;

+struct virtio_vdmabuf_e_hdr {

• /* buf_id of new buf */
• virtio_vdmabuf_buf_id_t buf_id;
• /* size of private data */
• int size;

+};

+struct virtio_vdmabuf_e_data {

• struct virtio_vdmabuf_e_hdr hdr;
• /* ptr to private data */
• void __user *data;

+};

+#define VIRTIO_VDMABUF_IOCTL_IMPORT \ +_IOC(_IOC_NONE, 'G', 2, sizeof(struct virtio_vdmabuf_import)) +#define VIRTIO_VDMABUF_IOCTL_RELEASE \ +_IOC(_IOC_NONE, 'G', 3, sizeof(struct virtio_vdmabuf_import)) +struct virtio_vdmabuf_import {

• /* IN parameters */
• /* ahdb buf id to be imported */
• virtio_vdmabuf_buf_id_t buf_id;
• /* flags */
• int flags;
• /* OUT parameters */
• /* exported dma buf fd */
• int fd;

+};

+#define VIRTIO_VDMABUF_IOCTL_EXPORT \ +_IOC(_IOC_NONE, 'G', 4, sizeof(struct virtio_vdmabuf_export)) +struct virtio_vdmabuf_export {

• /* IN parameters */
• /* DMA buf fd to be exported */
• int fd;
• /* exported dma buf id */
• virtio_vdmabuf_buf_id_t buf_id;
• int sz_priv;
• char *priv;

+};

+#define VIRTIO_VDMABUF_IOCTL_QUERY \ +_IOC(_IOC_NONE, 'G', 5, sizeof(struct virtio_vdmabuf_query)) +struct virtio_vdmabuf_query {

• /* in parameters */
• /* id of buf to be queried */
• virtio_vdmabuf_buf_id_t buf_id;
• /* item to be queried */
• int item;
• /* OUT parameters */
• /* Value of queried item */
• unsigned long info;

+};

+/* DMABUF query */ +enum virtio_vdmabuf_query_cmd {

• VIRTIO_VDMABUF_QUERY_SIZE = 0x10,
• VIRTIO_VDMABUF_QUERY_BUSY,
• VIRTIO_VDMABUF_QUERY_PRIV_INFO_SIZE,
• VIRTIO_VDMABUF_QUERY_PRIV_INFO,

+};

+#endif

2.26.2