Implement new perf elevated privilege system

Instead of using a script that changes system configuration temporarily,
just run perf as root.

To properly synchronize with a launched app (that should not run as root),
launch the app in a separate, initially stopped process, and use the
control fifo feature of perf to properly synchronize with it.

The control fifos are also needed to be able to stop sudo-perf, as one
does not have permission to SIGINT it anymore.

CMakeLists.txt

@@ -144,7 +144,6 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
 endif()
 
 add_subdirectory(3rdparty)
-add_subdirectory(scripts)
 
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 add_subdirectory(src)

README.md

@@ -407,12 +407,7 @@ Consider tweaking /proc/sys/kernel/perf_event_paranoid:
  2 - Disallow kernel profiling for unpriv
 ```
 
-To workaround this limitation, hotspot can temporarily elevate the perf privileges.
-This is achieved by applying
-[these steps](https://superuser.com/questions/980632/run-perf-without-root-right),
-bundled into [a script](scripts/elevate_perf_privileges.sh) that is run via `pkexec`, `kdesudo` or `kdesu`.
-The resulting elevated privileges are also required for kernel tracing in general and Off-CPU profiling in
-particular.
+To workaround this limitation, hotspot can run perf itself with elevated privileges.
 
 ### Export File Format
 

src/CMakeLists.txt

@@ -50,6 +50,8 @@ set(HOTSPOT_SRCS
  perfoutputwidgettext.cpp
  perfoutputwidgetkonsole.cpp
  costcontextmenu.cpp
+ initiallystoppedprocess.cpp
+ perfcontrolfifowrapper.cpp
  # ui files:
  mainwindow.ui
  aboutdialog.ui

src/initiallystoppedprocess.cpp

@@ -0,0 +1,113 @@
+/*
+ SPDX-FileCopyrightText: Zeno Endemann <[email protected]>
+ SPDX-FileCopyrightText: 2023 Klarälvdalens Datakonsult AB, a KDAB Group company, [email protected]
+
+ SPDX-License-Identifier: GPL-2.0-or-later
+*/
+
+#include "initiallystoppedprocess.h"
+
+#include <QDebug>
+#include <QFile>
+#include <QLoggingCategory>
+#include <QSocketNotifier>
+#include <QStandardPaths>
+
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <vector>
+
+namespace {
+Q_LOGGING_CATEGORY(initiallystoppedprocess, "hotspot.initiallystoppedprocess")
+
+void sendSignal(pid_t pid, int signal)
+{
+ if (!kill(pid, signal)) {
+ qCCritical(initiallystoppedprocess, "Failed to send %u to %u", signal, pid);
+ }
+}
+}
+
+InitiallyStoppedProcess::~InitiallyStoppedProcess()
+{
+ kill();
+}
+
+bool InitiallyStoppedProcess::createProcessAndStop(const QString& exePath, const QStringList& exeOptions,
+ const QString& workingDirectory)
+{
+ kill();
+
+ // convert arguments and working dir into what the C API needs
+
+ std::vector<QByteArray> args;
+ args.reserve(exeOptions.size() + 1);
+ args.emplace_back(exePath.toLocal8Bit());
+ for (const auto& opt : exeOptions)
+ args.emplace_back(opt.toLocal8Bit());
+ const auto wd = workingDirectory.toLocal8Bit();
+
+ std::vector<char*> argsArray(args.size() + 1);
+ for (size_t i = 0; i < args.size(); ++i)
+ argsArray[i] = args[i].data();
+ argsArray.back() = nullptr;
+
+ // fork
+ m_pid = fork();
+
+ if (m_pid == 0) { // inside child process
+ // change working dir
+ if (!wd.isEmpty() && chdir(wd.data()) != 0)
+ qFatal("Failed to change working directory to %s", wd.data());
+
+ // stop self
+ raise(SIGSTOP);
+
+ // exec
+ execvp(argsArray[0], argsArray.data());
+ qFatal("Failed to exec %s", argsArray[0]);
+ } else if (m_pid < 0) {
+ qCCritical(initiallystoppedprocess, "Failed to fork (?)");
+ return false;
+ }
+
+ return true;
+}
+
+bool InitiallyStoppedProcess::continueStoppedProcess()
+{
+ if (m_pid <= 0)
+ return false;
+
+ // wait for child to be stopped
+
+ int wstatus;
+ waitpid(m_pid, &wstatus, WUNTRACED);
+ if (!WIFSTOPPED(wstatus)) {
+ m_pid = -1;
+ return false;
+ }
+
+ // continue
+
+ sendSignal(m_pid, SIGCONT);
+ return true;
+}
+
+void InitiallyStoppedProcess::terminate()
+{
+ if (m_pid > 0)
+ sendSignal(m_pid, SIGTERM);
+}
+
+void InitiallyStoppedProcess::kill()
+{
+ if (m_pid > 0) {
+ sendSignal(m_pid, SIGILL);
+ waitpid(m_pid, nullptr, 0);
+ m_pid = -1;
+ }
+}

src/initiallystoppedprocess.h

@@ -0,0 +1,42 @@
+/*
+ SPDX-FileCopyrightText: Zeno Endemann <[email protected]>
+ SPDX-FileCopyrightText: 2023 Klarälvdalens Datakonsult AB, a KDAB Group company, [email protected]
+
+ SPDX-License-Identifier: GPL-2.0-or-later
+*/
+
+#pragma once
+
+#include <QObject>
+#include <QString>
+#include <QStringList>
+
+#include <memory>
+#include <unistd.h>
+
+class QSocketNotifier;
+
+class InitiallyStoppedProcess
+{
+ Q_DISABLE_COPY(InitiallyStoppedProcess)
+public:
+ InitiallyStoppedProcess() = default;
+ ~InitiallyStoppedProcess();
+
+ pid_t processPID() const
+ {
+ return m_pid;
+ }
+
+ // this function stop any existing child an then will create a process and ch into workDir. The process will then be
+ // stopped immediately. After receiving SIGCONT it will run exePath with exeOptions
+ bool createProcessAndStop(const QString& exePath, const QStringList& exeOptions, const QString& workingDirectory);
+
+ // continue stopped process creted by reset, will wait until child is stopped
+ bool continueStoppedProcess();
+ void terminate();
+ void kill();
+
+private:
+ pid_t m_pid = -1;
+};

src/perfcontrolfifowrapper.cpp

@@ -0,0 +1,129 @@
+/*
+ SPDX-FileCopyrightText: Zeno Endemann <[email protected]>
+ SPDX-FileCopyrightText: 2023 Klarälvdalens Datakonsult AB, a KDAB Group company, [email protected]
+
+ SPDX-License-Identifier: GPL-2.0-or-later
+*/
+
+#include "perfcontrolfifowrapper.h"
+
+#include <QDebug>
+#include <QFile>
+#include <QLoggingCategory>
+#include <QRandomGenerator>
+#include <QStandardPaths>
+
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+namespace {
+Q_LOGGING_CATEGORY(perfcontrolfifowrapper, "hotspot.perfcontrolfifowrapper")
+
+QString getRandomString()
+{
+ auto id = 0;
+ while (id < 1000000) {
+ id = QRandomGenerator::global()->generate();
+ }
+ return QString::number(id % 1000000, 16);
+}
+
+int createAndOpenFifo(const char* name)
+{
+ if (mkfifo(name, 0600) != 0) {
+ qCCritical(perfcontrolfifowrapper) << "Cannot create fifo" << name;
+ return -1;
+ }
+
+ auto fd = open(name, O_RDWR);
+ if (fd < 0) {
+ qCCritical(perfcontrolfifowrapper) << "Cannot open fifo" << name;
+ return -1;
+ }
+ return fd;
+}
+}
+
+PerfControlFifoWrapper::~PerfControlFifoWrapper()
+{
+ close();
+}
+
+bool PerfControlFifoWrapper::open()
+{
+ close();
+
+ // QStandardPaths::RuntimeLocation may be empty -> fallback to TempLocation
+ auto fifoParentPath = QStandardPaths::writableLocation(QStandardPaths::RuntimeLocation);
+ if (fifoParentPath.isEmpty())
+ fifoParentPath = QStandardPaths::writableLocation(QStandardPaths::TempLocation);
+
+ const auto fifoBasePath =
+ QLatin1String("%1/hotspot-%2-%3-perf").arg(fifoParentPath, QString::number(getpid()), getRandomString());
+ m_ctlFifoPath = fifoBasePath + QLatin1String("-control.fifo");
+ m_ackFifoPath = fifoBasePath + QLatin1String("-ack.fifo");
+
+ // error is already handles by createAndOpenFifo
+ m_ctlFifoFd = createAndOpenFifo(m_ctlFifoPath.toLocal8Bit().data());
+ if (m_ctlFifoFd < 0)
+ return false;
+
+ m_ackFifoFd = createAndOpenFifo(m_ackFifoPath.toLocal8Bit().data());
+ if (m_ackFifoFd < 0)
+ return false;
+
+ return true;
+}
+
+void PerfControlFifoWrapper::requestStart()
+{
+ if (m_ctlFifoFd < 0) {
+ emit noFIFO();
+ return;
+ }
+
+ m_ackReady = std::make_unique<QSocketNotifier>(m_ackFifoFd, QSocketNotifier::Read);
+ connect(m_ackReady.get(), &QSocketNotifier::activated, this, [this]() {
+ char buf[10];
+ read(m_ackFifoFd, buf, sizeof(buf));
+ emit started();
+ m_ackReady->disconnect(this);
+ });
+
+ const char start_cmd[] = "enable\n";
+ write(m_ctlFifoFd, start_cmd, sizeof(start_cmd) - 1);
+}
+
+void PerfControlFifoWrapper::requestStop()
+{
+ if (m_ctlFifoFd < 0) {
+ emit noFIFO();
+ return;
+ }
+ const char stop_cmd[] = "stop\n";
+ write(m_ctlFifoFd, stop_cmd, sizeof(stop_cmd) - 1);
+}
+
+void PerfControlFifoWrapper::close()
+{
+ if (m_ackReady) {
+ m_ackReady = nullptr;
+ }
+ if (m_ctlFifoFd >= 0) {
+ ::close(m_ctlFifoFd);
+ m_ctlFifoFd = -1;
+ }
+ if (m_ackFifoFd >= 0) {
+ ::close(m_ackFifoFd);
+ m_ackFifoFd = -1;
+ }
+ if (!m_ctlFifoPath.isEmpty()) {
+ QFile::remove(m_ctlFifoPath);
+ m_ctlFifoPath.clear();
+ }
+ if (!m_ackFifoPath.isEmpty()) {
+ QFile::remove(m_ackFifoPath);
+ m_ackFifoPath.clear();
+ }
+}