yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/src/main_x11.cpp
David Edmundson f700de56f8 core: Disable Qt RHI pipeline cache 
The Qt pipeline cache causes a disk sync on every load and save of a
QQuickWindow. This causes a stutter under high disk usage.

The gains from this cache are minimal on our simple scenes on PC
hardware. Especially given mesa has it's own cache, profiling on my
personal laptop showed the pipeline as being 0ms.

There is an upstream patch at
https://codereview.qt-project.org/c/qt/qtdeclarative/+/564411 .
QSaveFile still has a sync, but that should only be hit for the first
non-cached run. I'm also adding a flag to QSaveFile to fix the QML cache
and first run case. 

Tested via running kwin with `strace -e
inject=fdatasync:delay_enter=10000000` to simulate a slow flush.

BUG: 487043
2024-05-31 15:28:09 +00:00

472 lines
16 KiB
C++
Raw Blame History

/*
KWin - the KDE window manager
This file is part of the KDE project.
SPDX-FileCopyrightText: 1999, 2000 Matthias Ettrich <ettrich@kde.org>
SPDX-FileCopyrightText: 2003 Lubos Lunak <l.lunak@kde.org>
SPDX-FileCopyrightText: 2014 Martin Gräßlin <mgraesslin@kde.org>
SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "main_x11.h"
#include "config-kwin.h"
#include "backends/x11/standalone/x11_standalone_backend.h"
#include "compositor_x11.h"
#include "core/outputbackend.h"
#include "core/session.h"
#include "cursor.h"
#include "effect/effecthandler.h"
#include "outline.h"
#include "screenedge.h"
#include "sm.h"
#include "tabletmodemanager.h"
#include "utils/xcbutils.h"
#include "workspace.h"
#include <KConfigGroup>
#include <KCrash>
#include <KGlobalAccel>
#include <KLocalizedString>
#include <KSelectionOwner>
#include <KSignalHandler>
#include <QAction>
#include <QComboBox>
#include <QCommandLineParser>
#include <QDialog>
#include <QDialogButtonBox>
#include <QFile>
#include <QLabel>
#include <QPushButton>
#include <QSurfaceFormat>
#include <QVBoxLayout>
#include <qplatformdefs.h>
#include <private/qtx11extras_p.h>
#include <QtDBus>
// system
#include <iostream>
#include <unistd.h>
Q_LOGGING_CATEGORY(KWIN_CORE, "kwin_core", QtWarningMsg)
namespace KWin
{
class AlternativeWMDialog : public QDialog
{
public:
AlternativeWMDialog()
: QDialog()
{
QWidget *mainWidget = new QWidget(this);
QVBoxLayout *layout = new QVBoxLayout(mainWidget);
QString text = i18n("KWin is unstable.\n"
"It seems to have crashed several times in a row.\n"
"You can select another window manager to run:");
QLabel *textLabel = new QLabel(text, mainWidget);
layout->addWidget(textLabel);
wmList = new QComboBox(mainWidget);
wmList->setEditable(true);
layout->addWidget(wmList);
addWM(QStringLiteral("metacity"));
addWM(QStringLiteral("openbox"));
addWM(QStringLiteral("fvwm2"));
addWM(QStringLiteral("kwin_x11"));
QVBoxLayout *mainLayout = new QVBoxLayout(this);
mainLayout->addWidget(mainWidget);
QDialogButtonBox *buttons = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
buttons->button(QDialogButtonBox::Ok)->setDefault(true);
connect(buttons, &QDialogButtonBox::accepted, this, &QDialog::accept);
connect(buttons, &QDialogButtonBox::rejected, this, &QDialog::reject);
mainLayout->addWidget(buttons);
raise();
}
void addWM(const QString &wm)
{
// TODO: Check if WM is installed
if (!QStandardPaths::findExecutable(wm).isEmpty()) {
wmList->addItem(wm);
}
}
QString selectedWM() const
{
return wmList->currentText();
}
private:
QComboBox *wmList;
};
class KWinSelectionOwner : public KSelectionOwner
{
Q_OBJECT
public:
explicit KWinSelectionOwner()
: KSelectionOwner(make_selection_atom())
{
}
private:
bool genericReply(xcb_atom_t target_P, xcb_atom_t property_P, xcb_window_t requestor_P) override
{
if (target_P == xa_version) {
int32_t version[] = {2, 0};
xcb_change_property(kwinApp()->x11Connection(), XCB_PROP_MODE_REPLACE, requestor_P,
property_P, XCB_ATOM_INTEGER, 32, 2, version);
} else {
return KSelectionOwner::genericReply(target_P, property_P, requestor_P);
}
return true;
}
void replyTargets(xcb_atom_t property_P, xcb_window_t requestor_P) override
{
KSelectionOwner::replyTargets(property_P, requestor_P);
xcb_atom_t atoms[1] = {xa_version};
// PropModeAppend !
xcb_change_property(kwinApp()->x11Connection(), XCB_PROP_MODE_APPEND, requestor_P,
property_P, XCB_ATOM_ATOM, 32, 1, atoms);
}
void getAtoms() override
{
KSelectionOwner::getAtoms();
if (xa_version == XCB_ATOM_NONE) {
constexpr QByteArrayView name{"VERSION"};
UniqueCPtr<xcb_intern_atom_reply_t> atom(xcb_intern_atom_reply(
kwinApp()->x11Connection(),
xcb_intern_atom_unchecked(kwinApp()->x11Connection(), false, name.length(), name.constData()),
nullptr));
if (atom) {
xa_version = atom->atom;
}
}
}
xcb_atom_t make_selection_atom()
{
constexpr QByteArrayView screen{"WM_S0"};
UniqueCPtr<xcb_intern_atom_reply_t> atom(xcb_intern_atom_reply(
kwinApp()->x11Connection(),
xcb_intern_atom_unchecked(kwinApp()->x11Connection(), false, screen.length(), screen.constData()),
nullptr));
if (!atom) {
return XCB_ATOM_NONE;
}
return atom->atom;
}
static xcb_atom_t xa_version;
};
xcb_atom_t KWinSelectionOwner::xa_version = XCB_ATOM_NONE;
//************************************
// ApplicationX11
//************************************
ApplicationX11::ApplicationX11(int &argc, char **argv)
: Application(OperationModeX11, argc, argv)
, owner()
, m_replace(false)
{
setX11Connection(QX11Info::connection());
setX11RootWindow(QX11Info::appRootWindow());
}
ApplicationX11::~ApplicationX11()
{
setTerminating();
// need to unload all effects before destroying Workspace, as effects might call into Workspace
if (effects) {
effects->unloadAllEffects();
}
destroyPlugins();
destroyColorManager();
destroyWorkspace();
destroyCompositor();
// If there was no --replace (no new WM)
if (owner != nullptr && owner->ownerWindow() != XCB_WINDOW_NONE) {
Xcb::setInputFocus(XCB_INPUT_FOCUS_POINTER_ROOT);
}
}
void ApplicationX11::setReplace(bool replace)
{
m_replace = replace;
}
std::unique_ptr<Edge> ApplicationX11::createScreenEdge(ScreenEdges *parent)
{
return static_cast<X11StandaloneBackend *>(outputBackend())->createScreenEdge(parent);
}
std::unique_ptr<Cursor> ApplicationX11::createPlatformCursor()
{
return static_cast<X11StandaloneBackend *>(outputBackend())->createPlatformCursor();
}
std::unique_ptr<OutlineVisual> ApplicationX11::createOutline(Outline *outline)
{
// first try composited Outline
if (auto outlineVisual = Application::createOutline(outline)) {
return outlineVisual;
}
return static_cast<X11StandaloneBackend *>(outputBackend())->createOutline(outline);
}
void ApplicationX11::createEffectsHandler(Compositor *compositor, WorkspaceScene *scene)
{
static_cast<X11StandaloneBackend *>(outputBackend())->createEffectsHandler(compositor, scene);
}
void ApplicationX11::startInteractiveWindowSelection(std::function<void(KWin::Window *)> callback, const QByteArray &cursorName)
{
static_cast<X11StandaloneBackend *>(outputBackend())->startInteractiveWindowSelection(callback, cursorName);
}
void ApplicationX11::startInteractivePositionSelection(std::function<void(const QPointF &)> callback)
{
static_cast<X11StandaloneBackend *>(outputBackend())->startInteractivePositionSelection(callback);
}
PlatformCursorImage ApplicationX11::cursorImage() const
{
return static_cast<X11StandaloneBackend *>(outputBackend())->cursorImage();
}
void ApplicationX11::lostSelection()
{
sendPostedEvents();
// need to unload all effects before destroying Workspace, as effects might call into Workspace
if (effects) {
effects->unloadAllEffects();
}
destroyPlugins();
destroyColorManager();
destroyWorkspace();
destroyCompositor();
// Remove windowmanager privileges
Xcb::selectInput(kwinApp()->x11RootWindow(), XCB_EVENT_MASK_PROPERTY_CHANGE);
removeNativeX11EventFilter();
quit();
}
void ApplicationX11::performStartup()
{
crashChecking();
owner = std::make_unique<KWinSelectionOwner>();
connect(owner.get(), &KSelectionOwner::failedToClaimOwnership, [] {
fputs(i18n("kwin: unable to claim manager selection, another wm running? (try using --replace)\n").toLocal8Bit().constData(), stderr);
::exit(1);
});
connect(owner.get(), &KSelectionOwner::lostOwnership, this, &ApplicationX11::lostSelection);
connect(owner.get(), &KSelectionOwner::claimedOwnership, this, [this] {
installNativeX11EventFilter();
createOptions();
if (!outputBackend()->initialize()) {
std::exit(1);
}
// Check whether another windowmanager is running
const uint32_t maskValues[] = {XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT};
UniqueCPtr<xcb_generic_error_t> redirectCheck(xcb_request_check(kwinApp()->x11Connection(),
xcb_change_window_attributes_checked(kwinApp()->x11Connection(),
kwinApp()->x11RootWindow(),
XCB_CW_EVENT_MASK,
maskValues)));
if (redirectCheck) {
fputs(i18n("kwin: another window manager is running (try using --replace)\n").toLocal8Bit().constData(), stderr);
if (!wasCrash()) { // if this is a crash-restart, DrKonqi may have stopped the process w/o killing the connection
::exit(1);
}
}
// Update the timestamp if a global shortcut is pressed or released. Needed
// to ensure that kwin can grab the keyboard.
connect(KGlobalAccel::self(), &KGlobalAccel::globalShortcutActiveChanged, this, [this](QAction *triggeredAction) {
QVariant timestamp = triggeredAction->property("org.kde.kglobalaccel.activationTimestamp");
bool ok = false;
const quint32 t = timestamp.toULongLong(&ok);
if (ok) {
setX11Time(t);
}
});
createInput();
X11Compositor::create(this);
createWorkspace();
createColorManager();
createPlugins();
Xcb::sync(); // Trigger possible errors, there's still a chance to abort
notifyKSplash();
notifyStarted();
connect(Cursors::self()->mouse(), &Cursor::posChanged, workspace(), qOverload<const QPointF &>(&Workspace::setActiveOutput));
});
// we need to do an XSync here, otherwise the QPA might crash us later on
Xcb::sync();
owner->claim(m_replace || wasCrash(), true);
createAtoms();
createTabletModeManager();
}
void ApplicationX11::setupCrashHandler()
{
KCrash::setEmergencySaveFunction(ApplicationX11::crashHandler);
}
void ApplicationX11::crashChecking()
{
setupCrashHandler();
if (crashes >= 4) {
// Something has gone seriously wrong
AlternativeWMDialog dialog;
QString cmd = QStringLiteral("kwin_x11");
if (dialog.exec() == QDialog::Accepted) {
cmd = dialog.selectedWM();
} else {
::exit(1);
}
if (cmd.length() > 500) {
qCDebug(KWIN_CORE) << "Command is too long, truncating";
cmd = cmd.left(500);
}
qCDebug(KWIN_CORE) << "Starting" << cmd << "and exiting";
char buf[1024];
sprintf(buf, "%s &", cmd.toLatin1().data());
system(buf);
::exit(1);
}
// Reset crashes count if we stay up for more that 15 seconds
QTimer::singleShot(15 * 1000, this, &Application::resetCrashesCount);
}
void ApplicationX11::notifyKSplash()
{
// Tell KSplash that KWin has started
QDBusMessage ksplashProgressMessage = QDBusMessage::createMethodCall(QStringLiteral("org.kde.KSplash"),
QStringLiteral("/KSplash"),
QStringLiteral("org.kde.KSplash"),
QStringLiteral("setStage"));
ksplashProgressMessage.setArguments(QList<QVariant>() << QStringLiteral("wm"));
QDBusConnection::sessionBus().asyncCall(ksplashProgressMessage);
}
void ApplicationX11::crashHandler(int signal)
{
crashes++;
fprintf(stderr, "Application::crashHandler() called with signal %d; recent crashes: %d\n", signal, crashes);
char cmd[1024];
sprintf(cmd, "%s --crashes %d &",
QFile::encodeName(QCoreApplication::applicationFilePath()).constData(), crashes);
sleep(1);
system(cmd);
}
} // namespace
int main(int argc, char *argv[])
{
KWin::Application::setupMalloc();
KWin::Application::setupLocalizedString();
signal(SIGPIPE, SIG_IGN);
// enforce xcb plugin, unfortunately command line switch has precedence
setenv("QT_QPA_PLATFORM", "xcb", true);
// disable highdpi scaling
setenv("QT_ENABLE_HIGHDPI_SCALING", "0", true);
qunsetenv("QT_SCALE_FACTOR");
qunsetenv("QT_SCREEN_SCALE_FACTORS");
// KSMServer talks to us directly on DBus.
QCoreApplication::setAttribute(Qt::AA_DisableSessionManager);
// For sharing thumbnails between our scene graph and qtquick.
QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
// The shader (currently) causes a blocking disk flush on load and save of every QQuickWindow
// Because it's on load, it will happen every time not just occasionally
// The gains are minimal, disable until it's fixed
QCoreApplication::setAttribute(Qt::AA_DisableShaderDiskCache);
QSurfaceFormat format = QSurfaceFormat::defaultFormat();
// shared opengl contexts must have the same reset notification policy
format.setOptions(QSurfaceFormat::ResetNotification);
// disables vsync for any QtQuick windows we create (BUG 406180)
format.setSwapInterval(0);
QSurfaceFormat::setDefaultFormat(format);
KWin::ApplicationX11 a(argc, argv);
// reset QT_QPA_PLATFORM so we don't propagate it to our children (e.g. apps launched from the overview effect)
qunsetenv("QT_QPA_PLATFORM");
qunsetenv("QT_ENABLE_HIGHDPI_SCALING");
a.setProcessStartupEnvironment(QProcessEnvironment(QProcessEnvironment::InheritFromParent));
KSignalHandler::self()->watchSignal(SIGTERM);
KSignalHandler::self()->watchSignal(SIGINT);
KSignalHandler::self()->watchSignal(SIGHUP);
QObject::connect(KSignalHandler::self(), &KSignalHandler::signalReceived,
&a, &QCoreApplication::exit);
KWin::Application::createAboutData();
QCommandLineOption replaceOption(QStringLiteral("replace"), i18n("Replace already-running ICCCM2.0-compliant window manager"));
QCommandLineParser parser;
a.setupCommandLine(&parser);
parser.addOption(replaceOption);
#if KWIN_BUILD_ACTIVITIES
QCommandLineOption noActivitiesOption(QStringLiteral("no-kactivities"),
i18n("Disable KActivities integration."));
parser.addOption(noActivitiesOption);
#endif
parser.process(a);
a.processCommandLine(&parser);
a.setReplace(parser.isSet(replaceOption));
#if KWIN_BUILD_ACTIVITIES
if (parser.isSet(noActivitiesOption)) {
a.setUseKActivities(false);
}
#endif
// perform sanity checks
if (a.platformName().toLower() != QStringLiteral("xcb")) {
fprintf(stderr, "%s: FATAL ERROR expecting platform xcb but got platform %s\n",
argv[0], qPrintable(a.platformName()));
exit(1);
}
if (!QX11Info::display()) {
fprintf(stderr, "%s: FATAL ERROR KWin requires Xlib support in the xcb plugin. Do not configure Qt with -no-xcb-xlib\n",
argv[0]);
exit(1);
}
a.setSession(KWin::Session::create(KWin::Session::Type::Noop));
a.setOutputBackend(std::make_unique<KWin::X11StandaloneBackend>());
a.start();
return a.exec();
}
#include "main_x11.moc"
#include "moc_main_x11.cpp"
Reference in a new issue View git blame Copy permalink