Support restarting the OpenGL compositor on Wayland

Summary:
KWin needs to support restarting the OpenGL compositor in case of a
graphics reset event.

On Wayland the tricky part is that the applications should not notice
this. Most importantly KWin cannot just destroy the EGLDisplay and create
a new one. But this is how a restart works: the complete compositor gets
torn down and recreated - including the EGLDisplay.

This change moves ownership of the EGLDisplay to the Platform.
The AbstractEglBackend subclasses query the Platform whether there is
already an EGLDisplay. Only if there is no EGLDisplay the EGLDisplay is
created and only if no EGLDisplay is registered with Wayland the bind
is performed.

Another change is regarding the destruction: the AbstractEglDisplay does
no longer unbind the Wayland display and does no longer destroy the
EGLDisplay. The EGLDisplay is destroyed by the Platform - so very late
on application exit. The Wayland display is unbound when the Compositor
terminates.

Test Plan:
Limited testing with the added auto-test. This one needs to
be extended to fully verify that OpenGL applications continue to work.
But this requires build.kde.org to support OpenGL on Wayland.

Reviewers: #kwin, #plasma_on_wayland

Subscribers: plasma-devel, kwin

Tags: #plasma_on_wayland, #kwin

Differential Revision: https://phabricator.kde.org/D2202
This commit is contained in:
Martin Gräßlin 2016-07-18 10:27:56 +02:00
parent d0c488f4a2
commit 9d7ef58b2b
12 changed files with 203 additions and 67 deletions

View file

@ -19,6 +19,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
#include "abstract_egl_backend.h"
#include "options.h"
#include "platform.h"
#include "wayland_server.h"
#include <KWayland/Server/buffer_interface.h>
#include <KWayland/Server/display.h>
@ -56,16 +57,20 @@ AbstractEglBackend::AbstractEglBackend()
AbstractEglBackend::~AbstractEglBackend() = default;
void AbstractEglBackend::unbindWaylandDisplay()
{
auto display = kwinApp()->platform()->sceneEglDisplay();
if (eglUnbindWaylandDisplayWL && display != EGL_NO_DISPLAY) {
eglUnbindWaylandDisplayWL(display, *(WaylandServer::self()->display()));
}
}
void AbstractEglBackend::cleanup()
{
if (eglUnbindWaylandDisplayWL && eglDisplay() != EGL_NO_DISPLAY) {
eglUnbindWaylandDisplayWL(eglDisplay(), *(WaylandServer::self()->display()));
}
cleanupGL();
doneCurrent();
eglDestroyContext(m_display, m_context);
cleanupSurfaces();
eglTerminate(m_display);
eglReleaseThread();
}
@ -137,11 +142,14 @@ void AbstractEglBackend::initWayland()
eglBindWaylandDisplayWL = (eglBindWaylandDisplayWL_func)eglGetProcAddress("eglBindWaylandDisplayWL");
eglUnbindWaylandDisplayWL = (eglUnbindWaylandDisplayWL_func)eglGetProcAddress("eglUnbindWaylandDisplayWL");
eglQueryWaylandBufferWL = (eglQueryWaylandBufferWL_func)eglGetProcAddress("eglQueryWaylandBufferWL");
if (!eglBindWaylandDisplayWL(eglDisplay(), *(WaylandServer::self()->display()))) {
eglUnbindWaylandDisplayWL = nullptr;
eglQueryWaylandBufferWL = nullptr;
} else {
waylandServer()->display()->setEglDisplay(eglDisplay());
// only bind if not already done
if (waylandServer()->display()->eglDisplay() != eglDisplay()) {
if (!eglBindWaylandDisplayWL(eglDisplay(), *(WaylandServer::self()->display()))) {
eglUnbindWaylandDisplayWL = nullptr;
eglQueryWaylandBufferWL = nullptr;
} else {
waylandServer()->display()->setEglDisplay(eglDisplay());
}
}
}
}
@ -263,6 +271,11 @@ bool AbstractEglBackend::createContext()
return true;
}
void AbstractEglBackend::setEglDisplay(const EGLDisplay &display) {
m_display = display;
kwinApp()->platform()->setSceneEglDisplay(display);
}
AbstractEglTexture::AbstractEglTexture(SceneOpenGL::Texture *texture, AbstractEglBackend *backend)
: SceneOpenGL::TexturePrivate()
, q(texture)

View file

@ -40,6 +40,8 @@ public:
return m_context;
}
static void unbindWaylandDisplay();
protected:
AbstractEglBackend();
EGLSurface surface() const {
@ -48,9 +50,7 @@ protected:
EGLConfig config() const {
return m_config;
}
void setEglDisplay(const EGLDisplay &display) {
m_display = display;
}
void setEglDisplay(const EGLDisplay &display);
void setSurface(const EGLSurface &surface) {
m_surface = surface;
}

View file

@ -34,6 +34,7 @@ integrationTest(NAME testMaximized SRCS maximize_test.cpp)
integrationTest(NAME testShellClient SRCS shell_client_test.cpp)
integrationTest(NAME testDontCrashNoBorder SRCS dont_crash_no_border.cpp)
integrationTest(NAME testXClipboardSync SRCS xclipboardsync_test.cpp)
integrationTest(NAME testSceneOpenGL SRCS scene_opengl_test.cpp)
integrationTest(NAME testSceneQPainter SRCS scene_qpainter_test.cpp)
integrationTest(NAME testNoXdgRuntimeDir SRCS no_xdg_runtime_dir_test.cpp)
integrationTest(NAME testScreenChanges SRCS screen_changes_test.cpp)

View file

@ -0,0 +1,103 @@
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
#include "kwin_wayland_test.h"
#include "composite.h"
#include "effectloader.h"
#include "cursor.h"
#include "platform.h"
#include "scene_opengl.h"
#include "shell_client.h"
#include "wayland_server.h"
#include "effect_builtins.h"
#include <KConfigGroup>
using namespace KWin;
static const QString s_socketName = QStringLiteral("wayland_test_kwin_scene_opengl-0");
class SceneOpenGLTest : public QObject
{
Q_OBJECT
private Q_SLOTS:
void initTestCase();
void cleanup();
void testRestart();
};
void SceneOpenGLTest::cleanup()
{
Test::destroyWaylandConnection();
}
void SceneOpenGLTest::initTestCase()
{
if (!QFile::exists(QStringLiteral("/dev/dri/card0"))) {
QSKIP("Needs a dri device");
}
qRegisterMetaType<KWin::ShellClient*>();
qRegisterMetaType<KWin::AbstractClient*>();
QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
QVERIFY(workspaceCreatedSpy.isValid());
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
// disable all effects - we don't want to have it interact with the rendering
auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
KConfigGroup plugins(config, QStringLiteral("Plugins"));
ScriptedEffectLoader loader;
const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
for (QString name : builtinNames) {
plugins.writeEntry(name + QStringLiteral("Enabled"), false);
}
config->sync();
kwinApp()->setConfig(config);
qputenv("XCURSOR_THEME", QByteArrayLiteral("DMZ-White"));
qputenv("XCURSOR_SIZE", QByteArrayLiteral("24"));
qputenv("KWIN_COMPOSE", QByteArrayLiteral("O2"));
kwinApp()->start();
QVERIFY(workspaceCreatedSpy.wait());
QVERIFY(Compositor::self());
}
void SceneOpenGLTest::testRestart()
{
// simple restart of the OpenGL compositor without any windows being shown
QSignalSpy sceneCreatedSpy(KWin::Compositor::self(), &Compositor::sceneCreated);
QVERIFY(sceneCreatedSpy.isValid());
KWin::Compositor::self()->slotReinitialize();
if (sceneCreatedSpy.isEmpty()) {
QVERIFY(sceneCreatedSpy.wait());
}
QCOMPARE(sceneCreatedSpy.count(), 1);
auto scene = qobject_cast<SceneOpenGL*>(KWin::Compositor::self()->scene());
QVERIFY(scene);
// trigger a repaint
KWin::Compositor::self()->addRepaintFull();
// and wait 100 msec to ensure it's rendered
// TODO: introduce frameRendered signal in SceneOpenGL
QTest::qWait(100);
}
WAYLANDTEST_MAIN(SceneOpenGLTest)
#include "scene_opengl_test.moc"

View file

@ -19,6 +19,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
#include "composite.h"
#include "abstract_egl_backend.h"
#include "dbusinterface.h"
#include "utils.h"
#include <QTextStream>
@ -145,6 +146,7 @@ Compositor::Compositor(QObject* workspace)
Compositor::~Compositor()
{
emit aboutToDestroy();
AbstractEglBackend::unbindWaylandDisplay();
finish();
deleteUnusedSupportProperties();
delete cm_selection;

View file

@ -33,11 +33,15 @@ namespace KWin
Platform::Platform(QObject *parent)
: QObject(parent)
, m_eglDisplay(EGL_NO_DISPLAY)
{
}
Platform::~Platform()
{
if (m_eglDisplay != EGL_NO_DISPLAY) {
eglTerminate(m_eglDisplay);
}
}
QImage Platform::softwareCursor() const
@ -250,14 +254,14 @@ bool Platform::supportsQpaContext() const
return hasGLExtension(QByteArrayLiteral("EGL_KHR_surfaceless_context"));
}
EGLDisplay Platform::sceneEglDisplay() const
EGLDisplay KWin::Platform::sceneEglDisplay() const
{
if (Compositor *c = Compositor::self()) {
if (SceneOpenGL *s = dynamic_cast<SceneOpenGL*>(c->scene())) {
return static_cast<AbstractEglBackend*>(s->backend())->eglDisplay();
}
}
return EGL_NO_DISPLAY;
return m_eglDisplay;
}
void Platform::setSceneEglDisplay(EGLDisplay display)
{
m_eglDisplay = display;
}
EGLContext Platform::sceneEglContext() const

View file

@ -65,7 +65,8 @@ public:
/**
* The EGLDisplay used by the compositing scene.
**/
virtual EGLDisplay sceneEglDisplay() const;
EGLDisplay sceneEglDisplay() const;
void setSceneEglDisplay(EGLDisplay display);
/**
* The EGLContext used by the compositing scene.
**/
@ -231,6 +232,7 @@ private:
bool m_pointerWarping = false;
bool m_outputsEnabled = true;
int m_initialOutputCount = 1;
EGLDisplay m_eglDisplay;
};
}

View file

@ -90,23 +90,25 @@ void EglGbmBackend::cleanupOutput(const Output &o)
bool EglGbmBackend::initializeEgl()
{
initClientExtensions();
EGLDisplay display = EGL_NO_DISPLAY;
EGLDisplay display = m_backend->sceneEglDisplay();
// Use eglGetPlatformDisplayEXT() to get the display pointer
// if the implementation supports it.
if (!hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_base")) ||
!hasClientExtension(QByteArrayLiteral("EGL_MESA_platform_gbm"))) {
setFailed("EGL_EXT_platform_base and/or EGL_MESA_platform_gbm missing");
return false;
}
if (display == EGL_NO_DISPLAY) {
if (!hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_base")) ||
!hasClientExtension(QByteArrayLiteral("EGL_MESA_platform_gbm"))) {
setFailed("EGL_EXT_platform_base and/or EGL_MESA_platform_gbm missing");
return false;
}
m_device = gbm_create_device(m_backend->fd());
if (!m_device) {
setFailed("Could not create gbm device");
return false;
}
m_device = gbm_create_device(m_backend->fd());
if (!m_device) {
setFailed("Could not create gbm device");
return false;
}
display = eglGetPlatformDisplayEXT(EGL_PLATFORM_GBM_MESA, m_device, nullptr);
display = eglGetPlatformDisplayEXT(EGL_PLATFORM_GBM_MESA, m_device, nullptr);
}
if (display == EGL_NO_DISPLAY)
return false;

View file

@ -43,9 +43,11 @@ bool EglHwcomposerBackend::initializeEgl()
{
// cannot use initClientExtensions as that crashes in libhybris
qputenv("EGL_PLATFORM", QByteArrayLiteral("hwcomposer"));
EGLDisplay display = EGL_NO_DISPLAY;
EGLDisplay display = m_backend->sceneEglDisplay();
display = eglGetDisplay(nullptr);
if (display == EGL_NO_DISPLAY) {
display = eglGetDisplay(nullptr);
}
if (display == EGL_NO_DISPLAY) {
return false;
}

View file

@ -53,17 +53,19 @@ EglGbmBackend::~EglGbmBackend()
bool EglGbmBackend::initializeEgl()
{
initClientExtensions();
EGLDisplay display = EGL_NO_DISPLAY;
EGLDisplay display = m_backend->sceneEglDisplay();
// Use eglGetPlatformDisplayEXT() to get the display pointer
// if the implementation supports it.
if (!hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_base")) ||
!hasClientExtension(QByteArrayLiteral("EGL_MESA_platform_gbm"))) {
setFailed("EGL_EXT_platform_base and/or EGL_MESA_platform_gbm missing");
return false;
}
if (display == EGL_NO_DISPLAY) {
if (!hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_base")) ||
!hasClientExtension(QByteArrayLiteral("EGL_MESA_platform_gbm"))) {
setFailed("EGL_EXT_platform_base and/or EGL_MESA_platform_gbm missing");
return false;
}
display = eglGetPlatformDisplayEXT(EGL_PLATFORM_GBM_MESA, EGL_DEFAULT_DISPLAY, nullptr);
display = eglGetPlatformDisplayEXT(EGL_PLATFORM_GBM_MESA, EGL_DEFAULT_DISPLAY, nullptr);
}
if (display == EGL_NO_DISPLAY)
return false;

View file

@ -70,19 +70,21 @@ EglWaylandBackend::~EglWaylandBackend()
bool EglWaylandBackend::initializeEgl()
{
initClientExtensions();
EGLDisplay display = EGL_NO_DISPLAY;
EGLDisplay display = m_wayland->sceneEglDisplay();
// Use eglGetPlatformDisplayEXT() to get the display pointer
// if the implementation supports it.
m_havePlatformBase = hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_base"));
if (m_havePlatformBase) {
// Make sure that the wayland platform is supported
if (!hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_wayland")))
return false;
if (display == EGL_NO_DISPLAY) {
m_havePlatformBase = hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_base"));
if (m_havePlatformBase) {
// Make sure that the wayland platform is supported
if (!hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_wayland")))
return false;
display = eglGetPlatformDisplayEXT(EGL_PLATFORM_WAYLAND_EXT, m_wayland->display(), nullptr);
} else {
display = eglGetDisplay(m_wayland->display());
display = eglGetPlatformDisplayEXT(EGL_PLATFORM_WAYLAND_EXT, m_wayland->display(), nullptr);
} else {
display = eglGetDisplay(m_wayland->display());
}
}
if (display == EGL_NO_DISPLAY)

View file

@ -22,6 +22,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "main.h"
#include "options.h"
#include "overlaywindow.h"
#include "platform.h"
#include "screens.h"
#include "xcbutils.h"
// kwin libs
@ -171,27 +172,29 @@ void EglOnXBackend::init()
bool EglOnXBackend::initRenderingContext()
{
initClientExtensions();
EGLDisplay dpy;
EGLDisplay dpy = kwinApp()->platform()->sceneEglDisplay();
// Use eglGetPlatformDisplayEXT() to get the display pointer
// if the implementation supports it.
const bool havePlatformBase = hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_base"));
setHavePlatformBase(havePlatformBase);
if (havePlatformBase) {
// Make sure that the X11 platform is supported
if (!hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_x11"))) {
qCWarning(KWIN_CORE) << "EGL_EXT_platform_base is supported, but EGL_EXT_platform_x11 is not. Cannot create EGLDisplay on X11";
return false;
if (display == EGL_NO_DISPLAY) {
const bool havePlatformBase = hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_base"));
setHavePlatformBase(havePlatformBase);
if (havePlatformBase) {
// Make sure that the X11 platform is supported
if (!hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_x11"))) {
qCWarning(KWIN_CORE) << "EGL_EXT_platform_base is supported, but EGL_EXT_platform_x11 is not. Cannot create EGLDisplay on X11";
return false;
}
const int attribs[] = {
EGL_PLATFORM_X11_SCREEN_EXT, m_x11ScreenNumber,
EGL_NONE
};
dpy = eglGetPlatformDisplayEXT(EGL_PLATFORM_X11_EXT, m_x11Display, attribs);
} else {
dpy = eglGetDisplay(m_x11Display);
}
const int attribs[] = {
EGL_PLATFORM_X11_SCREEN_EXT, m_x11ScreenNumber,
EGL_NONE
};
dpy = eglGetPlatformDisplayEXT(EGL_PLATFORM_X11_EXT, m_x11Display, attribs);
} else {
dpy = eglGetDisplay(m_x11Display);
}
if (dpy == EGL_NO_DISPLAY) {