poz/quickshell
1
0
Fork 0
forked from quickshell/quickshell
Code Pull requests Activity

core/ipc: add ipc server/client

Browse source 
Currently can only kill a remote instance.
This commit is contained in:
outfoxxed 2024-08-30 21:45:20 -07:00
parent 13b6eeaa22
commit da043e092a
Signed by untrusted user: outfoxxed
GPG key ID: 4C88A185FB89301E
14 changed files with 710 additions and 120 deletions
Download patch file Download diff file Expand all files Collapse all files

3
src/core/CMakeLists.txt
View file

@ -41,8 +41,9 @@ qt_add_library(quickshell-core STATIC
clock.cpp
logging.cpp
paths.cpp
crashinfo.cpp
instanceinfo.cpp
common.cpp
ipc.cpp
)
if (CRASH_REPORTER)

19
src/core/crashinfo.cpp
View file

@ -1,19 +0,0 @@
#include "crashinfo.hpp"
#include <qdatastream.h>
QDataStream& operator<<(QDataStream& stream, const InstanceInfo& info) {
stream << info.configPath << info.shellId << info.launchTime << info.noColor;
return stream;
}
QDataStream& operator>>(QDataStream& stream, InstanceInfo& info) {
stream >> info.configPath >> info.shellId >> info.launchTime >> info.noColor;
return stream;
}
namespace qs::crash {
CrashInfo CrashInfo::INSTANCE = {}; // NOLINT
}

31
src/core/instanceinfo.cpp Normal file
View file

@ -0,0 +1,31 @@
#include "instanceinfo.hpp"
#include <qdatastream.h>
QDataStream& operator<<(QDataStream& stream, const InstanceInfo& info) {
stream << info.instanceId << info.configPath << info.shellId << info.launchTime;
return stream;
}
QDataStream& operator>>(QDataStream& stream, InstanceInfo& info) {
stream >> info.instanceId >> info.configPath >> info.shellId >> info.launchTime;
return stream;
}
QDataStream& operator<<(QDataStream& stream, const RelaunchInfo& info) {
stream << info.instance << info.noColor << info.sparseLogsOnly;
return stream;
}
QDataStream& operator>>(QDataStream& stream, RelaunchInfo& info) {
stream >> info.instance >> info.noColor >> info.sparseLogsOnly;
return stream;
}
InstanceInfo InstanceInfo::CURRENT = {}; // NOLINT
namespace qs::crash {
CrashInfo CrashInfo::INSTANCE = {}; // NOLINT
}

10
src/core/crashinfo.hpp → src/core/instanceinfo.hpp
View file

@ -4,10 +4,17 @@
#include <qstring.h>
struct InstanceInfo {
QString instanceId;
QString configPath;
QString shellId;
QString initialWorkdir;
QDateTime launchTime;
static InstanceInfo CURRENT; // NOLINT
};
struct RelaunchInfo {
InstanceInfo instance;
bool noColor = false;
bool sparseLogsOnly = false;
};
@ -15,6 +22,9 @@ struct InstanceInfo {
QDataStream& operator<<(QDataStream& stream, const InstanceInfo& info);
QDataStream& operator>>(QDataStream& stream, InstanceInfo& info);
QDataStream& operator<<(QDataStream& stream, const RelaunchInfo& info);
QDataStream& operator>>(QDataStream& stream, RelaunchInfo& info);
namespace qs::crash {
struct CrashInfo {

119
src/core/ipc.cpp Normal file
View file

@ -0,0 +1,119 @@
#include "ipc.hpp"
#include <functional>
#include <qlocalserver.h>
#include <qlocalsocket.h>
#include <qlogging.h>
#include <qloggingcategory.h>
#include <qobject.h>
#include "generation.hpp"
#include "paths.hpp"
namespace qs::ipc {
Q_LOGGING_CATEGORY(logIpc, "quickshell.ipc", QtWarningMsg);
IpcServer::IpcServer(const QString& path) {
QObject::connect(&this->server, &QLocalServer::newConnection, this, &IpcServer::onNewConnection);
QLocalServer::removeServer(path);
if (!this->server.listen(path)) {
qCCritical(logIpc) << "Failed to start IPC server on path" << path;
return;
}
qCInfo(logIpc) << "Started IPC server on path" << path;
}
void IpcServer::start() {
if (auto* run = QsPaths::instance()->instanceRunDir()) {
auto path = run->filePath("ipc.sock");
new IpcServer(path);
} else {
qCCritical(logIpc
) << "Could not start IPC server as the instance runtime path could not be created.";
}
}
void IpcServer::onNewConnection() {
while (auto* connection = this->server.nextPendingConnection()) {
new IpcServerConnection(connection, this);
}
}
IpcServerConnection::IpcServerConnection(QLocalSocket* socket, IpcServer* server)
: QObject(server)
, socket(socket) {
socket->setParent(this);
this->stream.setDevice(socket);
QObject::connect(socket, &QLocalSocket::disconnected, this, &IpcServerConnection::onDisconnected);
QObject::connect(socket, &QLocalSocket::readyRead, this, &IpcServerConnection::onReadyRead);
qCInfo(logIpc) << "New IPC connection" << this;
}
void IpcServerConnection::onDisconnected() {
qCInfo(logIpc) << "IPC connection disconnected" << this;
}
void IpcServerConnection::onReadyRead() {
this->stream.startTransaction();
this->stream.startTransaction();
auto command = IpcCommand::Unknown;
this->stream >> command;
if (!this->stream.commitTransaction()) return;
switch (command) {
case IpcCommand::Kill:
qInfo() << "Exiting due to IPC request.";
EngineGeneration::currentGeneration()->quit();
break;
default:
qCCritical(logIpc) << "Received invalid IPC command from" << this;
this->socket->disconnectFromServer();
break;
}
if (!this->stream.commitTransaction()) return;
}
IpcClient::IpcClient(const QString& path) {
QObject::connect(&this->socket, &QLocalSocket::connected, this, &IpcClient::connected);
QObject::connect(&this->socket, &QLocalSocket::disconnected, this, &IpcClient::disconnected);
QObject::connect(&this->socket, &QLocalSocket::errorOccurred, this, &IpcClient::onError);
this->socket.connectToServer(path);
this->stream.setDevice(&this->socket);
}
bool IpcClient::isConnected() const { return this->socket.isValid(); }
void IpcClient::waitForConnected() { this->socket.waitForConnected(); }
void IpcClient::waitForDisconnected() { this->socket.waitForDisconnected(); }
void IpcClient::kill() {
qCDebug(logIpc) << "Sending kill command...";
this->stream << IpcCommand::Kill;
this->socket.flush();
}
void IpcClient::onError(QLocalSocket::LocalSocketError error) {
qCCritical(logIpc) << "Socket Error" << error;
}
bool IpcClient::connect(const QString& id, const std::function<void(IpcClient& client)>& callback) {
auto path = QsPaths::ipcPath(id);
auto client = IpcClient(path);
qCDebug(logIpc) << "Connecting to instance" << id << "at" << path;
client.waitForConnected();
if (!client.isConnected()) return false;
qCDebug(logIpc) << "Connected.";
callback(client);
return true;
}
} // namespace qs::ipc

74
src/core/ipc.hpp Normal file
View file

@ -0,0 +1,74 @@
#pragma once
#include <functional>
#include <qlocalserver.h>
#include <qlocalsocket.h>
#include <qobject.h>
#include <qtmetamacros.h>
namespace qs::ipc {
enum class IpcCommand : quint8 {
Unknown = 0,
Kill,
};
class IpcServer: public QObject {
Q_OBJECT;
public:
explicit IpcServer(const QString& path);
static void start();
private slots:
void onNewConnection();
private:
QLocalServer server;
};
class IpcServerConnection: public QObject {
Q_OBJECT;
public:
explicit IpcServerConnection(QLocalSocket* socket, IpcServer* server);
private slots:
void onDisconnected();
void onReadyRead();
private:
QLocalSocket* socket;
QDataStream stream;
};
class IpcClient: public QObject {
Q_OBJECT;
public:
explicit IpcClient(const QString& path);
[[nodiscard]] bool isConnected() const;
void waitForConnected();
void waitForDisconnected();
void kill();
[[nodiscard]] static bool
connect(const QString& id, const std::function<void(IpcClient& client)>& callback);
signals:
void connected();
void disconnected();
private slots:
static void onError(QLocalSocket::LocalSocketError error);
private:
QLocalSocket socket;
QDataStream stream;
};
} // namespace qs::ipc

64
src/core/logging.cpp
View file

@ -24,11 +24,13 @@
#include <sys/mman.h>
#include <sys/sendfile.h>
#include "crashinfo.hpp"
#include "instanceinfo.hpp"
#include "logging_p.hpp"
#include "logging_qtprivate.cpp" // NOLINT
#include "paths.hpp"
Q_LOGGING_CATEGORY(logBare, "quickshell.bare");
namespace qs::log {
Q_LOGGING_CATEGORY(logLogging, "quickshell.logging", QtWarningMsg);
@ -53,37 +55,41 @@ void LogMessage::formatMessage(
stream << msg.time.toString("yyyy-MM-dd hh:mm:ss.zzz");
}
if (color) {
switch (msg.type) {
case QtDebugMsg: stream << "\033[34m DEBUG"; break;
case QtInfoMsg: stream << "\033[32m INFO"; break;
case QtWarningMsg: stream << "\033[33m WARN"; break;
case QtCriticalMsg: stream << "\033[31m ERROR"; break;
case QtFatalMsg: stream << "\033[31m FATAL"; break;
}
if (msg.category == "quickshell.bare") {
stream << msg.body;
} else {
switch (msg.type) {
case QtDebugMsg: stream << " DEBUG"; break;
case QtInfoMsg: stream << " INFO"; break;
case QtWarningMsg: stream << " WARN"; break;
case QtCriticalMsg: stream << " ERROR"; break;
case QtFatalMsg: stream << " FATAL"; break;
if (color) {
switch (msg.type) {
case QtDebugMsg: stream << "\033[34m DEBUG"; break;
case QtInfoMsg: stream << "\033[32m INFO"; break;
case QtWarningMsg: stream << "\033[33m WARN"; break;
case QtCriticalMsg: stream << "\033[31m ERROR"; break;
case QtFatalMsg: stream << "\033[31m FATAL"; break;
}
} else {
switch (msg.type) {
case QtDebugMsg: stream << " DEBUG"; break;
case QtInfoMsg: stream << " INFO"; break;
case QtWarningMsg: stream << " WARN"; break;
case QtCriticalMsg: stream << " ERROR"; break;
case QtFatalMsg: stream << " FATAL"; break;
}
}
const auto isDefault = msg.category == "default";
if (color && !isDefault && msg.type != QtFatalMsg) stream << "\033[97m";
if (!isDefault) {
stream << ' ' << msg.category;
}
if (color && msg.type != QtFatalMsg) stream << "\033[0m";
stream << ": " << msg.body;
if (color && msg.type == QtFatalMsg) stream << "\033[0m";
}
const auto isDefault = msg.category == "default";
if (color && !isDefault && msg.type != QtFatalMsg) stream << "\033[97m";
if (!isDefault) {
stream << ' ' << msg.category;
}
if (color && msg.type != QtFatalMsg) stream << "\033[0m";
stream << ": " << msg.body;
if (color && msg.type == QtFatalMsg) stream << "\033[0m";
}
bool CategoryFilter::shouldDisplay(QtMsgType type) const {

2
src/core/logging.hpp
View file

@ -11,6 +11,8 @@
#include <qobject.h>
#include <qtmetamacros.h>
Q_DECLARE_LOGGING_CATEGORY(logBare);
namespace qs::log {
struct LogMessage {

236
src/core/main.cpp
View file

@ -1,4 +1,6 @@
#include "main.hpp"
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <string>
@ -8,6 +10,7 @@
#include <CLI/Error.hpp>
#include <CLI/Validators.hpp>
#include <qapplication.h>
#include <qcontainerfwd.h>
#include <qcoreapplication.h>
#include <qcryptographichash.h>
#include <qdatastream.h>
@ -17,8 +20,12 @@
#include <qguiapplication.h>
#include <qhash.h>
#include <qicon.h>
#include <qjsonarray.h>
#include <qjsondocument.h>
#include <qjsonobject.h>
#include <qlist.h>
#include <qlogging.h>
#include <qloggingcategory.h>
#include <qnamespace.h>
#include <qqmldebug.h>
#include <qquickwindow.h>
@ -27,10 +34,13 @@
#include <qtenvironmentvariables.h>
#include <qtextstream.h>
#include <qtpreprocessorsupport.h>
#include <sched.h>
#include <unistd.h>
#include "build.hpp"
#include "common.hpp"
#include "crashinfo.hpp"
#include "instanceinfo.hpp"
#include "ipc.hpp"
#include "logging.hpp"
#include "paths.hpp"
#include "plugin.hpp"
@ -40,6 +50,8 @@
#include "../crash/main.hpp"
#endif
using qs::ipc::IpcClient;
struct CommandInfo {
QString configPath;
QString manifestPath;
@ -52,6 +64,8 @@ struct CommandInfo {
bool& sparseLogsOnly;
};
QString commandConfigPath(QString path, QString manifest, QString config, bool printInfo);
void processCommand(int argc, char** argv, CommandInfo& info) {
QCoreApplication::setApplicationName("quickshell");
@ -162,12 +176,97 @@ void processCommand(int argc, char** argv, CommandInfo& info) {
readLog->add_flag("--no-time", logNoTime, "Do not print timestamps of log messages.");
readLog->add_flag("--no-color", info.noColor, "Do not color the log output. (Env:NO_COLOR)");
/// ---
QStringOption instanceId;
pid_t instancePid = -1;
auto sortInstances = [](QVector<InstanceLockInfo>& list) {
std::sort(list.begin(), list.end(), [](const InstanceLockInfo& a, const InstanceLockInfo& b) {
return a.instance.launchTime < b.instance.launchTime;
});
};
auto selectInstance = [&]() {
auto* basePath = QsPaths::instance()->baseRunDir();
if (!basePath) exit(-1); // NOLINT
QString path;
InstanceLockInfo instance;
if (instancePid != -1) {
path = QDir(basePath->filePath("by-pid")).filePath(QString::number(instancePid));
if (!QsPaths::checkLock(path, &instance)) {
qCInfo(logBare) << "No instance found for pid" << instancePid;
exit(-1); // NOLINT
}
} else if (!(*instanceId).isEmpty()) {
path = basePath->filePath("by-pid");
auto instances = QsPaths::collectInstances(path);
auto itr =
std::remove_if(instances.begin(), instances.end(), [&](const InstanceLockInfo& info) {
return !info.instance.instanceId.startsWith(*instanceId);
});
instances.erase(itr, instances.end());
if (instances.isEmpty()) {
qCInfo(logBare) << "No running instances start with" << *instanceId;
} else if (instances.length() != 1) {
qCInfo(logBare) << "More than one instance starts with" << *instanceId;
for (auto& instance: instances) {
qCInfo(logBare).noquote() << " -" << instance.instance.instanceId;
}
exit(-1); // NOLINT
} else {
instance = instances.value(0);
}
} else {
auto configFilePath =
commandConfigPath(info.configPath, info.manifestPath, info.configName, info.printInfo);
auto pathId =
QCryptographicHash::hash(configFilePath.toUtf8(), QCryptographicHash::Md5).toHex();
path = QDir(basePath->filePath("by-path")).filePath(pathId);
auto instances = QsPaths::collectInstances(path);
sortInstances(instances);
if (instances.isEmpty()) {
qCInfo(logBare) << "No running instances for" << configFilePath;
exit(-1); // NOLINT
}
instance = instances.value(0);
}
return instance;
};
auto* instances =
app.add_subcommand("instances", "List running quickshell instances.")->fallthrough();
auto* allInstances =
instances->add_flag("-a,--all", "List all instances instead of just the current config.");
auto* instancesJson = instances->add_flag("-j,--json", "Output the list as a json.");
auto* kill = app.add_subcommand("kill", "Kill an instance.")->fallthrough();
auto* kInstance = app.add_option("-i,--instance", instanceId, "The instance id to kill.");
app.add_option("-p,--pid", instancePid, "The process id to kill.")->excludes(kInstance);
try {
app.parse(argc, argv);
} catch (const CLI::ParseError& e) {
exit(app.exit(e)); // NOLINT
};
// Start log manager - has to happen with an active event loop or offthread can't be started.
LogManager::init(!info.noColor, info.sparseLogsOnly);
if (*printVersion) {
std::cout << "quickshell pre-release, revision: " << GIT_REVISION << std::endl;
exit(0); // NOLINT
@ -183,6 +282,86 @@ void processCommand(int argc, char** argv, CommandInfo& info) {
exit( // NOLINT
qs::log::readEncodedLogs(&file, !logNoTime, *logFilter) ? 0 : -1
);
} else if (*instances) {
auto* basePath = QsPaths::instance()->baseRunDir();
if (!basePath) exit(-1); // NOLINT
QString path;
QString configFilePath;
if (*allInstances) {
path = basePath->filePath("by-pid");
} else {
configFilePath =
commandConfigPath(info.configPath, info.manifestPath, info.configName, info.printInfo);
auto pathId =
QCryptographicHash::hash(configFilePath.toUtf8(), QCryptographicHash::Md5).toHex();
path = QDir(basePath->filePath("by-path")).filePath(pathId);
}
auto instances = QsPaths::collectInstances(path);
if (instances.isEmpty()) {
if (*allInstances) {
qCInfo(logBare) << "No running instances.";
} else {
qCInfo(logBare) << "No running instances for" << configFilePath;
qCInfo(logBare) << "Use --all to list all instances.";
}
} else {
sortInstances(instances);
if (*instancesJson) {
auto array = QJsonArray();
for (auto& instance: instances) {
auto json = QJsonObject();
json["id"] = instance.instance.instanceId;
json["pid"] = instance.pid;
json["shell_id"] = instance.instance.shellId;
json["config_path"] = instance.instance.configPath;
json["launch_time"] = instance.instance.launchTime.toString(Qt::ISODate);
array.push_back(json);
}
auto document = QJsonDocument(array);
QTextStream(stdout) << document.toJson(QJsonDocument::Indented);
} else {
for (auto& instance: instances) {
auto launchTimeStr = instance.instance.launchTime.toString("yyyy-MM-dd hh:mm:ss");
auto runSeconds = instance.instance.launchTime.secsTo(QDateTime::currentDateTime());
auto remSeconds = runSeconds % 60;
auto runMinutes = (runSeconds - remSeconds) / 60;
auto remMinutes = runMinutes % 60;
auto runHours = (runMinutes - remMinutes) / 60;
auto runtimeStr = QString("%1 hours, %2 minutes, %3 seconds")
.arg(runHours)
.arg(remMinutes)
.arg(remSeconds);
qCInfo(logBare).noquote().nospace()
<< "Instance " << instance.instance.instanceId << ":\n"
<< " Process ID: " << instance.pid << '\n'
<< " Shell ID: " << instance.instance.shellId << '\n'
<< " Config path: " << instance.instance.configPath << '\n'
<< " Launch time: " << launchTimeStr << " (running for " << runtimeStr << ")\n";
}
}
}
exit(0); // NOLINT
} else if (*kill) {
auto instance = selectInstance();
auto r = IpcClient::connect(instance.instance.instanceId, [&](IpcClient& client) {
client.kill();
qCInfo(logBare).noquote() << "Killed" << instance.instance.instanceId;
});
exit(r ? 0 : -1); // NOLINT
}
}
@ -373,6 +552,26 @@ foundp:;
return configFilePath;
}
template <typename T>
QString base36Encode(T number) {
const QString digits = "0123456789abcdefghijklmnopqrstuvwxyz";
QString result;
do {
result.prepend(digits[number % 36]);
number /= 36;
} while (number > 0);
for (auto i = 0; i < result.length() / 2; i++) {
auto opposite = result.length() - i - 1;
auto c = result.at(i);
result[i] = result.at(opposite);
result[opposite] = c;
}
return result;
}
int qs_main(int argc, char** argv) {
#if CRASH_REPORTER
qsCheckCrash(argc, argv);
@ -385,6 +584,7 @@ int qs_main(int argc, char** argv) {
QString configFilePath;
QString initialWorkdir;
QString shellId;
QString pathId;
int debugPort = -1;
bool waitForDebug = false;
@ -411,11 +611,11 @@ int qs_main(int argc, char** argv) {
file.seek(0);
auto ds = QDataStream(&file);
InstanceInfo info;
RelaunchInfo info;
ds >> info;
configFilePath = info.configPath;
initialWorkdir = info.initialWorkdir;
configFilePath = info.instance.configPath;
initialWorkdir = info.instance.initialWorkdir;
noColor = info.noColor;
sparseLogsOnly = info.sparseLogsOnly;
@ -426,9 +626,9 @@ int qs_main(int argc, char** argv) {
<< " (Coredumps will be available under that pid.)";
qCritical() << "Further crash information is stored under"
<< QsPaths::crashDir(info.shellId, info.launchTime).path();
<< QsPaths::crashDir(info.instance.instanceId).path();
if (info.launchTime.msecsTo(QDateTime::currentDateTime()) < 10000) {
if (info.instance.launchTime.msecsTo(QDateTime::currentDateTime()) < 10000) {
qCritical() << "Quickshell crashed within 10 seconds of launching. Not restarting to avoid "
"a crash loop.";
return 0;
@ -452,9 +652,6 @@ int qs_main(int argc, char** argv) {
processCommand(argc, argv, command);
// Start log manager - has to happen with an active event loop or offthread can't be started.
LogManager::init(!noColor, sparseLogsOnly);
#if CRASH_REPORTER
// Started after log manager for pretty debug logs. Unlikely anything will crash before this point, but
// this can be moved if it happens.
@ -469,7 +666,8 @@ int qs_main(int argc, char** argv) {
);
}
shellId = QCryptographicHash::hash(configFilePath.toUtf8(), QCryptographicHash::Md5).toHex();
pathId = QCryptographicHash::hash(configFilePath.toUtf8(), QCryptographicHash::Md5).toHex();
shellId = pathId;
qInfo() << "Config file path:" << configFilePath;
@ -521,12 +719,18 @@ int qs_main(int argc, char** argv) {
if (printInfo) return 0;
#if CRASH_REPORTER
crashHandler.setInstanceInfo(InstanceInfo {
auto launchTime = qs::Common::LAUNCH_TIME.toSecsSinceEpoch();
InstanceInfo::CURRENT = InstanceInfo {
.instanceId = base36Encode(getpid()) + base36Encode(launchTime),
.configPath = configFilePath,
.shellId = shellId,
.initialWorkdir = initialWorkdir,
.launchTime = qs::Common::LAUNCH_TIME,
};
#if CRASH_REPORTER
crashHandler.setInstanceInfo(RelaunchInfo {
.instance = InstanceInfo::CURRENT,
.noColor = noColor,
.sparseLogsOnly = sparseLogsOnly,
});
@ -536,8 +740,9 @@ int qs_main(int argc, char** argv) {
qputenv(var.toUtf8(), val.toUtf8());
}
QsPaths::init(shellId);
QsPaths::instance()->linkPidRunDir();
QsPaths::init(shellId, pathId);
QsPaths::instance()->linkRunDir();
QsPaths::instance()->linkPathDir();
if (auto* cacheDir = QsPaths::instance()->cacheDir()) {
auto qmlCacheDir = cacheDir->filePath("qml-engine-cache");
@ -617,6 +822,9 @@ int qs_main(int argc, char** argv) {
QQuickWindow::setTextRenderType(QQuickWindow::NativeTextRendering);
}
qs::ipc::IpcServer::start();
QsPaths::instance()->createLock();
auto root = RootWrapper(configFilePath, shellId);
QGuiApplication::setQuitOnLastWindowClosed(false);

218
src/core/paths.cpp
View file

@ -1,8 +1,11 @@
#include "paths.hpp"
#include <cerrno>
#include <cstdio>
#include <utility>
#include <qdatetime.h>
#include <fcntl.h>
#include <qcontainerfwd.h>
#include <qdatastream.h>
#include <qdir.h>
#include <qlogging.h>
#include <qloggingcategory.h>
@ -10,7 +13,7 @@
#include <qtenvironmentvariables.h>
#include <unistd.h>
#include "common.hpp"
#include "instanceinfo.hpp"
Q_LOGGING_CATEGORY(logPaths, "quickshell.paths", QtWarningMsg);
@ -19,17 +22,27 @@ QsPaths* QsPaths::instance() {
return instance;
}
void QsPaths::init(QString shellId) { QsPaths::instance()->shellId = std::move(shellId); }
void QsPaths::init(QString shellId, QString pathId) {
auto* instance = QsPaths::instance();
instance->shellId = std::move(shellId);
instance->pathId = std::move(pathId);
}
QDir QsPaths::crashDir(const QString& shellId, const QDateTime& launchTime) {
QDir QsPaths::crashDir(const QString& id) {
auto dir = QDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation));
dir = QDir(dir.filePath("crashes"));
dir = QDir(dir.filePath(shellId));
dir = QDir(dir.filePath(QString("run-%1").arg(launchTime.toMSecsSinceEpoch())));
dir = QDir(dir.filePath(id));
return dir;
}
QString QsPaths::ipcPath(const QString& id) {
auto ipcPath = QsPaths::instance()->baseRunDir()->filePath("by-id");
ipcPath = QDir(ipcPath).filePath(id);
ipcPath = QDir(ipcPath).filePath("ipc.sock");
return ipcPath;
}
QDir* QsPaths::cacheDir() {
if (this->cacheState == DirState::Unknown) {
auto dir = QDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation));
@ -77,42 +90,45 @@ QDir* QsPaths::baseRunDir() {
else return &this->mBaseRunDir;
}
QDir* QsPaths::runDir() {
if (this->runState == DirState::Unknown) {
QDir* QsPaths::shellRunDir() {
if (this->shellRunState == DirState::Unknown) {
if (auto* baseRunDir = this->baseRunDir()) {
this->mRunDir = QDir(baseRunDir->filePath(this->shellId));
this->mShellRunDir = QDir(baseRunDir->filePath("by-shell"));
this->mShellRunDir = QDir(this->mShellRunDir.filePath(this->shellId));
qCDebug(logPaths) << "Initialized runtime path:" << this->mRunDir.path();
qCDebug(logPaths) << "Initialized runtime path:" << this->mShellRunDir.path();
if (!this->mRunDir.mkpath(".")) {
qCCritical(logPaths) << "Could not create runtime directory at" << this->mRunDir.path();
this->runState = DirState::Failed;
if (!this->mShellRunDir.mkpath(".")) {
qCCritical(logPaths) << "Could not create runtime directory at"
<< this->mShellRunDir.path();
this->shellRunState = DirState::Failed;
} else {
this->runState = DirState::Ready;
this->shellRunState = DirState::Ready;
}
} else {
qCCritical(logPaths) << "Could not create shell runtime path as it was not possible to "
"create the base runtime path.";
this->runState = DirState::Failed;
this->shellRunState = DirState::Failed;
}
}
if (this->runState == DirState::Failed) return nullptr;
else return &this->mRunDir;
if (this->shellRunState == DirState::Failed) return nullptr;
else return &this->mShellRunDir;
}
QDir* QsPaths::instanceRunDir() {
if (this->instanceRunState == DirState::Unknown) {
auto* runtimeDir = this->runDir();
auto* runDir = this->baseRunDir();
if (!runtimeDir) {
if (!runDir) {
qCCritical(logPaths) << "Cannot create instance runtime directory as main runtim directory "
"could not be created.";
this->instanceRunState = DirState::Failed;
} else {
this->mInstanceRunDir =
runtimeDir->filePath(QString("run-%1").arg(qs::Common::LAUNCH_TIME.toMSecsSinceEpoch()));
auto byIdDir = QDir(runDir->filePath("by-id"));
this->mInstanceRunDir = byIdDir.filePath(InstanceInfo::CURRENT.instanceId);
qCDebug(logPaths) << "Initialized instance runtime path:" << this->mInstanceRunDir.path();
@ -126,34 +142,162 @@ QDir* QsPaths::instanceRunDir() {
}
}
if (this->runState == DirState::Failed) return nullptr;
if (this->shellRunState == DirState::Failed) return nullptr;
else return &this->mInstanceRunDir;
}
void QsPaths::linkPidRunDir() {
void QsPaths::linkRunDir() {
if (auto* runDir = this->instanceRunDir()) {
auto pidDir = QDir(this->baseRunDir()->filePath("by-pid"));
auto* shellDir = this->shellRunDir();
if (!shellDir) {
qCCritical(logPaths
) << "Could not create by-id symlink as the shell runtime path could not be created.";
} else {
auto shellPath = shellDir->filePath(runDir->dirName());
QFile::remove(shellPath);
auto r =
symlinkat(runDir->filesystemCanonicalPath().c_str(), 0, shellPath.toStdString().c_str());
if (r != 0) {
qCCritical(logPaths).nospace()
<< "Could not create id symlink to " << runDir->path() << " at " << shellPath
<< " with error code " << errno << ": " << qt_error_string();
} else {
qCDebug(logPaths) << "Created shellid symlink" << shellPath << "to instance runtime path"
<< runDir->path();
}
}
if (!pidDir.mkpath(".")) {
qCCritical(logPaths) << "Could not create PID symlink directory.";
return;
}
auto pidPath = pidDir.filePath(QString::number(getpid()));
QFile::remove(pidPath);
auto r = symlinkat(runDir->filesystemCanonicalPath().c_str(), 0, pidPath.toStdString().c_str());
if (r != 0) {
qCCritical(logPaths).nospace()
<< "Could not create PID symlink to " << runDir->path() << " at " << pidPath
<< " with error code " << errno << ": " << qt_error_string();
} else {
qCDebug(logPaths) << "Created PID symlink" << pidPath << "to instance runtime path"
<< runDir->path();
auto pidPath = pidDir.filePath(QString::number(getpid()));
QFile::remove(pidPath);
auto r =
symlinkat(runDir->filesystemCanonicalPath().c_str(), 0, pidPath.toStdString().c_str());
if (r != 0) {
qCCritical(logPaths).nospace()
<< "Could not create PID symlink to " << runDir->path() << " at " << pidPath
<< " with error code " << errno << ": " << qt_error_string();
} else {
qCDebug(logPaths) << "Created PID symlink" << pidPath << "to instance runtime path"
<< runDir->path();
}
}
} else {
qCCritical(logPaths) << "Could not create PID symlink to runtime directory, as the runtime "
"directory could not be created.";
}
}
void QsPaths::linkPathDir() {
if (auto* runDir = this->shellRunDir()) {
auto pathDir = QDir(this->baseRunDir()->filePath("by-path"));
if (!pathDir.mkpath(".")) {
qCCritical(logPaths) << "Could not create path symlink directory.";
return;
}
auto linkPath = pathDir.filePath(this->pathId);
QFile::remove(linkPath);
auto r =
symlinkat(runDir->filesystemCanonicalPath().c_str(), 0, linkPath.toStdString().c_str());
if (r != 0) {
qCCritical(logPaths).nospace()
<< "Could not create path symlink to " << runDir->path() << " at " << linkPath
<< " with error code " << errno << ": " << qt_error_string();
} else {
qCDebug(logPaths) << "Created path symlink" << linkPath << "to shell runtime path"
<< runDir->path();
}
} else {
qCCritical(logPaths) << "Could not create path symlink to shell runtime directory, as the "
"shell runtime directory could not be created.";
}
}
void QsPaths::createLock() {
if (auto* runDir = this->instanceRunDir()) {
auto path = runDir->filePath("instance.lock");
auto* file = new QFile(path); // leaked
if (!file->open(QFile::ReadWrite | QFile::Truncate)) {
qCCritical(logPaths) << "Could not create instance lock at" << path;
return;
}
auto lock = flock {
.l_type = F_WRLCK,
.l_whence = SEEK_SET,
.l_start = 0,
.l_len = 0,
};
if (fcntl(file->handle(), F_SETLK, &lock) != 0) { // NOLINT
qCCritical(logPaths).nospace() << "Could not lock instance lock at " << path
<< " with error code " << errno << ": " << qt_error_string();
} else {
auto stream = QDataStream(file);
stream << InstanceInfo::CURRENT;
file->flush();
qCDebug(logPaths) << "Created instance lock at" << path;
}
} else {
qCCritical(logPaths
) << "Could not create instance lock, as the instance runtime directory could not be created.";
}
}
bool QsPaths::checkLock(const QString& path, InstanceLockInfo* info) {
auto file = QFile(QDir(path).filePath("instance.lock"));
if (!file.open(QFile::ReadOnly)) return false;
auto lock = flock {
.l_type = F_WRLCK,
.l_whence = SEEK_SET,
.l_start = 0,
.l_len = 0,
};
fcntl(file.handle(), F_GETLK, &lock); // NOLINT
if (lock.l_type == F_UNLCK) return false;
if (info) {
info->pid = lock.l_pid;
auto stream = QDataStream(&file);
stream >> info->instance;
}
return true;
}
QVector<InstanceLockInfo> QsPaths::collectInstances(const QString& path) {
qCDebug(logPaths) << "Collecting instances from" << path;
auto instances = QVector<InstanceLockInfo>();
auto dir = QDir(path);
InstanceLockInfo info;
for (auto& entry: dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot)) {
auto path = dir.filePath(entry);
if (QsPaths::checkLock(path, &info)) {
qCDebug(logPaths).nospace() << "Found live instance " << info.instance.instanceId << " (pid "
<< info.pid << ") at " << path;
instances.push_back(info);
} else {
qCDebug(logPaths) << "Skipped dead instance at" << path;
}
}
return instances;
}

28
src/core/paths.hpp
View file

@ -2,17 +2,32 @@
#include <qdatetime.h>
#include <qdir.h>
#include "instanceinfo.hpp"
struct InstanceLockInfo {
pid_t pid = -1;
InstanceInfo instance;
};
QDataStream& operator<<(QDataStream& stream, const InstanceLockInfo& info);
QDataStream& operator>>(QDataStream& stream, InstanceLockInfo& info);
class QsPaths {
public:
static QsPaths* instance();
static void init(QString shellId);
static QDir crashDir(const QString& shellId, const QDateTime& launchTime);
static void init(QString shellId, QString pathId);
static QDir crashDir(const QString& id);
static QString ipcPath(const QString& id);
static bool checkLock(const QString& path, InstanceLockInfo* info = nullptr);
static QVector<InstanceLockInfo> collectInstances(const QString& path);
QDir* cacheDir();
QDir* baseRunDir();
QDir* runDir();
QDir* shellRunDir();
QDir* instanceRunDir();
void linkPidRunDir();
void linkRunDir();
void linkPathDir();
void createLock();
private:
enum class DirState {
@ -22,12 +37,13 @@ private:
};
QString shellId;
QString pathId;
QDir mCacheDir;
QDir mBaseRunDir;
QDir mRunDir;
QDir mShellRunDir;
QDir mInstanceRunDir;
DirState cacheState = DirState::Unknown;
DirState baseRunState = DirState::Unknown;
DirState runState = DirState::Unknown;
DirState shellRunState = DirState::Unknown;
DirState instanceRunState = DirState::Unknown;
};

4
src/crash/handler.cpp
View file

@ -14,7 +14,7 @@
#include <sys/mman.h>
#include <unistd.h>
#include "../core/crashinfo.hpp"
#include "../core/instanceinfo.hpp"
extern char** environ; // NOLINT
@ -64,7 +64,7 @@ void CrashHandler::init() {
qCInfo(logCrashHandler) << "Crash handler initialized.";
}
void CrashHandler::setInstanceInfo(const InstanceInfo& info) {
void CrashHandler::setInstanceInfo(const RelaunchInfo& info) {
this->d->infoFd = memfd_create("quickshell:instance_info", MFD_CLOEXEC);
if (this->d->infoFd == -1) {

4
src/crash/handler.hpp
View file

@ -2,7 +2,7 @@
#include <qtclasshelpermacros.h>
#include "../core/crashinfo.hpp"
#include "../core/instanceinfo.hpp"
namespace qs::crash {
struct CrashHandlerPrivate;
@ -14,7 +14,7 @@ public:
Q_DISABLE_COPY_MOVE(CrashHandler);
void init();
void setInstanceInfo(const InstanceInfo& info);
void setInstanceInfo(const RelaunchInfo& info);
private:
CrashHandlerPrivate* d;

18
src/crash/main.cpp
View file

@ -5,7 +5,6 @@
#include <qapplication.h>
#include <qconfig.h>
#include <qdatastream.h>
#include <qdatetime.h>
#include <qdir.h>
#include <qfile.h>
#include <qlogging.h>
@ -15,7 +14,7 @@
#include <sys/sendfile.h>
#include <sys/types.h>
#include "../core/crashinfo.hpp"
#include "../core/instanceinfo.hpp"
#include "../core/logging.hpp"
#include "../core/paths.hpp"
#include "build.hpp"
@ -23,14 +22,14 @@
Q_LOGGING_CATEGORY(logCrashReporter, "quickshell.crashreporter", QtWarningMsg);
void recordCrashInfo(const QDir& crashDir, const InstanceInfo& instanceInfo);
void recordCrashInfo(const QDir& crashDir, const InstanceInfo& instance);
void qsCheckCrash(int argc, char** argv) {
auto fd = qEnvironmentVariable("__QUICKSHELL_CRASH_DUMP_FD");
if (fd.isEmpty()) return;
auto app = QApplication(argc, argv);
InstanceInfo instance;
RelaunchInfo info;
auto crashProc = qEnvironmentVariable("__QUICKSHELL_CRASH_DUMP_PID").toInt();
@ -42,15 +41,15 @@ void qsCheckCrash(int argc, char** argv) {
file.seek(0);
auto ds = QDataStream(&file);
ds >> instance;
ds >> info;
}
LogManager::init(!instance.noColor, false);
auto crashDir = QsPaths::crashDir(instance.shellId, instance.launchTime);
LogManager::init(!info.noColor, false);
auto crashDir = QsPaths::crashDir(info.instance.instanceId);
qCInfo(logCrashReporter) << "Starting crash reporter...";
recordCrashInfo(crashDir, instance);
recordCrashInfo(crashDir, info.instance);
auto gui = CrashReporterGui(crashDir.path(), crashProc);
gui.show();
@ -125,8 +124,7 @@ void recordCrashInfo(const QDir& crashDir, const InstanceInfo& instance) {
stream << "===== Quickshell Crash =====\n";
stream << "Git Revision: " << GIT_REVISION << '\n';
stream << "Crashed process ID: " << crashProc << '\n';
stream << "Run ID: " << QString("run-%1").arg(instance.launchTime.toMSecsSinceEpoch())
<< '\n';
stream << "Run ID: " << instance.instanceId << '\n';
stream << "\n===== Shell Information =====\n";
stream << "Shell ID: " << instance.shellId << '\n';