contrib/vhost-user-gpu/vugbm.c

   1 /*
   2  * Virtio vhost-user GPU Device
   3  *
   4  * DRM helpers
   5  *
   6  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   7  * See the COPYING file in the top-level directory.
   8  */
   9
  10 #include "qemu/osdep.h"
  11 #include "vugbm.h"
  12
  13 static bool
  14 mem_alloc_bo(struct vugbm_buffer *buf)
  15 {
  16     buf->mmap = g_malloc(buf->width * buf->height * 4);
  17     buf->stride = buf->width * 4;
  18     return true;
  19 }
  20
  21 static void
  22 mem_free_bo(struct vugbm_buffer *buf)
  23 {
  24     g_free(buf->mmap);
  25 }
  26
  27 static bool
  28 mem_map_bo(struct vugbm_buffer *buf)
  29 {
  30     return buf->mmap != NULL;
  31 }
  32
  33 static void
  34 mem_unmap_bo(struct vugbm_buffer *buf)
  35 {
  36 }
  37
  38 static void
  39 mem_device_destroy(struct vugbm_device *dev)
  40 {
  41 }
  42
  43 #ifdef CONFIG_MEMFD
  44 struct udmabuf_create {
  45         uint32_t memfd;
  46         uint32_t flags;
  47         uint64_t offset;
  48         uint64_t size;
  49 };
  50
  51 #define UDMABUF_CREATE _IOW('u', 0x42, struct udmabuf_create)
  52
  53 static size_t
  54 udmabuf_get_size(struct vugbm_buffer *buf)
  55 {
  56     return ROUND_UP(buf->width * buf->height * 4, qemu_real_host_page_size());
  57 }
  58
  59 static bool
  60 udmabuf_alloc_bo(struct vugbm_buffer *buf)
  61 {
  62     int ret;
  63
  64     buf->memfd = memfd_create("udmabuf-bo", MFD_ALLOW_SEALING);
  65     if (buf->memfd < 0) {
  66         return false;
  67     }
  68
  69     ret = ftruncate(buf->memfd, udmabuf_get_size(buf));
  70     if (ret < 0) {
  71         close(buf->memfd);
  72         return false;
  73     }
  74
  75     ret = fcntl(buf->memfd, F_ADD_SEALS, F_SEAL_SHRINK);
  76     if (ret < 0) {
  77         close(buf->memfd);
  78         return false;
  79     }
  80
  81     buf->stride = buf->width * 4;
  82
  83     return true;
  84 }
  85
  86 static void
  87 udmabuf_free_bo(struct vugbm_buffer *buf)
  88 {
  89     close(buf->memfd);
  90 }
  91
  92 static bool
  93 udmabuf_map_bo(struct vugbm_buffer *buf)
  94 {
  95     buf->mmap = mmap(NULL, udmabuf_get_size(buf),
  96                      PROT_READ | PROT_WRITE, MAP_SHARED, buf->memfd, 0);
  97     if (buf->mmap == MAP_FAILED) {
  98         return false;
  99     }
 100
 101     return true;
 102 }
 103
 104 static bool
 105 udmabuf_get_fd(struct vugbm_buffer *buf, int *fd)
 106 {
 107     struct udmabuf_create create = {
 108         .memfd = buf->memfd,
 109         .offset = 0,
 110         .size = udmabuf_get_size(buf),
 111     };
 112
 113     *fd = ioctl(buf->dev->fd, UDMABUF_CREATE, &create);
 114
 115     return *fd >= 0;
 116 }
 117
 118 static void
 119 udmabuf_unmap_bo(struct vugbm_buffer *buf)
 120 {
 121     munmap(buf->mmap, udmabuf_get_size(buf));
 122 }
 123
 124 static void
 125 udmabuf_device_destroy(struct vugbm_device *dev)
 126 {
 127     close(dev->fd);
 128 }
 129 #endif
 130
 131 #ifdef CONFIG_GBM
 132 static bool
 133 alloc_bo(struct vugbm_buffer *buf)
 134 {
 135     struct gbm_device *dev = buf->dev->dev;
 136
 137     assert(!buf->bo);
 138
 139     buf->bo = gbm_bo_create(dev, buf->width, buf->height,
 140                             buf->format,
 141                             GBM_BO_USE_RENDERING | GBM_BO_USE_LINEAR);
 142
 143     if (buf->bo) {
 144         buf->stride = gbm_bo_get_stride(buf->bo);
 145         return true;
 146     }
 147
 148     return false;
 149 }
 150
 151 static void
 152 free_bo(struct vugbm_buffer *buf)
 153 {
 154     gbm_bo_destroy(buf->bo);
 155 }
 156
 157 static bool
 158 map_bo(struct vugbm_buffer *buf)
 159 {
 160     uint32_t stride;
 161
 162     buf->mmap = gbm_bo_map(buf->bo, 0, 0, buf->width, buf->height,
 163                            GBM_BO_TRANSFER_READ_WRITE, &stride,
 164                            &buf->mmap_data);
 165
 166     assert(stride == buf->stride);
 167
 168     return buf->mmap != NULL;
 169 }
 170
 171 static void
 172 unmap_bo(struct vugbm_buffer *buf)
 173 {
 174     gbm_bo_unmap(buf->bo, buf->mmap_data);
 175 }
 176
 177 static bool
 178 get_fd(struct vugbm_buffer *buf, int *fd)
 179 {
 180     *fd = gbm_bo_get_fd(buf->bo);
 181
 182     return *fd >= 0;
 183 }
 184
 185 static void
 186 device_destroy(struct vugbm_device *dev)
 187 {
 188     gbm_device_destroy(dev->dev);
 189 }
 190 #endif
 191
 192 void
 193 vugbm_device_destroy(struct vugbm_device *dev)
 194 {
 195     if (!dev->inited) {
 196         return;
 197     }
 198
 199     dev->device_destroy(dev);
 200 }
 201
 202 void
 203 vugbm_device_init(struct vugbm_device *dev, int fd)
 204 {
 205     assert(!dev->inited);
 206
 207 #ifdef CONFIG_GBM
 208     if (fd >= 0) {
 209         dev->dev = gbm_create_device(fd);
 210     }
 211     if (dev->dev != NULL) {
 212         dev->fd = fd;
 213         dev->alloc_bo = alloc_bo;
 214         dev->free_bo = free_bo;
 215         dev->get_fd = get_fd;
 216         dev->map_bo = map_bo;
 217         dev->unmap_bo = unmap_bo;
 218         dev->device_destroy = device_destroy;
 219         dev->inited = true;
 220     }
 221 #endif
 222 #ifdef CONFIG_MEMFD
 223     if (!dev->inited && g_file_test("/dev/udmabuf", G_FILE_TEST_EXISTS)) {
 224         dev->fd = open("/dev/udmabuf", O_RDWR);
 225         if (dev->fd >= 0) {
 226             g_debug("Using experimental udmabuf backend");
 227             dev->alloc_bo = udmabuf_alloc_bo;
 228             dev->free_bo = udmabuf_free_bo;
 229             dev->get_fd = udmabuf_get_fd;
 230             dev->map_bo = udmabuf_map_bo;
 231             dev->unmap_bo = udmabuf_unmap_bo;
 232             dev->device_destroy = udmabuf_device_destroy;
 233             dev->inited = true;
 234         }
 235     }
 236 #endif
 237     if (!dev->inited) {
 238         g_debug("Using mem fallback");
 239         dev->alloc_bo = mem_alloc_bo;
 240         dev->free_bo = mem_free_bo;
 241         dev->map_bo = mem_map_bo;
 242         dev->unmap_bo = mem_unmap_bo;
 243         dev->device_destroy = mem_device_destroy;
 244         dev->inited = true;
 245     }
 246     assert(dev->inited);
 247 }
 248
 249 static bool
 250 vugbm_buffer_map(struct vugbm_buffer *buf)
 251 {
 252     struct vugbm_device *dev = buf->dev;
 253
 254     return dev->map_bo(buf);
 255 }
 256
 257 static void
 258 vugbm_buffer_unmap(struct vugbm_buffer *buf)
 259 {
 260     struct vugbm_device *dev = buf->dev;
 261
 262     dev->unmap_bo(buf);
 263 }
 264
 265 bool
 266 vugbm_buffer_can_get_dmabuf_fd(struct vugbm_buffer *buffer)
 267 {
 268     if (!buffer->dev->get_fd) {
 269         return false;
 270     }
 271
 272     return true;
 273 }
 274
 275 bool
 276 vugbm_buffer_get_dmabuf_fd(struct vugbm_buffer *buffer, int *fd)
 277 {
 278     if (!vugbm_buffer_can_get_dmabuf_fd(buffer) ||
 279         !buffer->dev->get_fd(buffer, fd)) {
 280         g_warning("Failed to get dmabuf");
 281         return false;
 282     }
 283
 284     if (*fd < 0) {
 285         g_warning("error: dmabuf_fd < 0");
 286         return false;
 287     }
 288
 289     return true;
 290 }
 291
 292 bool
 293 vugbm_buffer_create(struct vugbm_buffer *buffer, struct vugbm_device *dev,
 294                     uint32_t width, uint32_t height)
 295 {
 296     buffer->dev = dev;
 297     buffer->width = width;
 298     buffer->height = height;
 299     buffer->format = GBM_FORMAT_XRGB8888;
 300     buffer->stride = 0; /* modified during alloc */
 301     if (!dev->alloc_bo(buffer)) {
 302         g_warning("alloc_bo failed");
 303         return false;
 304     }
 305
 306     if (!vugbm_buffer_map(buffer)) {
 307         g_warning("map_bo failed");
 308         goto err;
 309     }
 310
 311     return true;
 312
 313 err:
 314     dev->free_bo(buffer);
 315     return false;
 316 }
 317
 318 void
 319 vugbm_buffer_destroy(struct vugbm_buffer *buffer)
 320 {
 321     struct vugbm_device *dev = buffer->dev;
 322
 323     vugbm_buffer_unmap(buffer);
 324     dev->free_bo(buffer);
 325 }