/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#undef NDEBUG
extern "C" {
#include <linux/virtio_gpu.h>
#include <virglrenderer.h>
#include <virgl_hw.h>
}
#include <sys/uio.h>
#include <dlfcn.h>
#include <algorithm>
#include <cassert>
#include <cerrno>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <map>
#include <mutex>
#include <string>
#include <vector>
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <GLES/gl.h>
#include <GLES/glext.h>
#include <GLES3/gl31.h>
#include <GLES3/gl3ext.h>
#include <drm/drm_fourcc.h>
#include <OpenGLESDispatch/EGLDispatch.h>
#include <OpenGLESDispatch/GLESv1Dispatch.h>
#include <OpenGLESDispatch/GLESv3Dispatch.h>
#include "OpenglRender/IOStream.h"
#include "Context.h"
#include "EglConfig.h"
#include "EglContext.h"
#include "EglSurface.h"
#include "EglSync.h"
#include "Resource.h"
#include <VirtioGpuCmd.h>
// for debug only
#include <sys/syscall.h>
#include <unistd.h>
#define gettid() (int)syscall(__NR_gettid)
#ifndef PAGE_SIZE
#define PAGE_SIZE 0x1000
#endif
#define MAX_CMDRESPBUF_SIZE (10 * PAGE_SIZE)
#define ALIGN(A, B) (((A) + (B)-1) / (B) * (B))
// Enable passing scanout buffers as texture names to sdl2 backend
#define QEMU_HARDWARE_GL_INTEROP
#ifdef QEMU_HARDWARE_GL_INTEROP
typedef GLenum (*PFNGLGETERROR)(void);
typedef void (*PFNGLBINDTEXTURE)(GLenum target, GLuint texture);
typedef void (*PFNGLGENTEXTURES)(GLsizei n, GLuint* textures);
typedef void (*PFNGLTEXPARAMETERI)(GLenum target, GLenum pname, GLint param);
typedef void (*PFNGLPIXELSTOREI)(GLenum pname, GLint param);
typedef void (*PFNGLTEXIMAGE2D)(GLenum target, GLint level, GLint internalformat, GLsizei width,
GLsizei height, GLint border, GLenum format, GLenum type,
const void* pixels);
static PFNGLBINDTEXTURE g_glBindTexture;
static PFNGLGENTEXTURES g_glGenTextures;
static PFNGLTEXPARAMETERI g_glTexParameteri;
static PFNGLPIXELSTOREI g_glPixelStorei;
static PFNGLTEXIMAGE2D g_glTexImage2D;
static virgl_renderer_gl_context g_ctx0_alt;
#endif
// Global state
std::map<uint32_t, EglContext*> EglContext::map;
std::map<uint32_t, EglSurface*> EglSurface::map;
std::map<uint32_t, EglImage*> EglImage::map;
std::map<uint32_t, Resource*> Resource::map;
std::map<uint64_t, EglSync*> EglSync::map;
std::map<uint32_t, Context*> Context::map;
std::vector<EglConfig*> EglConfig::vec;
static virgl_renderer_callbacks* g_cb;
const EGLint EglConfig::kAttribs[];
uint32_t EglContext::nextId = 1U;
uint32_t EglSurface::nextId = 1U;
uint32_t EglImage::nextId = 1U;
uint64_t EglSync::nextId = 1U;
static void* g_cookie;
// Fence queue, must be thread safe
static std::mutex g_fence_deque_mutex;
static std::deque<int> g_fence_deque;
// Other GPU context and state
static EGLSurface g_ctx0_surface;
static EGLContext g_ctx0_es1;
static EGLContext g_ctx0_es2;
static EGLDisplay g_dpy;
// Last context receiving a command. Allows us to find the context a fence is
// being created for. Works around the poorly designed virgl interface.
static Context* g_last_submit_cmd_ctx;
#ifdef OPENGL_DEBUG_PRINTOUT
#include "emugl/common/logging.h"
// For logging from the protocol decoders
void default_logger(const char* fmt, ...) {
va_list ap;
va_start(ap, fmt);
vprintf(fmt, ap);
va_end(ap);
}
emugl_logger_t emugl_cxt_logger = default_logger;
#endif
static void dump_global_state(void) {
printf("AVDVIRGLRENDERER GLOBAL STATE\n\n");
printf("Resources:\n");
for (auto const& it : Resource::map) {
Resource const* res = it.second;
printf(
" Resource %u: %ux%u 0x%x %p (%zub) t=%u b=%u d=%u a=%u l=%u "
"n=%u f=%u\n",
res->args.handle, res->args.width, res->args.height, res->args.format,
res->iov ? res->iov[0].iov_base : nullptr, res->iov ? res->iov[0].iov_len : 0,
res->args.target, res->args.bind, res->args.depth, res->args.array_size,
res->args.last_level, res->args.nr_samples, res->args.flags);
for (auto const& it : res->context_map) {
Context const* ctx = it.second;
printf(" Context %u, pid=%d, tid=%d\n", ctx->handle, ctx->pid, ctx->tid);
}
}
printf("Contexts:\n");
for (auto const& it : Context::map) {
Context const* ctx = it.second;
printf(" Context %u: %s pid=%u tid=%u\n", ctx->handle, ctx->name.c_str(), ctx->pid,
ctx->tid);
for (auto const& it : ctx->resource_map) {
Resource const* res = it.second;
printf(" Resource %u\n", res->args.handle);
}
}
}
static int sync_linear_to_iovec(Resource* res, uint64_t offset, const virgl_box* box) {
uint32_t bpp;
switch (res->args.format) {
case VIRGL_FORMAT_R8_UNORM:
bpp = 1U;
break;
case VIRGL_FORMAT_B5G6R5_UNORM:
bpp = 2U;
break;
default:
bpp = 4U;
break;
}
if (box->x > res->args.width || box->y > res->args.height)
return 0;
if (box->w == 0U || box->h == 0U)
return 0;
uint32_t w = std::min(box->w, res->args.width - box->x);
uint32_t h = std::min(box->h, res->args.height - box->y);
uint32_t stride = ALIGN(res->args.width * bpp, 16U);
offset += box->y * stride + box->x * bpp;
size_t length = (h - 1U) * stride + w * bpp;
if (offset + length > res->linearSize)
return EINVAL;
if (res->num_iovs > 1) {
const char* linear = static_cast<const char*>(res->linear);
for (uint32_t i = 0, iovOffset = 0U; length && i < res->num_iovs; i++) {
if (iovOffset + res->iov[i].iov_len > offset) {
char* iov_base = static_cast<char*>(res->iov[i].iov_base);
size_t copyLength = std::min(length, res->iov[i].iov_len);
memcpy(iov_base + offset - iovOffset, linear, copyLength);
linear += copyLength;
offset += copyLength;
length -= copyLength;
}
iovOffset += res->iov[i].iov_len;
}
}
return 0;
}
static int sync_iovec_to_linear(Resource* res, uint64_t offset, const virgl_box* box) {
uint32_t bpp;
switch (res->args.format) {
case VIRGL_FORMAT_R8_UNORM:
bpp = 1U;
break;
case VIRGL_FORMAT_B5G6R5_UNORM:
bpp = 2U;
break;
default:
bpp = 4U;
break;
}
if (box->x > res->args.width || box->y > res->args.height)
return 0;
if (box->w == 0U || box->h == 0U)
return 0;
uint32_t w = std::min(box->w, res->args.width - box->x);
uint32_t h = std::min(box->h, res->args.height - box->y);
uint32_t stride = ALIGN(res->args.width * bpp, 16U);
offset += box->y * stride + box->x * bpp;
size_t length = (h - 1U) * stride + w * bpp;
if (offset + length > res->linearSize)
return EINVAL;
if (res->num_iovs > 1) {
char* linear = static_cast<char*>(res->linear);
for (uint32_t i = 0, iovOffset = 0U; length && i < res->num_iovs; i++) {
if (iovOffset + res->iov[i].iov_len > offset) {
const char* iov_base = static_cast<const char*>(res->iov[i].iov_base);
size_t copyLength = std::min(length, res->iov[i].iov_len);
memcpy(linear, iov_base + offset - iovOffset, copyLength);
linear += copyLength;
offset += copyLength;
length -= copyLength;
}
iovOffset += res->iov[i].iov_len;
}
}
return 0;
}
// The below API was defined by virglrenderer 'master', but does not seem to
// be used by QEMU, so just ignore it for now..
//
// virgl_renderer_get_rect
// virgl_renderer_get_fd_for_texture
// virgl_renderer_cleanup
// virgl_renderer_reset
// virgl_renderer_get_poll_fd
int virgl_renderer_init(void* cookie, int flags, virgl_renderer_callbacks* cb) {
if (!cookie || !cb)
return EINVAL;
if (flags != 0)
return ENOSYS;
if (cb->version != 1)
return ENOSYS;
#ifdef QEMU_HARDWARE_GL_INTEROP
// FIXME: If we just use "libGL.so" here, mesa's interception library returns
// stub dlsyms that do nothing at runtime, even after binding..
void* handle = dlopen(
"/usr/lib/x86_64-linux-gnu/nvidia/"
"current/libGL.so.384.111",
RTLD_NOW);
assert(handle != nullptr);
g_glBindTexture = (PFNGLBINDTEXTURE)dlsym(handle, "glBindTexture");
assert(g_glBindTexture != nullptr);
g_glGenTextures = (PFNGLGENTEXTURES)dlsym(handle, "glGenTextures");
assert(g_glGenTextures != nullptr);
g_glTexParameteri = (PFNGLTEXPARAMETERI)dlsym(handle, "glTexParameteri");
assert(g_glTexParameteri != nullptr);
g_glPixelStorei = (PFNGLPIXELSTOREI)dlsym(handle, "glPixelStorei");
assert(g_glPixelStorei != nullptr);
g_glTexImage2D = (PFNGLTEXIMAGE2D)dlsym(handle, "glTexImage2D");
assert(g_glTexImage2D != nullptr);
#endif
if (!egl_dispatch_init())
return ENOENT;
if (!gles1_dispatch_init())
return ENOENT;
if (!gles3_dispatch_init())
return ENOENT;
g_dpy = s_egl.eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (g_dpy == EGL_NO_DISPLAY) {
printf("Failed to open default EGL display\n");
return ENOENT;
}
if (!s_egl.eglInitialize(g_dpy, nullptr, nullptr)) {
printf("Failed to initialize EGL display\n");
g_dpy = EGL_NO_DISPLAY;
return ENOENT;
}
EGLint nConfigs;
if (!s_egl.eglGetConfigs(g_dpy, nullptr, 0, &nConfigs)) {
printf("Failed to retrieve number of EGL configs\n");
s_egl.eglTerminate(g_dpy);
g_dpy = EGL_NO_DISPLAY;
return ENOENT;
}
EGLConfig configs[nConfigs];
if (!s_egl.eglGetConfigs(g_dpy, configs, nConfigs, &nConfigs)) {
printf("Failed to retrieve EGL configs\n");
s_egl.eglTerminate(g_dpy);
g_dpy = EGL_NO_DISPLAY;
return ENOENT;
}
// Our static analyzer sees the `new`ing of `config` below without any sort
// of attempt to free it, and warns about it. Normally, it would catch that
// we're pushing it into a vector in the constructor, but it hits an
// internal evaluation limit when trying to evaluate the loop inside of the
// ctor. So, it never gets to see that we escape our newly-allocated
// `config` instance. Silence the warning, since it's incorrect.
// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
for (EGLint c = 0; c < nConfigs; c++) {
EGLint configId;
if (!s_egl.eglGetConfigAttrib(g_dpy, configs[c], EGL_CONFIG_ID, &configId)) {
printf("Failed to retrieve EGL config ID\n");
s_egl.eglTerminate(g_dpy);
g_dpy = EGL_NO_DISPLAY;
return ENOENT;
}
EglConfig* config =
new (std::nothrow) EglConfig(g_dpy, configs[c], s_egl.eglGetConfigAttrib);
if (!config)
return ENOMEM;
}
// clang-format off
EGLint const attrib_list[] = {
EGL_CONFORMANT, EGL_OPENGL_ES_BIT | EGL_OPENGL_ES3_BIT_KHR,
EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
EGL_NONE,
};
// clang-format on
EGLint num_config = 0;
EGLConfig config;
if (!s_egl.eglChooseConfig(g_dpy, attrib_list, &config, 1, &num_config) || num_config != 1) {
printf("Failed to select ES1 & ES3 capable EGL config\n");
s_egl.eglTerminate(g_dpy);
g_dpy = EGL_NO_DISPLAY;
return ENOENT;
}
// clang-format off
EGLint const pbuffer_attrib_list[] = {
EGL_WIDTH, 1,
EGL_HEIGHT, 1,
EGL_NONE
};
// clang-format on
g_ctx0_surface = s_egl.eglCreatePbufferSurface(g_dpy, config, pbuffer_attrib_list);
if (!g_ctx0_surface) {
printf("Failed to create pbuffer surface for context 0\n");
s_egl.eglTerminate(g_dpy);
g_dpy = EGL_NO_DISPLAY;
return ENOENT;
}
// clang-format off
EGLint const es1_attrib_list[] = {
EGL_CONTEXT_CLIENT_VERSION, 1,
EGL_NONE
};
// clang-format on
g_ctx0_es1 = s_egl.eglCreateContext(g_dpy, config, EGL_NO_CONTEXT, es1_attrib_list);
if (g_ctx0_es1 == EGL_NO_CONTEXT) {
printf("Failed to create ES1 context 0\n");
s_egl.eglDestroySurface(g_dpy, g_ctx0_surface);
s_egl.eglTerminate(g_dpy);
g_dpy = EGL_NO_DISPLAY;
return ENOENT;
}
// clang-format off
EGLint const es2_attrib_list[] = {
EGL_CONTEXT_CLIENT_VERSION, 3, // yes, 3
EGL_NONE
};
// clang-format on
g_ctx0_es2 = s_egl.eglCreateContext(g_dpy, config, EGL_NO_CONTEXT, es2_attrib_list);
if (g_ctx0_es2 == EGL_NO_CONTEXT) {
printf("Failed to create ES2 context 0\n");
s_egl.eglDestroySurface(g_dpy, g_ctx0_surface);
s_egl.eglDestroyContext(g_dpy, g_ctx0_es1);
g_ctx0_es1 = EGL_NO_CONTEXT;
s_egl.eglTerminate(g_dpy);
g_dpy = EGL_NO_DISPLAY;
}
#ifdef QEMU_HARDWARE_GL_INTEROP
// This is the hardware GPU context. In future, this code should probably
// be removed and SwiftShader be used for all presentation blits.
virgl_renderer_gl_ctx_param ctx_params = {
.major_ver = 3,
.minor_ver = 0,
};
g_ctx0_alt = cb->create_gl_context(cookie, 0, &ctx_params);
if (!g_ctx0_alt) {
printf("Failed to create hardware GL context 0\n");
s_egl.eglDestroySurface(g_dpy, g_ctx0_surface);
s_egl.eglDestroyContext(g_dpy, g_ctx0_es1);
g_ctx0_es1 = EGL_NO_CONTEXT;
s_egl.eglTerminate(g_dpy);
g_dpy = EGL_NO_DISPLAY;
}
// Test we can actually make it current; otherwise, bail
if (cb->make_current(cookie, 0, g_ctx0_alt)) {
printf("Failed to make hardware GL context 0 current\n");
cb->destroy_gl_context(cookie, g_ctx0_alt);
g_ctx0_alt = nullptr;
s_egl.eglDestroySurface(g_dpy, g_ctx0_surface);
s_egl.eglDestroyContext(g_dpy, g_ctx0_es1);
g_ctx0_es1 = EGL_NO_CONTEXT;
s_egl.eglTerminate(g_dpy);
g_dpy = EGL_NO_DISPLAY;
}
#endif
EglContext::nextId = 1U;
g_cookie = cookie;
g_cb = cb;
return 0;
}
void virgl_renderer_poll(void) {
std::lock_guard<std::mutex> lk(g_fence_deque_mutex);
for (auto fence : g_fence_deque)
g_cb->write_fence(g_cookie, fence);
g_fence_deque.clear();
}
void* virgl_renderer_get_cursor_data(uint32_t resource_id, uint32_t* width, uint32_t* height) {
if (!width || !height)
return nullptr;
std::map<uint32_t, Resource*>::iterator it;
it = Resource::map.find(resource_id);
if (it == Resource::map.end())
return nullptr;
Resource* res = it->second;
if (res->args.bind != VIRGL_RES_BIND_CURSOR)
return nullptr;
void* pixels = malloc(res->linearSize);
memcpy(pixels, res->linear, res->linearSize);
*height = res->args.height;
*width = res->args.width;
return pixels;
}
// NOTE: This function is called from thread context. Do not touch anything
// without a mutex to protect it from concurrent access. Everything else in
// libvirglrenderer is designed to be single-threaded *only*.
// Hack to serialize all calls into EGL or GLES functions due to bugs in
// swiftshader. This should be removed as soon as possible.
static std::mutex swiftshader_wa_mutex;
static void process_cmd(Context* ctx, char* buf, size_t bufSize, int fence) {
VirtioGpuCmd* cmd_resp = reinterpret_cast<VirtioGpuCmd*>(ctx->cmd_resp->linear);
IOStream stream(cmd_resp->buf, MAX_CMDRESPBUF_SIZE - sizeof(*cmd_resp));
{
std::lock_guard<std::mutex> lk(swiftshader_wa_mutex);
size_t decodedBytes;
decodedBytes = ctx->render_control.decode(buf, bufSize, &stream, &ctx->checksum_calc);
bufSize -= decodedBytes;
buf += decodedBytes;
decodedBytes = ctx->gles1.decode(buf, bufSize, &stream, &ctx->checksum_calc);
bufSize -= decodedBytes;
buf += decodedBytes;
decodedBytes = ctx->gles3.decode(buf, bufSize, &stream, &ctx->checksum_calc);
bufSize -= decodedBytes;
buf += decodedBytes;
}
assert(bufSize == 0);
cmd_resp->cmdSize += stream.getFlushSize();
printf("(tid %d) ctx %d: cmd %u, size %zu, fence %d\n", gettid(), ctx->handle, cmd_resp->op,
cmd_resp->cmdSize - sizeof(*cmd_resp), fence);
if (cmd_resp->cmdSize - sizeof(*cmd_resp) > 0) {
printf("(tid %d) ", gettid());
for (size_t i = 0; i < cmd_resp->cmdSize - sizeof(*cmd_resp); i++) {
printf("%.2x ", (unsigned char)cmd_resp->buf[i]);
}
printf("\n");
}
virgl_box box = {
.w = cmd_resp->cmdSize,
.h = 1,
};
sync_linear_to_iovec(ctx->cmd_resp, 0, &box);
{
std::lock_guard<std::mutex> lk(g_fence_deque_mutex);
g_fence_deque.push_back(fence);
}
}
int virgl_renderer_submit_cmd(void* buffer, int ctx_id, int ndw) {
VirtioGpuCmd* cmd = static_cast<VirtioGpuCmd*>(buffer);
size_t bufSize = sizeof(uint32_t) * ndw;
if (bufSize < sizeof(*cmd)) {
printf("bad buffer size, bufSize=%zu, ctx=%d\n", bufSize, ctx_id);
return -1;
}
printf("ctx %d: cmd %u, size %zu\n", ctx_id, cmd->op, cmd->cmdSize - sizeof(*cmd));
for (size_t i = 0; i < bufSize - sizeof(*cmd); i++) {
printf("%.2x ", (unsigned char)cmd->buf[i]);
}
printf("\n");
if (cmd->cmdSize < bufSize) {
printf("ignoring short command, cmdSize=%u, bufSize=%zu\n", cmd->cmdSize, bufSize);
return 0;
}
if (cmd->cmdSize > bufSize) {
printf("command would overflow buffer, cmdSize=%u, bufSize=%zu\n", cmd->cmdSize, bufSize);
return -1;
}
std::map<uint32_t, Context*>::iterator it;
it = Context::map.find((uint32_t)ctx_id);
if (it == Context::map.end()) {
printf("command submit from invalid context %d, ignoring\n", ctx_id);
return 0;
}
Context* ctx = it->second;
// When the context is created, the remote side should send a test command
// (op == 0) which we use to set up our link to this context's 'response
// buffer'. Only apps using EGL or GLES have this. Gralloc contexts will
// never hit this path because they do not submit 3D commands.
if (cmd->op == 0) {
std::map<uint32_t, Resource*>::iterator it;
it = Resource::map.find(*(uint32_t*)cmd->buf);
if (it != Resource::map.end()) {
Resource* res = it->second;
size_t cmdRespBufSize = 0U;
for (size_t i = 0; i < res->num_iovs; i++)
cmdRespBufSize += res->iov[i].iov_len;
if (cmdRespBufSize == MAX_CMDRESPBUF_SIZE)
ctx->cmd_resp = res;
}
}
if (!ctx->cmd_resp) {
printf("context command response page not set up, ctx=%d\n", ctx_id);
return -1;
}
VirtioGpuCmd* cmd_resp = reinterpret_cast<VirtioGpuCmd*>(ctx->cmd_resp->linear);
// We can configure bits of the response now. The size, and any message, will
// be updated later. This must be done even for the dummy 'op == 0' command.
cmd_resp->op = cmd->op;
cmd_resp->cmdSize = sizeof(*cmd_resp);
if (cmd->op == 0) {
// Send back a no-op response, just to keep the protocol in check
virgl_box box = {
.w = cmd_resp->cmdSize,
.h = 1,
};
sync_linear_to_iovec(ctx->cmd_resp, 0, &box);
} else {
// If the rcSetPuid command was already processed, this command will be
// processed by another thread. If not, the command data will be copied
// here and responded to when ctx->setFence() is called later.
ctx->submitCommand(buffer, bufSize);
}
g_last_submit_cmd_ctx = ctx;
return 0;
}
void virgl_renderer_get_cap_set(uint32_t set, uint32_t* max_ver, uint32_t* max_size) {
if (!max_ver || !max_size)
return;
printf("Request for caps version %u\n", set);
switch (set) {
case 1:
*max_ver = 1;
*max_size = sizeof(virgl_caps_v1);
break;
case 2:
*max_ver = 2;
*max_size = sizeof(virgl_caps_v2);
break;
default:
*max_ver = 0;
*max_size = 0;
break;
}
}
void virgl_renderer_fill_caps(uint32_t set, uint32_t, void* caps_) {
union virgl_caps* caps = static_cast<union virgl_caps*>(caps_);
EGLSurface old_read_surface, old_draw_surface;
GLfloat range[2] = { 0.0f, 0.0f };
bool fill_caps_v2 = false;
EGLContext old_context;
GLint max = 0;
if (!caps)
return;
// We don't need to handle caps yet, because our guest driver's features
// should be as close as possible to the host driver's. But maybe some day
// we'll support gallium shaders and the virgl control stream, so it seems
// like a good idea to set up the driver caps correctly..
// If this is broken, nothing will work properly
old_read_surface = s_egl.eglGetCurrentSurface(EGL_READ);
old_draw_surface = s_egl.eglGetCurrentSurface(EGL_DRAW);
old_context = s_egl.eglGetCurrentContext();
if (!s_egl.eglMakeCurrent(g_dpy, g_ctx0_surface, g_ctx0_surface, g_ctx0_es1)) {
printf("Failed to make ES1 context current\n");
return;
}
// Don't validate 'version' because it looks like this was misdesigned
// upstream and won't be set; instead, 'set' was bumped from 1->2.
switch (set) {
case 0:
case 1:
memset(caps, 0, sizeof(virgl_caps_v1));
caps->max_version = 1;
break;
case 2:
memset(caps, 0, sizeof(virgl_caps_v2));
caps->max_version = 2;
fill_caps_v2 = true;
break;
default:
caps->max_version = 0;
return;
}
if (fill_caps_v2) {
printf("Will probe and fill caps version 2.\n");
}
// Formats supported for textures
caps->v1.sampler.bitmask[0] = (1 << (VIRGL_FORMAT_B8G8R8A8_UNORM - (0 * 32))) |
(1 << (VIRGL_FORMAT_B5G6R5_UNORM - (0 * 32)));
caps->v1.sampler.bitmask[2] = (1 << (VIRGL_FORMAT_R8G8B8A8_UNORM - (2 * 32)));
caps->v1.sampler.bitmask[4] = (1 << (VIRGL_FORMAT_R8G8B8X8_UNORM - (4 * 32)));
// Formats supported for rendering
caps->v1.render.bitmask[0] = (1 << (VIRGL_FORMAT_B8G8R8A8_UNORM - (0 * 32))) |
(1 << (VIRGL_FORMAT_B5G6R5_UNORM - (0 * 32)));
caps->v1.render.bitmask[2] = (1 << (VIRGL_FORMAT_R8G8B8A8_UNORM - (2 * 32)));
caps->v1.render.bitmask[4] = (1 << (VIRGL_FORMAT_R8G8B8X8_UNORM - (4 * 32)));
// Could parse s_gles1.glGetString(GL_SHADING_LANGUAGE_VERSION, ...)?
caps->v1.glsl_level = 300; // OpenGL ES GLSL 3.00
// Call with any API (v1, v3) bound
caps->v1.max_viewports = 1;
s_gles1.glGetIntegerv(GL_MAX_DRAW_BUFFERS_EXT, &max);
caps->v1.max_render_targets = max;
s_gles1.glGetIntegerv(GL_MAX_SAMPLES_EXT, &max);
caps->v1.max_samples = max;
if (fill_caps_v2) {
s_gles1.glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, range);
caps->v2.min_aliased_point_size = range[0];
caps->v2.max_aliased_point_size = range[1];
s_gles1.glGetFloatv(GL_ALIASED_LINE_WIDTH_RANGE, range);
caps->v2.min_aliased_line_width = range[0];
caps->v2.max_aliased_line_width = range[1];
// An extension, but everybody has it
s_gles1.glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &max);
caps->v2.max_vertex_attribs = max;
// Call with ES 1.0 bound *only*
s_gles1.glGetFloatv(GL_SMOOTH_POINT_SIZE_RANGE, range);
caps->v2.min_smooth_point_size = range[0];
caps->v2.max_smooth_point_size = range[1];
s_gles1.glGetFloatv(GL_SMOOTH_LINE_WIDTH_RANGE, range);
caps->v2.min_smooth_line_width = range[0];
caps->v2.max_smooth_line_width = range[1];
}
if (!s_egl.eglMakeCurrent(g_dpy, g_ctx0_surface, g_ctx0_surface, g_ctx0_es2)) {
s_egl.eglMakeCurrent(g_dpy, old_draw_surface, old_read_surface, old_context);
printf("Failed to make ES3 context current\n");
return;
}
// Call with ES 3.0 bound *only*
caps->v1.bset.primitive_restart = 1;
caps->v1.bset.seamless_cube_map = 1;
caps->v1.bset.occlusion_query = 1;
caps->v1.bset.instanceid = 1;
caps->v1.bset.ubo = 1;
s_gles1.glGetIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS, &max);
caps->v1.max_texture_array_layers = max;
s_gles1.glGetIntegerv(GL_MAX_VERTEX_UNIFORM_BLOCKS, &max);
caps->v1.max_uniform_blocks = max + 1;
if (fill_caps_v2) {
s_gles1.glGetFloatv(GL_MAX_TEXTURE_LOD_BIAS, &caps->v2.max_texture_lod_bias);
s_gles1.glGetIntegerv(GL_MAX_VERTEX_OUTPUT_COMPONENTS, &max);
caps->v2.max_vertex_outputs = max / 4;
s_gles1.glGetIntegerv(GL_MIN_PROGRAM_TEXEL_OFFSET, &caps->v2.min_texel_offset);
s_gles1.glGetIntegerv(GL_MAX_PROGRAM_TEXEL_OFFSET, &caps->v2.max_texel_offset);
s_gles1.glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &max);
caps->v2.uniform_buffer_offset_alignment = max;
}
// ES 2.0 extensions (fixme)
// Gallium compatibility; not usable currently.
caps->v1.prim_mask = (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (1 << 4) | (1 << 5) | (1 << 6);
if (!s_egl.eglMakeCurrent(g_dpy, old_draw_surface, old_read_surface, old_context)) {
printf("Failed to make no context current\n");
}
}
int virgl_renderer_create_fence(int client_fence_id, uint32_t cmd_type) {
switch (cmd_type) {
case VIRTIO_GPU_CMD_SUBMIT_3D:
if (g_last_submit_cmd_ctx) {
g_last_submit_cmd_ctx->setFence(client_fence_id);
break;
}
[[fallthrough]];
default: {
std::lock_guard<std::mutex> lk(g_fence_deque_mutex);
g_fence_deque.push_back(client_fence_id);
break;
}
}
return 0;
}
void virgl_renderer_force_ctx_0(void) {
#ifdef QEMU_HARDWARE_GL_INTEROP
if (!g_ctx0_alt)
return;
if (g_cb->make_current(g_cookie, 0, g_ctx0_alt)) {
printf("Failed to make hardware GL context 0 current\n");
g_cb->destroy_gl_context(g_cookie, g_ctx0_alt);
g_ctx0_alt = nullptr;
}
#endif
}
int virgl_renderer_resource_create(virgl_renderer_resource_create_args* args, iovec* iov,
uint32_t num_iovs) {
if (!args)
return EINVAL;
if (args->bind == VIRGL_RES_BIND_CURSOR) {
// Enforce limitation of current virtio-gpu-3d implementation
if (args->width != 64 || args->height != 64 || args->format != VIRGL_FORMAT_B8G8R8A8_UNORM)
return EINVAL;
}
assert(!Resource::map.count(args->handle) && "Can't insert same resource twice!");
Resource* res = new (std::nothrow) Resource(args, num_iovs, iov);
if (!res)
return ENOMEM;
printf("Creating Resource %u (num_iovs=%u)\n", args->handle, num_iovs);
return 0;
}
void virgl_renderer_resource_unref(uint32_t res_handle) {
std::map<uint32_t, Resource*>::iterator it;
it = Resource::map.find(res_handle);
if (it == Resource::map.end())
return;
Resource* res = it->second;
for (auto const& it : Context::map) {
Context const* ctx = it.second;
virgl_renderer_ctx_detach_resource(ctx->handle, res->args.handle);
}
assert(res->context_map.empty() && "Deleted resource was associated with contexts");
printf("Deleting Resource %u\n", res_handle);
delete res;
}
int virgl_renderer_resource_attach_iov(int res_handle, iovec* iov, int num_iovs) {
std::map<uint32_t, Resource*>::iterator it;
it = Resource::map.find((uint32_t)res_handle);
if (it == Resource::map.end())
return ENOENT;
Resource* res = it->second;
if (!res->iov) {
printf(
"Attaching backing store for Resource %d "
"(num_iovs=%d)\n",
res_handle, num_iovs);
res->num_iovs = num_iovs;
res->iov = iov;
res->reallocLinear();
// Assumes that when resources are attached, they contain junk, and we
// don't need to synchronize with the linear buffer
}
return 0;
}
void virgl_renderer_resource_detach_iov(int res_handle, iovec** iov, int* num_iovs) {
std::map<uint32_t, Resource*>::iterator it;
it = Resource::map.find((uint32_t)res_handle);
if (it == Resource::map.end())
return;
Resource* res = it->second;
printf("Detaching backing store for Resource %d\n", res_handle);
// Synchronize our linear buffer, if any, with the iovec that we are about
// to give up. Most likely this is not required, but it seems cleaner.
virgl_box box = {
.w = res->args.width,
.h = res->args.height,
};
sync_linear_to_iovec(res, 0, &box);
if (num_iovs)
*num_iovs = res->num_iovs;
res->num_iovs = 0U;
if (iov)
*iov = res->iov;
res->iov = nullptr;
res->reallocLinear();
}
int virgl_renderer_resource_get_info(int res_handle, virgl_renderer_resource_info* info) {
if (!info)
return EINVAL;
std::map<uint32_t, Resource*>::iterator it;
it = Resource::map.find((uint32_t)res_handle);
if (it == Resource::map.end())
return ENOENT;
Resource* res = it->second;
uint32_t bpp = 4U;
switch (res->args.format) {
case VIRGL_FORMAT_B8G8R8A8_UNORM:
info->drm_fourcc = DRM_FORMAT_BGRA8888;
break;
case VIRGL_FORMAT_B5G6R5_UNORM:
info->drm_fourcc = DRM_FORMAT_BGR565;
bpp = 2U;
break;
case VIRGL_FORMAT_R8G8B8A8_UNORM:
info->drm_fourcc = DRM_FORMAT_RGBA8888;
break;
case VIRGL_FORMAT_R8G8B8X8_UNORM:
info->drm_fourcc = DRM_FORMAT_RGBX8888;
break;
default:
return EINVAL;
}
#ifdef QEMU_HARDWARE_GL_INTEROP
GLenum type = GL_UNSIGNED_BYTE;
GLenum format = GL_RGBA;
switch (res->args.format) {
case VIRGL_FORMAT_B8G8R8A8_UNORM:
format = 0x80E1; // GL_BGRA
break;
case VIRGL_FORMAT_B5G6R5_UNORM:
type = GL_UNSIGNED_SHORT_5_6_5;
format = GL_RGB;
break;
case VIRGL_FORMAT_R8G8B8X8_UNORM:
format = GL_RGB;
break;
}
if (!res->tex_id) {
g_glGenTextures(1, &res->tex_id);
g_glBindTexture(GL_TEXTURE_2D, res->tex_id);
g_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
g_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
g_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
g_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
} else {
g_glBindTexture(GL_TEXTURE_2D, res->tex_id);
}
g_glPixelStorei(GL_UNPACK_ROW_LENGTH, ALIGN(res->args.width, 16));
g_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, res->args.width, res->args.height, 0, format, type,
res->linear);
#endif
info->stride = ALIGN(res->args.width * bpp, 16U);
info->virgl_format = res->args.format;
info->handle = res->args.handle;
info->height = res->args.height;
info->width = res->args.width;
info->depth = res->args.depth;
info->flags = res->args.flags;
info->tex_id = res->tex_id;
printf("Scanning out Resource %d\n", res_handle);
dump_global_state();
return 0;
}
int virgl_renderer_context_create(uint32_t handle, uint32_t nlen, const char* name) {
assert(!Context::map.count(handle) && "Can't insert same context twice!");
Context* ctx = new (std::nothrow) Context(handle, name, nlen, process_cmd, g_dpy);
if (!ctx)
return ENOMEM;
printf("Creating Context %u (%.*s)\n", handle, (int)nlen, name);
return 0;
}
void virgl_renderer_context_destroy(uint32_t handle) {
std::map<uint32_t, Context*>::iterator it;
it = Context::map.find(handle);
if (it == Context::map.end())
return;
Context* ctx = it->second;
printf("Destroying Context %u\n", handle);
delete ctx;
}
int virgl_renderer_transfer_read_iov(uint32_t handle, uint32_t, uint32_t, uint32_t, uint32_t,
virgl_box* box, uint64_t offset, iovec*, int) {
// stride, layer_stride and level are not set by minigbm, so don't try to
// validate them right now. iov and iovec_cnt are always passed as nullptr
// and 0 by qemu, so ignore those too
std::map<uint32_t, Resource*>::iterator it;
it = Resource::map.find((uint32_t)handle);
if (it == Resource::map.end())
return EINVAL;
return sync_linear_to_iovec(it->second, offset, box);
}
int virgl_renderer_transfer_write_iov(uint32_t handle, uint32_t, int, uint32_t, uint32_t,
virgl_box* box, uint64_t offset, iovec*, unsigned int) {
// stride, layer_stride and level are not set by minigbm, so don't try to
// validate them right now. iov and iovec_cnt are always passed as nullptr
// and 0 by qemu, so ignore those too
std::map<uint32_t, Resource*>::iterator it;
it = Resource::map.find((uint32_t)handle);
if (it == Resource::map.end())
return EINVAL;
return sync_iovec_to_linear(it->second, offset, box);
}
void virgl_renderer_ctx_attach_resource(int ctx_id, int res_handle) {
std::map<uint32_t, Context*>::iterator ctx_it;
ctx_it = Context::map.find((uint32_t)ctx_id);
if (ctx_it == Context::map.end())
return;
Context* ctx = ctx_it->second;
assert(!ctx->resource_map.count((uint32_t)res_handle) &&
"Can't attach resource to context twice!");
std::map<uint32_t, Resource*>::iterator res_it;
res_it = Resource::map.find((uint32_t)res_handle);
if (res_it == Resource::map.end())
return;
Resource* res = res_it->second;
printf("Attaching Resource %d to Context %d\n", res_handle, ctx_id);
res->context_map.emplace((uint32_t)ctx_id, ctx);
ctx->resource_map.emplace((uint32_t)res_handle, res);
}
void virgl_renderer_ctx_detach_resource(int ctx_id, int res_handle) {
std::map<uint32_t, Context*>::iterator ctx_it;
ctx_it = Context::map.find((uint32_t)ctx_id);
if (ctx_it == Context::map.end())
return;
Context* ctx = ctx_it->second;
std::map<uint32_t, Resource*>::iterator res_it;
res_it = ctx->resource_map.find((uint32_t)res_handle);
if (res_it == ctx->resource_map.end())
return;
Resource* res = res_it->second;
ctx_it = res->context_map.find((uint32_t)ctx_id);
if (ctx_it == res->context_map.end())
return;
printf("Detaching Resource %d from Context %d\n", res_handle, ctx_id);
if (ctx->cmd_resp && ctx->cmd_resp->args.handle == (uint32_t)res_handle)
ctx->cmd_resp = nullptr;
ctx->resource_map.erase(res_it);
res->context_map.erase(ctx_it);
}