feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Android: Rename some gdbServer* to debugServer*

Browse Source 
There's LLDB coming into play, and debugServer is what we use on
BareMetal and RemoteLinux, too.

Change-Id: I77f8545ebbe6685708215ac579789f7d4990b7be
Task-number: QTCREATORBUG-23260
Reviewed-by: BogDan Vatra <bogdan@kdab.com>
This commit is contained in:
hjk
2020-04-15 04:33:06 +02:00
parent 4672aff903
commit 6d66733d50
5 changed files with 44 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/plugins/android/androiddebugsupport.cpp
View File

@@ -148,10 +148,10 @@ void AndroidDebugSupport::start()
setUseExtendedRemote(true); setUseExtendedRemote(true);
QString devicePreferredAbi = AndroidManager::apkDevicePreferredAbi(target); QString devicePreferredAbi = AndroidManager::apkDevicePreferredAbi(target);
setAbi(AndroidManager::androidAbi2Abi(devicePreferredAbi)); setAbi(AndroidManager::androidAbi2Abi(devicePreferredAbi));
QUrl gdbServer; QUrl debugServer;
gdbServer.setHost(QHostAddress(QHostAddress::LocalHost).toString()); debugServer.setHost(QHostAddress(QHostAddress::LocalHost).toString());
gdbServer.setPort(m_runner->gdbServerPort().number()); debugServer.setPort(m_runner->debugServerPort().number());
setRemoteChannel(gdbServer); setRemoteChannel(debugServer);
auto qt = static_cast<AndroidQtVersion *>(qtVersion); auto qt = static_cast<AndroidQtVersion *>(qtVersion);
const int minimumNdk = qt ? qt->minimumNDK() : 0; const int minimumNdk = qt ? qt->minimumNDK() : 0;

4
src/plugins/android/androidrunner.cpp
View File

@@ -226,11 +226,11 @@ void AndroidRunner::remoteErrorOutput(const QString &output)
m_outputParser.processOutput(output); m_outputParser.processOutput(output);
} }
void AndroidRunner::handleRemoteProcessStarted(Utils::Port gdbServerPort, void AndroidRunner::handleRemoteProcessStarted(Utils::Port debugServerPort,
const QUrl &qmlServer, qint64 pid) const QUrl &qmlServer, qint64 pid)
{ {
m_pid = ProcessHandle(pid); m_pid = ProcessHandle(pid);
m_gdbServerPort = gdbServerPort; m_debugServerPort = debugServerPort;
m_qmlServer = qmlServer; m_qmlServer = qmlServer;
reportStarted(); reportStarted();
} }

6
src/plugins/android/androidrunner.h
View File

@@ -53,7 +53,7 @@ public:
const QString &intentName = QString()); const QString &intentName = QString());
~AndroidRunner() override; ~AndroidRunner() override;
Utils::Port gdbServerPort() const { return m_gdbServerPort; } Utils::Port debugServerPort() const { return m_debugServerPort; } // GDB or LLDB
QUrl qmlServer() const { return m_qmlServer; } QUrl qmlServer() const { return m_qmlServer; }
Utils::ProcessHandle pid() const { return m_pid; } Utils::ProcessHandle pid() const { return m_pid; }
@@ -72,7 +72,7 @@ private:
void remoteOutput(const QString &output); void remoteOutput(const QString &output);
void remoteErrorOutput(const QString &output); void remoteErrorOutput(const QString &output);
void gotRemoteOutput(const QString &output); void gotRemoteOutput(const QString &output);
void handleRemoteProcessStarted(Utils::Port gdbServerPort, const QUrl &qmlServer, qint64 pid); void handleRemoteProcessStarted(Utils::Port debugServerPort, const QUrl &qmlServer, qint64 pid);
void handleRemoteProcessFinished(const QString &errString = QString()); void handleRemoteProcessFinished(const QString &errString = QString());
void checkAVD(); void checkAVD();
void launchAVD(); void launchAVD();
@@ -83,7 +83,7 @@ private:
QTimer m_checkAVDTimer; QTimer m_checkAVDTimer;
QScopedPointer<AndroidRunnerWorker> m_worker; QScopedPointer<AndroidRunnerWorker> m_worker;
QPointer<ProjectExplorer::Target> m_target; QPointer<ProjectExplorer::Target> m_target;
Utils::Port m_gdbServerPort; Utils::Port m_debugServerPort;
QUrl m_qmlServer; QUrl m_qmlServer;
Utils::ProcessHandle m_pid; Utils::ProcessHandle m_pid;
QmlDebug::QmlOutputParser m_outputParser; QmlDebug::QmlOutputParser m_outputParser;

58
src/plugins/android/androidrunnerworker.cpp
View File

@@ -161,7 +161,7 @@ AndroidRunnerWorker::AndroidRunnerWorker(RunWorker *runner, const QString &packa
, m_adbLogcatProcess(nullptr, deleter) , m_adbLogcatProcess(nullptr, deleter)
, m_psIsAlive(nullptr, deleter) , m_psIsAlive(nullptr, deleter)
, m_logCatRegExp(regExpLogcat) , m_logCatRegExp(regExpLogcat)
, m_gdbServerProcess(nullptr, deleter) , m_debugServerProcess(nullptr, deleter)
, m_jdbProcess(nullptr, deleter) , m_jdbProcess(nullptr, deleter)
{ {
@@ -178,8 +178,8 @@ AndroidRunnerWorker::AndroidRunnerWorker(RunWorker *runner, const QString &packa
m_qmlDebugServices = QmlDebug::QmlPreviewServices; m_qmlDebugServices = QmlDebug::QmlPreviewServices;
else else
m_qmlDebugServices = QmlDebug::NoQmlDebugServices; m_qmlDebugServices = QmlDebug::NoQmlDebugServices;
m_localGdbServerPort = Utils::Port(5039); m_localDebugServerPort = Utils::Port(5039);
QTC_CHECK(m_localGdbServerPort.isValid()); QTC_CHECK(m_localDebugServerPort.isValid());
if (m_qmlDebugServices != QmlDebug::NoQmlDebugServices) { if (m_qmlDebugServices != QmlDebug::NoQmlDebugServices) {
qCDebug(androidRunWorkerLog) << "QML debugging enabled"; qCDebug(androidRunWorkerLog) << "QML debugging enabled";
QTcpServer server; QTcpServer server;
@@ -228,8 +228,8 @@ AndroidRunnerWorker::AndroidRunnerWorker(RunWorker *runner, const QString &packa
QtSupport::BaseQtVersion *version = QtSupport::QtKitAspect::qtVersion(target->kit()); QtSupport::BaseQtVersion *version = QtSupport::QtKitAspect::qtVersion(target->kit());
QString preferredAbi = AndroidManager::apkDevicePreferredAbi(target); QString preferredAbi = AndroidManager::apkDevicePreferredAbi(target);
if (!preferredAbi.isEmpty()) if (!preferredAbi.isEmpty())
m_gdbserverPath = AndroidConfigurations::instance() m_debugServerPath = AndroidConfigurations::currentConfig()
->currentConfig().gdbServer(preferredAbi, version).toString(); .gdbServer(preferredAbi, version).toString();
m_useAppParamsForQmlDebugger = version->qtVersion() >= QtSupport::QtVersionNumber(5, 12); m_useAppParamsForQmlDebugger = version->qtVersion() >= QtSupport::QtVersionNumber(5, 12);
} }
@@ -254,9 +254,9 @@ bool AndroidRunnerWorker::runAdb(const QStringList &args, QString *stdOut,
return result.success(); return result.success();
} }
bool AndroidRunnerWorker::uploadGdbServer() bool AndroidRunnerWorker::uploadDebugServer()
{ {
// Push the gdbserver to temp location and then to package dir. // Push the gdbserver or lldb-server to temp location and then to package dir.
// the files can't be pushed directly to package because of permissions. // the files can't be pushed directly to package because of permissions.
qCDebug(androidRunWorkerLog) << "Uploading GdbServer"; qCDebug(androidRunWorkerLog) << "Uploading GdbServer";
@@ -281,7 +281,7 @@ bool AndroidRunnerWorker::uploadGdbServer()
*tempGdbServerPath = tempGdbServerPath->arg(count); *tempGdbServerPath = tempGdbServerPath->arg(count);
// Copy gdbserver to temp location // Copy gdbserver to temp location
if (!runAdb({"push", m_gdbserverPath , *tempGdbServerPath})) { if (!runAdb({"push", m_debugServerPath , *tempGdbServerPath})) {
qCDebug(androidRunWorkerLog) << "Gdbserver upload to temp directory failed"; qCDebug(androidRunWorkerLog) << "Gdbserver upload to temp directory failed";
return false; return false;
} }
@@ -447,32 +447,32 @@ void AndroidRunnerWorker::asyncStartHelper()
// e.g. on Android 8 with NDK 10e // e.g. on Android 8 with NDK 10e
runAdb({"shell", "run-as", m_packageName, "chmod", "a+x", packageDir.trimmed()}); runAdb({"shell", "run-as", m_packageName, "chmod", "a+x", packageDir.trimmed()});
QString gdbServerExecutable = "gdbserver"; QString debugServerExecutable = "gdbserver";
QString gdbServerPrefix = "./lib/"; QString debugServerPrefix = "./lib/";
auto findGdbServer = [this, &gdbServerExecutable, gdbServerPrefix](const QString& gdbEx) { auto findGdbServer = [this, &debugServerExecutable, debugServerPrefix](const QString& gdbEx) {
if (!packageFileExists(gdbServerPrefix + gdbEx)) if (!packageFileExists(debugServerPrefix + gdbEx))
return false; return false;
gdbServerExecutable = gdbEx; debugServerExecutable = gdbEx;
return true; return true;
}; };
if (!findGdbServer("gdbserver") && !findGdbServer("libgdbserver.so")) { if (!findGdbServer("gdbserver") && !findGdbServer("libgdbserver.so")) {
// Armv8. symlink lib is not available. // Armv8. symlink lib is not available.
// Kill the previous instances of gdbserver. Do this before copying the gdbserver. // Kill the previous instances of gdbserver. Do this before copying the gdbserver.
runAdb({"shell", "run-as", m_packageName, "killall", gdbServerExecutable}); runAdb({"shell", "run-as", m_packageName, "killall", debugServerExecutable});
if (!m_gdbserverPath.isEmpty() && uploadGdbServer()) { if (!m_debugServerPath.isEmpty() && uploadDebugServer()) {
gdbServerPrefix = "./"; debugServerPrefix = "./";
} else { } else {
emit remoteProcessFinished(tr("Cannot find or copy C++ debug server.")); emit remoteProcessFinished(tr("Cannot find or copy C++ debug server."));
return; return;
} }
} else { } else {
qCDebug(androidRunWorkerLog) << "Found GDB server under ./lib"; qCDebug(androidRunWorkerLog) << "Found GDB server under ./lib";
runAdb({"shell", "run-as", m_packageName, "killall", gdbServerExecutable}); runAdb({"shell", "run-as", m_packageName, "killall", debugServerExecutable});
} }
QString debuggerServerErr; QString debuggerServerErr;
if (!startDebuggerServer(packageDir, gdbServerPrefix, gdbServerExecutable, &debuggerServerErr)) { if (!startDebuggerServer(packageDir, debugServerPrefix, debugServerExecutable, &debuggerServerErr)) {
emit remoteProcessFinished(debuggerServerErr); emit remoteProcessFinished(debuggerServerErr);
return; return;
} }
@@ -525,8 +525,8 @@ void AndroidRunnerWorker::asyncStartHelper()
} }
bool AndroidRunnerWorker::startDebuggerServer(const QString &packageDir, bool AndroidRunnerWorker::startDebuggerServer(const QString &packageDir,
const QString &gdbServerPrefix, const QString &debugServerPrefix,
const QString &gdbServerExecutable, const QString &debugServerExecutable,
QString *errorStr) QString *errorStr)
{ {
QString gdbServerSocket = packageDir + "/debug-socket"; QString gdbServerSocket = packageDir + "/debug-socket";
@@ -534,22 +534,22 @@ bool AndroidRunnerWorker::startDebuggerServer(const QString &packageDir,
QString gdbProcessErr; QString gdbProcessErr;
QStringList gdbServerArgs = selector(); QStringList gdbServerArgs = selector();
gdbServerArgs << "shell" << "run-as" << m_packageName << gdbServerPrefix + gdbServerExecutable gdbServerArgs << "shell" << "run-as" << m_packageName << debugServerPrefix + debugServerExecutable
<< "--multi" << "+" + gdbServerSocket; << "--multi" << "+" + gdbServerSocket;
m_gdbServerProcess.reset(AndroidManager::runAdbCommandDetached(gdbServerArgs, &gdbProcessErr)); m_debugServerProcess.reset(AndroidManager::runAdbCommandDetached(gdbServerArgs, &gdbProcessErr));
if (!m_gdbServerProcess) { if (!m_debugServerProcess) {
qCDebug(androidRunWorkerLog) << "Debugger process failed to start" << gdbProcessErr; qCDebug(androidRunWorkerLog) << "Debugger process failed to start" << gdbProcessErr;
if (errorStr) if (errorStr)
*errorStr = tr("Failed to start debugger server."); *errorStr = tr("Failed to start debugger server.");
return false; return false;
} }
qCDebug(androidRunWorkerLog) << "Debugger process started"; qCDebug(androidRunWorkerLog) << "Debugger process started";
m_gdbServerProcess->setObjectName("AndroidDebugServerProcess"); m_debugServerProcess->setObjectName("AndroidDebugServerProcess");
QStringList removeForward{"forward", "--remove", "tcp:" + m_localGdbServerPort.toString()}; QStringList removeForward{"forward", "--remove", "tcp:" + m_localDebugServerPort.toString()};
runAdb(removeForward); runAdb(removeForward);
if (!runAdb({"forward", "tcp:" + m_localGdbServerPort.toString(), if (!runAdb({"forward", "tcp:" + m_localDebugServerPort.toString(),
"localfilesystem:" + gdbServerSocket})) { "localfilesystem:" + gdbServerSocket})) {
if (errorStr) if (errorStr)
*errorStr = tr("Failed to forward C++ debugging ports."); *errorStr = tr("Failed to forward C++ debugging ports.");
@@ -577,7 +577,7 @@ void AndroidRunnerWorker::asyncStop()
forceStop(); forceStop();
m_jdbProcess.reset(); m_jdbProcess.reset();
m_gdbServerProcess.reset(); m_debugServerProcess.reset();
} }
void AndroidRunnerWorker::handleJdbWaiting() void AndroidRunnerWorker::handleJdbWaiting()
@@ -659,7 +659,7 @@ void AndroidRunnerWorker::onProcessIdChanged(qint64 pid)
m_adbLogcatProcess.reset(); m_adbLogcatProcess.reset();
m_psIsAlive.reset(); m_psIsAlive.reset();
m_jdbProcess.reset(); m_jdbProcess.reset();
m_gdbServerProcess.reset(); m_debugServerProcess.reset();
// Run adb commands after application quit. // Run adb commands after application quit.
for (const QString &entry: m_afterFinishAdbCommands) for (const QString &entry: m_afterFinishAdbCommands)
@@ -667,7 +667,7 @@ void AndroidRunnerWorker::onProcessIdChanged(qint64 pid)
} else { } else {
// In debugging cases this will be funneled to the engine to actually start // In debugging cases this will be funneled to the engine to actually start
// and attach gdb. Afterwards this ends up in handleRemoteDebuggerRunning() below. // and attach gdb. Afterwards this ends up in handleRemoteDebuggerRunning() below.
emit remoteProcessStarted(m_localGdbServerPort, m_qmlServer, m_processPID); emit remoteProcessStarted(m_localDebugServerPort, m_qmlServer, m_processPID);
logcatReadStandardOutput(); logcatReadStandardOutput();
QTC_ASSERT(!m_psIsAlive, /**/); QTC_ASSERT(!m_psIsAlive, /**/);
QStringList isAliveArgs = selector() << "shell" << pidPollingScript.arg(m_processPID); QStringList isAliveArgs = selector() << "shell" << pidPollingScript.arg(m_processPID);

12
src/plugins/android/androidrunnerworker.h
View File

@@ -64,7 +64,7 @@ public:
void handleJdbSettled(); void handleJdbSettled();
signals: signals:
void remoteProcessStarted(Utils::Port gdbServerPort, const QUrl &qmlServer, qint64 pid); void remoteProcessStarted(Utils::Port debugServerPort, const QUrl &qmlServer, qint64 pid);
void remoteProcessFinished(const QString &errString = QString()); void remoteProcessFinished(const QString &errString = QString());
void remoteOutput(const QString &output); void remoteOutput(const QString &output);
@@ -73,10 +73,10 @@ signals:
private: private:
void asyncStartHelper(); void asyncStartHelper();
bool startDebuggerServer(const QString &packageDir, const QString &gdbServerPrefix, bool startDebuggerServer(const QString &packageDir, const QString &gdbServerPrefix,
const QString &gdbServerExecutable, QString *errorStr = nullptr); const QString &debugServerExecutable, QString *errorStr = nullptr);
bool deviceFileExists(const QString &filePath); bool deviceFileExists(const QString &filePath);
bool packageFileExists(const QString& filePath); bool packageFileExists(const QString& filePath);
bool uploadGdbServer(); bool uploadDebugServer();
enum class JDBState { enum class JDBState {
Idle, Idle,
@@ -102,17 +102,17 @@ private:
QFuture<qint64> m_pidFinder; QFuture<qint64> m_pidFinder;
bool m_useCppDebugger = false; bool m_useCppDebugger = false;
QmlDebug::QmlDebugServicesPreset m_qmlDebugServices; QmlDebug::QmlDebugServicesPreset m_qmlDebugServices;
Utils::Port m_localGdbServerPort; // Local end of forwarded debug socket. Utils::Port m_localDebugServerPort; // Local end of forwarded debug socket.
QUrl m_qmlServer; QUrl m_qmlServer;
JDBState m_jdbState = JDBState::Idle; JDBState m_jdbState = JDBState::Idle;
Utils::Port m_localJdbServerPort; Utils::Port m_localJdbServerPort;
std::unique_ptr<QProcess, Deleter> m_gdbServerProcess; std::unique_ptr<QProcess, Deleter> m_debugServerProcess; // gdbserver or lldb-server
std::unique_ptr<QProcess, Deleter> m_jdbProcess; std::unique_ptr<QProcess, Deleter> m_jdbProcess;
QString m_deviceSerialNumber; QString m_deviceSerialNumber;
int m_apiLevel = -1; int m_apiLevel = -1;
QString m_extraAppParams; QString m_extraAppParams;
Utils::Environment m_extraEnvVars; Utils::Environment m_extraEnvVars;
QString m_gdbserverPath; QString m_debugServerPath;
bool m_useAppParamsForQmlDebugger = false; bool m_useAppParamsForQmlDebugger = false;
}; };