1 /* 2 * Virtio GPU Device 3 * 4 * Copyright Red Hat, Inc. 2013-2014 5 * 6 * Authors: 7 * Dave Airlie <airlied@redhat.com> 8 * Gerd Hoffmann <kraxel@redhat.com> 9 * 10 * This work is licensed under the terms of the GNU GPL, version 2 or later. 11 * See the COPYING file in the top-level directory. 12 */ 13 14 #include "qemu/osdep.h" 15 #include "qemu/units.h" 16 #include "qemu-common.h" 17 #include "qemu/iov.h" 18 #include "ui/console.h" 19 #include "hw/virtio/virtio-gpu.h" 20 #include "hw/virtio/virtio-gpu-pixman.h" 21 #include "trace.h" 22 #include "exec/ramblock.h" 23 #include "sysemu/hostmem.h" 24 #include <sys/ioctl.h> 25 #include <fcntl.h> 26 #include <linux/memfd.h> 27 #include "qemu/memfd.h" 28 #include "standard-headers/linux/udmabuf.h" 29 30 static void virtio_gpu_create_udmabuf(struct virtio_gpu_simple_resource *res) 31 { 32 struct udmabuf_create_list *list; 33 RAMBlock *rb; 34 ram_addr_t offset; 35 int udmabuf, i; 36 37 udmabuf = udmabuf_fd(); 38 if (udmabuf < 0) { 39 return; 40 } 41 42 list = g_malloc0(sizeof(struct udmabuf_create_list) + 43 sizeof(struct udmabuf_create_item) * res->iov_cnt); 44 45 for (i = 0; i < res->iov_cnt; i++) { 46 rcu_read_lock(); 47 rb = qemu_ram_block_from_host(res->iov[i].iov_base, false, &offset); 48 rcu_read_unlock(); 49 50 if (!rb || rb->fd < 0) { 51 g_free(list); 52 return; 53 } 54 55 list->list[i].memfd = rb->fd; 56 list->list[i].offset = offset; 57 list->list[i].size = res->iov[i].iov_len; 58 } 59 60 list->count = res->iov_cnt; 61 list->flags = UDMABUF_FLAGS_CLOEXEC; 62 63 res->dmabuf_fd = ioctl(udmabuf, UDMABUF_CREATE_LIST, list); 64 if (res->dmabuf_fd < 0) { 65 warn_report("%s: UDMABUF_CREATE_LIST: %s", __func__, 66 strerror(errno)); 67 } 68 g_free(list); 69 } 70 71 static void virtio_gpu_remap_udmabuf(struct virtio_gpu_simple_resource *res) 72 { 73 res->remapped = mmap(NULL, res->blob_size, PROT_READ, 74 MAP_SHARED, res->dmabuf_fd, 0); 75 if (res->remapped == MAP_FAILED) { 76 warn_report("%s: dmabuf mmap failed: %s", __func__, 77 strerror(errno)); 78 res->remapped = NULL; 79 } 80 } 81 82 static void virtio_gpu_destroy_udmabuf(struct virtio_gpu_simple_resource *res) 83 { 84 if (res->remapped) { 85 munmap(res->remapped, res->blob_size); 86 res->remapped = NULL; 87 } 88 if (res->dmabuf_fd >= 0) { 89 close(res->dmabuf_fd); 90 res->dmabuf_fd = -1; 91 } 92 } 93 94 static int find_memory_backend_type(Object *obj, void *opaque) 95 { 96 bool *memfd_backend = opaque; 97 int ret; 98 99 if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) { 100 HostMemoryBackend *backend = MEMORY_BACKEND(obj); 101 RAMBlock *rb = backend->mr.ram_block; 102 103 if (rb && rb->fd > 0) { 104 ret = fcntl(rb->fd, F_GET_SEALS); 105 if (ret > 0) { 106 *memfd_backend = true; 107 } 108 } 109 } 110 111 return 0; 112 } 113 114 bool virtio_gpu_have_udmabuf(void) 115 { 116 Object *memdev_root; 117 int udmabuf; 118 bool memfd_backend = false; 119 120 udmabuf = udmabuf_fd(); 121 if (udmabuf < 0) { 122 return false; 123 } 124 125 memdev_root = object_resolve_path("/objects", NULL); 126 object_child_foreach(memdev_root, find_memory_backend_type, &memfd_backend); 127 128 return memfd_backend; 129 } 130 131 void virtio_gpu_init_udmabuf(struct virtio_gpu_simple_resource *res) 132 { 133 void *pdata = NULL; 134 135 res->dmabuf_fd = -1; 136 if (res->iov_cnt == 1) { 137 pdata = res->iov[0].iov_base; 138 } else { 139 virtio_gpu_create_udmabuf(res); 140 if (res->dmabuf_fd < 0) { 141 return; 142 } 143 virtio_gpu_remap_udmabuf(res); 144 if (!res->remapped) { 145 return; 146 } 147 pdata = res->remapped; 148 } 149 150 res->blob = pdata; 151 } 152 153 void virtio_gpu_fini_udmabuf(struct virtio_gpu_simple_resource *res) 154 { 155 if (res->remapped) { 156 virtio_gpu_destroy_udmabuf(res); 157 } 158 } 159 160 static void virtio_gpu_free_dmabuf(VirtIOGPU *g, VGPUDMABuf *dmabuf) 161 { 162 struct virtio_gpu_scanout *scanout; 163 164 scanout = &g->parent_obj.scanout[dmabuf->scanout_id]; 165 dpy_gl_release_dmabuf(scanout->con, &dmabuf->buf); 166 QTAILQ_REMOVE(&g->dmabuf.bufs, dmabuf, next); 167 g_free(dmabuf); 168 } 169 170 static VGPUDMABuf 171 *virtio_gpu_create_dmabuf(VirtIOGPU *g, 172 uint32_t scanout_id, 173 struct virtio_gpu_simple_resource *res, 174 struct virtio_gpu_framebuffer *fb, 175 struct virtio_gpu_rect *r) 176 { 177 VGPUDMABuf *dmabuf; 178 179 if (res->dmabuf_fd < 0) { 180 return NULL; 181 } 182 183 dmabuf = g_new0(VGPUDMABuf, 1); 184 dmabuf->buf.width = fb->width; 185 dmabuf->buf.height = fb->height; 186 dmabuf->buf.stride = fb->stride; 187 dmabuf->buf.x = r->x; 188 dmabuf->buf.y = r->y; 189 dmabuf->buf.scanout_width = r->width; 190 dmabuf->buf.scanout_height = r->height; 191 dmabuf->buf.fourcc = qemu_pixman_to_drm_format(fb->format); 192 dmabuf->buf.fd = res->dmabuf_fd; 193 dmabuf->buf.allow_fences = true; 194 dmabuf->buf.draw_submitted = false; 195 dmabuf->scanout_id = scanout_id; 196 QTAILQ_INSERT_HEAD(&g->dmabuf.bufs, dmabuf, next); 197 198 return dmabuf; 199 } 200 201 int virtio_gpu_update_dmabuf(VirtIOGPU *g, 202 uint32_t scanout_id, 203 struct virtio_gpu_simple_resource *res, 204 struct virtio_gpu_framebuffer *fb, 205 struct virtio_gpu_rect *r) 206 { 207 struct virtio_gpu_scanout *scanout = &g->parent_obj.scanout[scanout_id]; 208 VGPUDMABuf *new_primary, *old_primary = NULL; 209 210 new_primary = virtio_gpu_create_dmabuf(g, scanout_id, res, fb, r); 211 if (!new_primary) { 212 return -EINVAL; 213 } 214 215 if (g->dmabuf.primary[scanout_id]) { 216 old_primary = g->dmabuf.primary[scanout_id]; 217 } 218 219 g->dmabuf.primary[scanout_id] = new_primary; 220 qemu_console_resize(scanout->con, 221 new_primary->buf.scanout_width, 222 new_primary->buf.scanout_height); 223 dpy_gl_scanout_dmabuf(scanout->con, &new_primary->buf); 224 225 if (old_primary) { 226 virtio_gpu_free_dmabuf(g, old_primary); 227 } 228 229 return 0; 230 } 231