/************************************************************************** * * Copyright (C) 2014 Red Hat Inc. * * 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 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. * **************************************************************************/ #include #include #include #include #include #include #include #include "pipe/p_state.h" #include "util/u_format.h" #include "util/u_math.h" #include "vrend_renderer.h" #include "virglrenderer.h" #include "virgl_context.h" #include "virgl_resource.h" #ifdef HAVE_EPOXY_EGL_H #include "virgl_gbm.h" #include "virgl_egl.h" #endif #ifdef HAVE_EPOXY_GLX_H #include "virgl_glx.h" static struct virgl_glx *glx_info; #endif /* new API - just wrap internal API for now */ static int virgl_renderer_resource_create_internal(struct virgl_renderer_resource_create_args *args, UNUSED struct iovec *iov, UNUSED uint32_t num_iovs, void *image) { int ret; struct pipe_resource *pipe_res; struct vrend_renderer_resource_create_args vrend_args = { 0 }; /* do not accept handle 0 */ if (args->handle == 0) return EINVAL; vrend_args.target = args->target; vrend_args.format = args->format; vrend_args.bind = args->bind; vrend_args.width = args->width; vrend_args.height = args->height; vrend_args.depth = args->depth; vrend_args.array_size = args->array_size; vrend_args.nr_samples = args->nr_samples; vrend_args.last_level = args->last_level; vrend_args.flags = args->flags; pipe_res = vrend_renderer_resource_create(&vrend_args, image); if (!pipe_res) return EINVAL; ret = virgl_resource_create_from_pipe(args->handle, pipe_res, iov, num_iovs); if (ret) { vrend_renderer_resource_destroy((struct vrend_resource *)pipe_res); return ret; } return 0; } int virgl_renderer_resource_create(struct virgl_renderer_resource_create_args *args, struct iovec *iov, uint32_t num_iovs) { return virgl_renderer_resource_create_internal(args, iov, num_iovs, NULL); } int virgl_renderer_resource_import_eglimage(struct virgl_renderer_resource_create_args *args, void *image) { #ifdef HAVE_EPOXY_EGL_H return virgl_renderer_resource_create_internal(args, NULL, 0, image); #else return EINVAL; #endif } void virgl_renderer_resource_set_priv(uint32_t res_handle, void *priv) { struct virgl_resource *res = virgl_resource_lookup(res_handle); if (!res) return; res->private_data = priv; } void *virgl_renderer_resource_get_priv(uint32_t res_handle) { struct virgl_resource *res = virgl_resource_lookup(res_handle); if (!res) return NULL; return res->private_data; } static bool detach_resource(struct virgl_context *ctx, void *data) { struct virgl_resource *res = data; ctx->detach_resource(ctx, res); return true; } void virgl_renderer_resource_unref(uint32_t res_handle) { struct virgl_resource *res = virgl_resource_lookup(res_handle); struct virgl_context_foreach_args args; if (!res) return; args.callback = detach_resource; args.data = res; virgl_context_foreach(&args); virgl_resource_remove(res->res_id); } void virgl_renderer_fill_caps(uint32_t set, uint32_t version, void *caps) { switch (set) { case VIRGL_CAPSET_VIRGL: case VIRGL_CAPSET_VIRGL2: vrend_renderer_fill_caps(set, version, (union virgl_caps *)caps); break; default: break; } } int virgl_renderer_context_create(uint32_t handle, uint32_t nlen, const char *name) { struct virgl_context *ctx; int ret; /* user context id must be greater than 0 */ if (handle == 0) return EINVAL; if (virgl_context_lookup(handle)) return 0; ctx = vrend_renderer_context_create(handle, nlen, name); if (!ctx) return ENOMEM; ret = virgl_context_add(ctx); if (ret) { ctx->destroy(ctx); return ret; } return 0; } void virgl_renderer_context_destroy(uint32_t handle) { virgl_context_remove(handle); } int virgl_renderer_submit_cmd(void *buffer, int ctx_id, int ndw) { struct virgl_context *ctx = virgl_context_lookup(ctx_id); if (!ctx) return EINVAL; return ctx->submit_cmd(ctx, buffer, sizeof(uint32_t) * ndw); } int virgl_renderer_transfer_write_iov(uint32_t handle, uint32_t ctx_id, int level, uint32_t stride, uint32_t layer_stride, struct virgl_box *box, uint64_t offset, struct iovec *iovec, unsigned int iovec_cnt) { struct virgl_resource *res = virgl_resource_lookup(handle); struct vrend_transfer_info transfer_info; if (!res) return EINVAL; transfer_info.level = level; transfer_info.stride = stride; transfer_info.layer_stride = layer_stride; transfer_info.box = (struct pipe_box *)box; transfer_info.offset = offset; transfer_info.iovec = iovec; transfer_info.iovec_cnt = iovec_cnt; transfer_info.synchronized = false; if (ctx_id) { struct virgl_context *ctx = virgl_context_lookup(ctx_id); if (!ctx) return EINVAL; return ctx->transfer_3d(ctx, res, &transfer_info, VIRGL_TRANSFER_TO_HOST); } else { if (!res->pipe_resource) return EINVAL; return vrend_renderer_transfer_pipe(res->pipe_resource, &transfer_info, VIRGL_TRANSFER_TO_HOST); } } int virgl_renderer_transfer_read_iov(uint32_t handle, uint32_t ctx_id, uint32_t level, uint32_t stride, uint32_t layer_stride, struct virgl_box *box, uint64_t offset, struct iovec *iovec, int iovec_cnt) { struct virgl_resource *res = virgl_resource_lookup(handle); struct vrend_transfer_info transfer_info; if (!res) return EINVAL; transfer_info.level = level; transfer_info.stride = stride; transfer_info.layer_stride = layer_stride; transfer_info.box = (struct pipe_box *)box; transfer_info.offset = offset; transfer_info.iovec = iovec; transfer_info.iovec_cnt = iovec_cnt; transfer_info.synchronized = false; if (ctx_id) { struct virgl_context *ctx = virgl_context_lookup(ctx_id); if (!ctx) return EINVAL; return ctx->transfer_3d(ctx, res, &transfer_info, VIRGL_TRANSFER_FROM_HOST); } else { if (!res->pipe_resource) return EINVAL; return vrend_renderer_transfer_pipe(res->pipe_resource, &transfer_info, VIRGL_TRANSFER_FROM_HOST); } } int virgl_renderer_resource_attach_iov(int res_handle, struct iovec *iov, int num_iovs) { struct virgl_resource *res = virgl_resource_lookup(res_handle); if (!res) return EINVAL; return virgl_resource_attach_iov(res, iov, num_iovs); } void virgl_renderer_resource_detach_iov(int res_handle, struct iovec **iov_p, int *num_iovs_p) { struct virgl_resource *res = virgl_resource_lookup(res_handle); if (!res) return; if (iov_p) *iov_p = (struct iovec *)res->iov; if (num_iovs_p) *num_iovs_p = res->iov_count; virgl_resource_detach_iov(res); } int virgl_renderer_create_fence(int client_fence_id, uint32_t ctx_id) { return vrend_renderer_create_fence(client_fence_id, ctx_id); } void virgl_renderer_force_ctx_0(void) { vrend_renderer_force_ctx_0(); } void virgl_renderer_ctx_attach_resource(int ctx_id, int res_handle) { struct virgl_context *ctx = virgl_context_lookup(ctx_id); struct virgl_resource *res = virgl_resource_lookup(res_handle); if (!ctx || !res) return; ctx->attach_resource(ctx, res); } void virgl_renderer_ctx_detach_resource(int ctx_id, int res_handle) { struct virgl_context *ctx = virgl_context_lookup(ctx_id); struct virgl_resource *res = virgl_resource_lookup(res_handle); if (!ctx || !res) return; ctx->detach_resource(ctx, res); } int virgl_renderer_resource_get_info(int res_handle, struct virgl_renderer_resource_info *info) { struct virgl_resource *res = virgl_resource_lookup(res_handle); int ret; if (!res || !res->pipe_resource) return EINVAL; if (!info) return EINVAL; ret = vrend_renderer_resource_get_info(res->pipe_resource, (struct vrend_renderer_resource_info *)info); info->handle = res_handle; #ifdef HAVE_EPOXY_EGL_H if (ret == 0 && use_context == CONTEXT_EGL) return virgl_egl_get_fourcc_for_texture(egl, info->tex_id, info->virgl_format, &info->drm_fourcc); #endif return ret; } void virgl_renderer_get_cap_set(uint32_t cap_set, uint32_t *max_ver, uint32_t *max_size) { switch (cap_set) { case VIRGL_CAPSET_VIRGL: case VIRGL_CAPSET_VIRGL2: vrend_renderer_get_cap_set(cap_set, max_ver, max_size); break; default: *max_ver = 0; *max_size = 0; break; } } void virgl_renderer_get_rect(int resource_id, struct iovec *iov, unsigned int num_iovs, uint32_t offset, int x, int y, int width, int height) { struct virgl_resource *res = virgl_resource_lookup(resource_id); if (!res || !res->pipe_resource) return; vrend_renderer_get_rect(res->pipe_resource, iov, num_iovs, offset, x, y, width, height); } static struct virgl_renderer_callbacks *rcbs; static void *dev_cookie; static struct vrend_if_cbs virgl_cbs; static void virgl_write_fence(uint32_t fence_id) { rcbs->write_fence(dev_cookie, fence_id); } static virgl_renderer_gl_context create_gl_context(int scanout_idx, struct virgl_gl_ctx_param *param) { struct virgl_renderer_gl_ctx_param vparam; #ifdef HAVE_EPOXY_EGL_H if (use_context == CONTEXT_EGL) return virgl_egl_create_context(egl, param); #endif #ifdef HAVE_EPOXY_GLX_H if (use_context == CONTEXT_GLX) return virgl_glx_create_context(glx_info, param); #endif vparam.version = 1; vparam.shared = param->shared; vparam.major_ver = param->major_ver; vparam.minor_ver = param->minor_ver; return rcbs->create_gl_context(dev_cookie, scanout_idx, &vparam); } static void destroy_gl_context(virgl_renderer_gl_context ctx) { #ifdef HAVE_EPOXY_EGL_H if (use_context == CONTEXT_EGL) { virgl_egl_destroy_context(egl, ctx); return; } #endif #ifdef HAVE_EPOXY_GLX_H if (use_context == CONTEXT_GLX) { virgl_glx_destroy_context(glx_info, ctx); return; } #endif rcbs->destroy_gl_context(dev_cookie, ctx); } static int make_current(virgl_renderer_gl_context ctx) { #ifdef HAVE_EPOXY_EGL_H if (use_context == CONTEXT_EGL) return virgl_egl_make_context_current(egl, ctx); #endif #ifdef HAVE_EPOXY_GLX_H if (use_context == CONTEXT_GLX) return virgl_glx_make_context_current(glx_info, ctx); #endif return rcbs->make_current(dev_cookie, 0, ctx); } static struct vrend_if_cbs virgl_cbs = { virgl_write_fence, create_gl_context, destroy_gl_context, make_current, }; void *virgl_renderer_get_cursor_data(uint32_t resource_id, uint32_t *width, uint32_t *height) { struct virgl_resource *res = virgl_resource_lookup(resource_id); if (!res || !res->pipe_resource) return NULL; vrend_renderer_force_ctx_0(); return vrend_renderer_get_cursor_contents(res->pipe_resource, width, height); } void virgl_renderer_poll(void) { vrend_renderer_check_fences(); } void virgl_renderer_cleanup(UNUSED void *cookie) { vrend_renderer_fini(); virgl_context_table_cleanup(); #ifdef HAVE_EPOXY_EGL_H if (use_context == CONTEXT_EGL) { virgl_egl_destroy(egl); egl = NULL; use_context = CONTEXT_NONE; if (gbm) { virgl_gbm_fini(gbm); gbm = NULL; } } #endif #ifdef HAVE_EPOXY_GLX_H if (use_context == CONTEXT_GLX) { virgl_glx_destroy(glx_info); glx_info = NULL; use_context = CONTEXT_NONE; } #endif } int virgl_renderer_init(void *cookie, int flags, struct virgl_renderer_callbacks *cbs) { uint32_t renderer_flags = 0; if (!cookie || !cbs) return -1; if (cbs->version < 1 || cbs->version > VIRGL_RENDERER_CALLBACKS_VERSION) return -1; dev_cookie = cookie; rcbs = cbs; if (flags & VIRGL_RENDERER_USE_EGL) { #ifdef HAVE_EPOXY_EGL_H int fd = -1; if (cbs->version >= 2 && cbs->get_drm_fd) { fd = cbs->get_drm_fd(cookie); } /* * If the user specifies a preferred DRM fd and we can't use it, fail. If the user doesn't * specify an fd, it's possible to initialize EGL without one. */ gbm = virgl_gbm_init(fd); if (fd > 0 && !gbm) return -1; egl = virgl_egl_init(gbm, flags & VIRGL_RENDERER_USE_SURFACELESS, flags & VIRGL_RENDERER_USE_GLES); if (!egl) { if (gbm) { virgl_gbm_fini(gbm); gbm = NULL; } return -1; } use_context = CONTEXT_EGL; #else vrend_printf( "EGL is not supported on this platform\n"); return -1; #endif } else if (flags & VIRGL_RENDERER_USE_GLX) { #ifdef HAVE_EPOXY_GLX_H glx_info = virgl_glx_init(); if (!glx_info) return -1; use_context = CONTEXT_GLX; #else vrend_printf( "GLX is not supported on this platform\n"); return -1; #endif } if (virgl_context_table_init()) return -1; if (flags & VIRGL_RENDERER_THREAD_SYNC) renderer_flags |= VREND_USE_THREAD_SYNC; if (flags & VIRGL_RENDERER_USE_EXTERNAL_BLOB) renderer_flags |= VREND_USE_EXTERNAL_BLOB; return vrend_renderer_init(&virgl_cbs, renderer_flags); } int virgl_renderer_get_fd_for_texture(uint32_t tex_id, int *fd) { #ifdef HAVE_EPOXY_EGL_H if (!egl) return -1; return virgl_egl_get_fd_for_texture(egl, tex_id, fd); #else return -1; #endif } int virgl_renderer_get_fd_for_texture2(uint32_t tex_id, int *fd, int *stride, int *offset) { #ifdef HAVE_EPOXY_EGL_H if (!egl) return -1; return virgl_egl_get_fd_for_texture2(egl, tex_id, fd, stride, offset); #else return -1; #endif } void virgl_renderer_reset(void) { vrend_renderer_reset(); } int virgl_renderer_get_poll_fd(void) { return vrend_renderer_get_poll_fd(); } virgl_debug_callback_type virgl_set_debug_callback(virgl_debug_callback_type cb) { return vrend_set_debug_callback(cb); } static int virgl_renderer_export_query(void *execute_args, uint32_t execute_size) { struct virgl_resource *res; struct virgl_renderer_export_query *export_query = execute_args; if (execute_size != sizeof(struct virgl_renderer_export_query)) return -EINVAL; if (export_query->hdr.size != sizeof(struct virgl_renderer_export_query)) return -EINVAL; res = virgl_resource_lookup(export_query->in_resource_id); if (!res || !res->pipe_resource) return -EINVAL; return vrend_renderer_export_query(res->pipe_resource, export_query); } static int virgl_renderer_supported_structures(void *execute_args, uint32_t execute_size) { struct virgl_renderer_supported_structures *supported_structures = execute_args; if (execute_size != sizeof(struct virgl_renderer_supported_structures)) return -EINVAL; if (supported_structures->hdr.size != sizeof(struct virgl_renderer_supported_structures)) return -EINVAL; if (supported_structures->in_stype_version == 0) { supported_structures->out_supported_structures_mask = VIRGL_RENDERER_STRUCTURE_TYPE_EXPORT_QUERY | VIRGL_RENDERER_STRUCTURE_TYPE_SUPPORTED_STRUCTURES; } else { supported_structures->out_supported_structures_mask = 0; } return 0; } int virgl_renderer_execute(void *execute_args, uint32_t execute_size) { struct virgl_renderer_hdr *hdr = execute_args; if (hdr->stype_version != 0) return -EINVAL; switch (hdr->stype) { case VIRGL_RENDERER_STRUCTURE_TYPE_SUPPORTED_STRUCTURES: return virgl_renderer_supported_structures(execute_args, execute_size); case VIRGL_RENDERER_STRUCTURE_TYPE_EXPORT_QUERY: return virgl_renderer_export_query(execute_args, execute_size); default: return -EINVAL; } } int virgl_renderer_resource_create_blob(const struct virgl_renderer_resource_create_blob_args *args) { struct virgl_context *ctx; struct virgl_context_blob blob; bool has_host_storage; bool has_guest_storage; int ret; switch (args->blob_mem) { case VIRGL_RENDERER_BLOB_MEM_GUEST: has_host_storage = false; has_guest_storage = true; break; case VIRGL_RENDERER_BLOB_MEM_HOST3D: has_host_storage = true; has_guest_storage = false; break; case VIRGL_RENDERER_BLOB_MEM_HOST3D_GUEST: has_host_storage = true; has_guest_storage = true; break; default: return -EINVAL; } /* user resource id must be greater than 0 */ if (args->res_handle == 0) return -EINVAL; if (args->size == 0) return -EINVAL; if (has_guest_storage) { const size_t iov_size = vrend_get_iovec_size(args->iovecs, args->num_iovs); if (iov_size < args->size) return -EINVAL; } else { if (args->num_iovs) return -EINVAL; } if (!has_host_storage) { return virgl_resource_create_from_iov(args->res_handle, args->iovecs, args->num_iovs); } ctx = virgl_context_lookup(args->ctx_id); if (!ctx) return -EINVAL; ret = ctx->get_blob(ctx, args->blob_id, args->blob_flags, &blob); if (ret) return ret; if (blob.type != VIRGL_RESOURCE_FD_INVALID) { ret = virgl_resource_create_from_fd(args->res_handle, blob.type, blob.u.fd, args->iovecs, args->num_iovs); if (ret) { close(blob.u.fd); return ret; } } else { ret = virgl_resource_create_from_pipe(args->res_handle, blob.u.pipe_resource, args->iovecs, args->num_iovs); if (ret) { vrend_renderer_resource_destroy((struct vrend_resource *)blob.u.pipe_resource); return ret; } } if (ctx->get_blob_done) ctx->get_blob_done(ctx, args->res_handle, &blob); return 0; } int virgl_renderer_resource_map(uint32_t res_handle, void **map, uint64_t *out_size) { struct virgl_resource *res = virgl_resource_lookup(res_handle); if (!res || !res->pipe_resource) return -EINVAL; return vrend_renderer_resource_map(res->pipe_resource, map, out_size); } int virgl_renderer_resource_unmap(uint32_t res_handle) { struct virgl_resource *res = virgl_resource_lookup(res_handle); if (!res || !res->pipe_resource) return -EINVAL; return vrend_renderer_resource_unmap(res->pipe_resource); } int virgl_renderer_resource_get_map_info(uint32_t res_handle, uint32_t *map_info) { struct virgl_resource *res = virgl_resource_lookup(res_handle); if (!res || !res->pipe_resource) return -EINVAL; return vrend_renderer_resource_get_map_info(res->pipe_resource, map_info); } int virgl_renderer_resource_export_blob(uint32_t res_id, uint32_t *fd_type, int *fd) { struct virgl_resource *res = virgl_resource_lookup(res_id); if (!res) return EINVAL; switch (virgl_resource_export_fd(res, fd)) { case VIRGL_RESOURCE_FD_DMABUF: *fd_type = VIRGL_RENDERER_BLOB_FD_TYPE_DMABUF; break; case VIRGL_RESOURCE_FD_OPAQUE: *fd_type = VIRGL_RENDERER_BLOB_FD_TYPE_OPAQUE; break; default: return EINVAL; } return 0; }