Valgrind: Merge ValgrindRunner and ValgrindProcess

There was a 1:1 matching remaining. Change-Id: I619bedcda867b642eab37396a0bd48bcb3a5829a Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
2017-06-29 15:03:06 +02:00
parent 7a09bb4418
commit 8678117572
11 changed files with 209 additions and 483 deletions
--- a/src/plugins/valgrind/valgrindrunner.cpp
+++ b/src/plugins/valgrind/valgrindrunner.cpp
@@ -25,57 +25,199 @@
 ****************************************************************************/

 #include "valgrindrunner.h"
-#include "valgrindprocess.h"

 #include "xmlprotocol/threadedparser.h"

-#include <projectexplorer/runnables.h>
-
-#include <utils/environment.h>
 #include <utils/hostosinfo.h>
 #include <utils/qtcassert.h>
-
-#include <ssh/sshconnection.h>
-#include <ssh/sshremoteprocess.h>
+#include <utils/qtcprocess.h>

 #include <QEventLoop>
-#include <QNetworkInterface>
 #include <QTcpServer>
 #include <QTcpSocket>

 using namespace ProjectExplorer;
+using namespace Utils;

 namespace Valgrind {

-class ValgrindRunner::Private
+class ValgrindRunner::Private : public QObject
 {
 public:
+    Private(ValgrindRunner *owner) : q(owner) {}
+
+    void run();
+
+    void handleRemoteStderr(const QByteArray &b);
+    void handleRemoteStdout(const QByteArray &b);
+
+    void closed(bool success);
+    void localProcessStarted();
+    void remoteProcessStarted();
+    void findPIDOutputReceived(const QByteArray &out);
+
+    ValgrindRunner *q;
+    StandardRunnable m_debuggee;
+    ApplicationLauncher m_valgrindProcess;
+    IDevice::ConstPtr m_device;
+
+    ApplicationLauncher m_findPID;
+
+    QString m_valgrindExecutable;
+    QStringList m_valgrindArguments;
+
    QHostAddress localServerAddress;
-    ValgrindProcess process;
    QProcess::ProcessChannelMode channelMode = QProcess::SeparateChannels;
-    bool finished = false;
-    QString valgrindExecutable;
-    QStringList valgrindArguments;
-    StandardRunnable debuggee;
-    IDevice::ConstPtr device;
-    QString tool;
+    bool m_finished = false;
+    QString m_tool;

    QTcpServer xmlServer;
    XmlProtocol::ThreadedParser parser;
    QTcpServer logServer;
    QTcpSocket *logSocket = nullptr;
+
+    // Workaround for valgrind bug when running vgdb with xml output
+    // https://bugs.kde.org/show_bug.cgi?id=343902
    bool disableXml = false;
 };

+void ValgrindRunner::Private::run()
+{
+    connect(&m_valgrindProcess, &ApplicationLauncher::processExited,
+            this, &ValgrindRunner::Private::closed);
+    connect(&m_valgrindProcess, &ApplicationLauncher::processStarted,
+            this, &ValgrindRunner::Private::localProcessStarted);
+    connect(&m_valgrindProcess, &ApplicationLauncher::error,
+            q, &ValgrindRunner::processError);
+    connect(&m_valgrindProcess, &ApplicationLauncher::appendMessage,
+            q, &ValgrindRunner::processOutputReceived);
+    connect(&m_valgrindProcess, &ApplicationLauncher::finished,
+            q, &ValgrindRunner::finished);
+
+    connect(&m_valgrindProcess, &ApplicationLauncher::remoteStderr,
+            this, &ValgrindRunner::Private::handleRemoteStderr);
+    connect(&m_valgrindProcess, &ApplicationLauncher::remoteStdout,
+            this, &ValgrindRunner::Private::handleRemoteStdout);
+    connect(&m_valgrindProcess, &ApplicationLauncher::remoteProcessStarted,
+            this, &ValgrindRunner::Private::remoteProcessStarted);
+
+    QStringList fullArgs = m_valgrindArguments;
+    fullArgs << QString("--tool=%1").arg(m_tool);
+    if (HostOsInfo::isMacHost())
+        // May be slower to start but without it we get no filenames for symbols.
+        fullArgs << "--dsymutil=yes";
+    fullArgs << m_debuggee.executable;
+
+    StandardRunnable valgrind;
+    valgrind.executable = m_valgrindExecutable;
+    valgrind.workingDirectory = m_debuggee.workingDirectory;
+    valgrind.environment = m_debuggee.environment;
+    valgrind.runMode = m_debuggee.runMode;
+    valgrind.device = m_device;
+    valgrind.commandLineArguments = QtcProcess::joinArgs(fullArgs, m_device->osType());
+    Utils::QtcProcess::addArgs(&valgrind.commandLineArguments, m_debuggee.commandLineArguments);
+
+    if (m_device->type() == ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE)
+        m_valgrindProcess.start(valgrind);
+    else
+        m_valgrindProcess.start(valgrind, m_device);
+}
+
+void ValgrindRunner::Private::handleRemoteStderr(const QByteArray &b)
+{
+    if (!b.isEmpty())
+        q->processOutputReceived(QString::fromUtf8(b), Utils::StdErrFormat);
+}
+
+void ValgrindRunner::Private::handleRemoteStdout(const QByteArray &b)
+{
+    if (!b.isEmpty())
+        q->processOutputReceived(QString::fromUtf8(b), Utils::StdOutFormat);
+}
+
+void ValgrindRunner::Private::localProcessStarted()
+{
+    qint64 pid = m_valgrindProcess.applicationPID().pid();
+    emit q->valgrindStarted(pid);
+}
+
+void ValgrindRunner::Private::remoteProcessStarted()
+{
+    // find out what PID our process has
+
+    // NOTE: valgrind cloaks its name,
+    // e.g.: valgrind --tool=memcheck foobar
+    // => ps aux, pidof will see valgrind.bin
+    // => pkill/killall/top... will see memcheck-amd64-linux or similar
+    // hence we need to do something more complex...
+
+    // plain path to exe, m_valgrindExe contains e.g. env vars etc. pp.
+    const QString proc = m_valgrindExecutable.split(' ').last();
+
+    StandardRunnable findPid;
+    findPid.executable = "/bin/sh";
+    // sleep required since otherwise we might only match "bash -c..."
+    //  and not the actual valgrind run
+    findPid.commandLineArguments = QString("-c \""
+                                           "sleep 1; ps ax" // list all processes with aliased name
+                                           " | grep '\\b%1.*%2'" // find valgrind process
+                                           " | tail -n 1" // limit to single process
+                                           // we pick the last one, first would be "bash -c ..."
+                                           " | awk '{print $1;}'" // get pid
+                                           "\""
+                                           ).arg(proc, Utils::FileName::fromString(m_debuggee.executable).fileName());
+
+//    m_remote.m_findPID = m_remote.m_connection->createRemoteProcess(cmd.toUtf8());
+    connect(&m_findPID, &ApplicationLauncher::remoteStderr,
+            this, &ValgrindRunner::Private::handleRemoteStderr);
+    connect(&m_findPID, &ApplicationLauncher::remoteStdout,
+            this, &ValgrindRunner::Private::findPIDOutputReceived);
+    m_findPID.start(findPid, m_device);
+}
+
+void ValgrindRunner::Private::findPIDOutputReceived(const QByteArray &out)
+{
+    if (out.isEmpty())
+        return;
+    bool ok;
+    qint64 pid = out.trimmed().toLongLong(&ok);
+    if (!ok) {
+//        m_remote.m_errorString = tr("Could not determine remote PID.");
+//        emit ValgrindRunner::Private::error(QProcess::FailedToStart);
+//        close();
+    } else {
+        emit q->valgrindStarted(pid);
+    }
+}
+
+void ValgrindRunner::Private::closed(bool success)
+{
+    Q_UNUSED(success);
+//    QTC_ASSERT(m_remote.m_process, return);
+
+//    m_remote.m_errorString = m_remote.m_process->errorString();
+//    if (status == QSsh::SshRemoteProcess::FailedToStart) {
+//        m_remote.m_error = QProcess::FailedToStart;
+//        q->processError(QProcess::FailedToStart);
+//    } else if (status == QSsh::SshRemoteProcess::NormalExit) {
+//        q->processFinished(m_remote.m_process->exitCode(), QProcess::NormalExit);
+//    } else if (status == QSsh::SshRemoteProcess::CrashExit) {
+//        m_remote.m_error = QProcess::Crashed;
+//        q->processFinished(m_remote.m_process->exitCode(), QProcess::CrashExit);
+//    }
+     q->processFinished(0, QProcess::NormalExit);
+}
+
+
 ValgrindRunner::ValgrindRunner(QObject *parent)
-    : QObject(parent), d(new Private)
+    : QObject(parent), d(new Private(this))
 {
    setToolName("memcheck");
 }

 ValgrindRunner::~ValgrindRunner()
 {
-    if (d->process.isRunning()) {
+    if (d->m_valgrindProcess.isRunning()) {
        // make sure we don't delete the thread while it's still running
        waitForFinished();
    }
@@ -89,37 +231,17 @@ ValgrindRunner::~ValgrindRunner()

 void ValgrindRunner::setValgrindExecutable(const QString &executable)
 {
-    d->valgrindExecutable = executable;
-}
-
-QString ValgrindRunner::valgrindExecutable() const
-{
-    return d->valgrindExecutable;
+    d->m_valgrindExecutable = executable;
 }

 void ValgrindRunner::setValgrindArguments(const QStringList &toolArguments)
 {
-    d->valgrindArguments = toolArguments;
-}
-
-QStringList ValgrindRunner::valgrindArguments() const
-{
-    return d->valgrindArguments;
-}
-
-QStringList ValgrindRunner::fullValgrindArguments() const
-{
-    QStringList fullArgs = valgrindArguments();
-    fullArgs << QString("--tool=%1").arg(d->tool);
-    if (Utils::HostOsInfo::isMacHost())
-        // May be slower to start but without it we get no filenames for symbols.
-        fullArgs << QLatin1String("--dsymutil=yes");
-    return fullArgs;
+    d->m_valgrindArguments = toolArguments;
 }

 void ValgrindRunner::setDebuggee(const StandardRunnable &debuggee)
 {
-    d->debuggee = debuggee;
+    d->m_debuggee = debuggee;
 }

 void ValgrindRunner::setProcessChannelMode(QProcess::ProcessChannelMode mode)
@@ -134,17 +256,12 @@ void ValgrindRunner::setLocalServerAddress(const QHostAddress &localServerAddres

 void ValgrindRunner::setDevice(const IDevice::ConstPtr &device)
 {
-    d->device = device;
-}
-
-IDevice::ConstPtr ValgrindRunner::device() const
-{
-    return d->device;
+    d->m_device = device;
 }

 void ValgrindRunner::waitForFinished() const
 {
-    if (d->finished)
+    if (d->m_finished)
        return;

    QEventLoop loop;
@@ -154,7 +271,22 @@ void ValgrindRunner::waitForFinished() const

 void ValgrindRunner::setToolName(const QString &toolName)
 {
-    d->tool = toolName;
+    d->m_tool = toolName;
+}
+
+static void handleSocketParameter(const QString &prefix, const QTcpServer &tcpServer,
+                            bool *useXml, QStringList *arguments)
+{
+    QHostAddress serverAddress = tcpServer.serverAddress();
+    if (serverAddress.protocol() != QAbstractSocket::IPv4Protocol) {
+        // Report will end up in the Application Output pane, i.e. not have
+        // clickable items, but that's better than nothing.
+        qWarning("Need IPv4 for valgrind");
+        *useXml = false;
+    } else {
+        *arguments << QString("%1=%2:%3").arg(prefix).arg(serverAddress.toString())
+                                         .arg(tcpServer.serverPort());
+    }
 }

 bool ValgrindRunner::start()
@@ -162,37 +294,35 @@ bool ValgrindRunner::start()
    if (!d->localServerAddress.isNull()) {
        if (!startServers())
            return false;
-        setValgrindArguments(memcheckLogArguments() + valgrindArguments());
+
+        bool enableXml = !d->disableXml;
+
+        QStringList arguments = {"--child-silent-after-fork=yes"};
+
+        handleSocketParameter("--xml-socket", d->xmlServer, &enableXml, &arguments);
+        handleSocketParameter("--log-socket", d->logServer, &enableXml, &arguments);
+
+        if (enableXml)
+            arguments << "--xml=yes";
+
+        d->m_valgrindArguments = arguments + d->m_valgrindArguments;
    }

-    d->process.setProcessChannelMode(d->channelMode);
-    d->process.setDevice(d->device);
+    d->m_valgrindProcess.setProcessChannelMode(d->channelMode);
    // consider appending our options last so they override any interfering user-supplied options
    // -q as suggested by valgrind manual
-    d->process.setValgrindExecutable(d->valgrindExecutable);
-    d->process.setValgrindArguments(fullValgrindArguments());
-    d->process.setDebuggee(d->debuggee);
-
-    QObject::connect(&d->process, &ValgrindProcess::processOutput,
-                     this, &ValgrindRunner::processOutputReceived);
-    QObject::connect(&d->process, &ValgrindProcess::valgrindStarted,
-                     this, &ValgrindRunner::onValgrindStarted);
-    QObject::connect(&d->process, &ValgrindProcess::finished,
-                     this, &ValgrindRunner::processFinished);
-    QObject::connect(&d->process, &ValgrindProcess::error,
-                     this, &ValgrindRunner::processError);
-
-    d->process.run(d->debuggee.runMode);
+    d->m_valgrindExecutable = d->m_valgrindExecutable;
+    d->run();

    return true;
 }

 void ValgrindRunner::processError(QProcess::ProcessError e)
 {
-    if (d->finished)
+    if (d->m_finished)
        return;

-    d->finished = true;
+    d->m_finished = true;

    // make sure we don't wait for the connection anymore
    emit processErrorReceived(errorString(), e);
@@ -203,31 +333,26 @@ void ValgrindRunner::processFinished(int ret, QProcess::ExitStatus status)
 {
    emit extraProcessFinished();

-    if (d->finished)
+    if (d->m_finished)
        return;

-    d->finished = true;
+    d->m_finished = true;

    // make sure we don't wait for the connection anymore
    emit finished();

    if (ret != 0 || status == QProcess::CrashExit)
-        emit processErrorReceived(errorString(), d->process.processError());
+        emit processErrorReceived(errorString(), d->m_valgrindProcess.processError());
 }

 QString ValgrindRunner::errorString() const
 {
-    return d->process.errorString();
+    return d->m_valgrindProcess.errorString();
 }

 void ValgrindRunner::stop()
 {
-    d->process.close();
-}
-
-ValgrindProcess *ValgrindRunner::valgrindProcess() const
-{
-    return &d->process;
+    d->m_valgrindProcess.stop();
 }

 XmlProtocol::ThreadedParser *ValgrindRunner::parser() const
@@ -235,19 +360,6 @@ XmlProtocol::ThreadedParser *ValgrindRunner::parser() const
    return &d->parser;
 }

-
-// Workaround for valgrind bug when running vgdb with xml output
-// https://bugs.kde.org/show_bug.cgi?id=343902
-void ValgrindRunner::disableXml()
-{
-    d->disableXml = true;
-}
-
-void ValgrindRunner::onValgrindStarted(qint64 pid)
-{
-    emit valgrindStarted(pid);
-}
-
 void ValgrindRunner::xmlSocketConnected()
 {
    QTcpSocket *socket = d->xmlServer.nextPendingConnection();
@@ -295,34 +407,4 @@ bool ValgrindRunner::startServers()
    return true;
 }

-static void handleSocketParameter(const QString &prefix, const QTcpServer &tcpServer,
-                            bool *useXml, QStringList *arguments)
-{
-    QHostAddress serverAddress = tcpServer.serverAddress();
-    if (serverAddress.protocol() != QAbstractSocket::IPv4Protocol) {
-        // Report will end up in the Application Output pane, i.e. not have
-        // clickable items, but that's better than nothing.
-        qWarning("Need IPv4 for valgrind");
-        *useXml = false;
-    } else {
-        *arguments << QString("%1=%2:%3").arg(prefix).arg(serverAddress.toString())
-                                         .arg(tcpServer.serverPort());
-    }
-}
-
-QStringList ValgrindRunner::memcheckLogArguments() const
-{
-    bool enableXml = !d->disableXml;
-
-    QStringList arguments = {"--child-silent-after-fork=yes"};
-
-    handleSocketParameter("--xml-socket", d->xmlServer, &enableXml, &arguments);
-    handleSocketParameter("--log-socket", d->logServer, &enableXml, &arguments);
-
-    if (enableXml)
-        arguments << "--xml=yes";
-
-    return arguments;
-}
-
 } // namespace Valgrind