[clang] [llvm] [clang][MBD] set up module build daemon infrastructure (PR #67562)
Connor Sughrue via cfe-commits
cfe-commits at lists.llvm.org
Wed Dec 6 13:21:42 PST 2023
https://github.com/cpsughrue updated https://github.com/llvm/llvm-project/pull/67562
>From cbb5a82507438a9428285d25c0f5eb7c62931099 Mon Sep 17 00:00:00 2001
From: cpsughrue <cpsughrue at gmail.com>
Date: Sun, 9 Jul 2023 23:19:58 -0400
Subject: [PATCH 1/9] [clang][MBD] set up module build daemon infrastructure
The module build daemon (mbd) will serve as a cc1 tool that helps convert
implicit module command lines to explicit module command lines. A clang
invocation will check to see if a mbd exists, if not the invocation will spawn
one. After the mbd is up and running and a handshake has successfully been
carried out between the mbd and clang invocation the clang invocation will
share it's command line with the mbd. The mbd will then scan the translation
unit and build all modular dependencies before returning a modified cc1 command
line such that all arguments related to modules are converted from the
implicit option to their explicit option.
This commit sets up the basic mbd infrastructure. Including the ability to
spawn a mbd and carry out a handshake between the clang invocation and mbd.
RFC: https://discourse.llvm.org/t/rfc-modules-build-daemon-build-system-agnostic-support-for-explicitly-built-modules/71524
---
clang/include/clang/Driver/Options.td | 12 +
.../include/clang/Frontend/FrontendOptions.h | 7 +
.../clang/Tooling/ModuleBuildDaemon/Client.h | 44 +++
.../ModuleBuildDaemon/SocketMsgSupport.h | 134 +++++++++
.../Tooling/ModuleBuildDaemon/SocketSupport.h | 31 ++
.../clang/Tooling/ModuleBuildDaemon/Utils.h | 28 ++
clang/lib/Driver/ToolChains/Clang.cpp | 14 +-
clang/lib/Tooling/CMakeLists.txt | 1 +
.../Tooling/ModuleBuildDaemon/CMakeLists.txt | 9 +
.../lib/Tooling/ModuleBuildDaemon/Client.cpp | 167 +++++++++++
.../ModuleBuildDaemon/SocketSupport.cpp | 128 +++++++++
clang/lib/Tooling/ModuleBuildDaemon/Utils.cpp | 32 +++
clang/test/Driver/unknown-arg.c | 2 +-
clang/test/ModuleBuildDaemon/handshake.c | 18 ++
clang/test/ModuleBuildDaemon/launch.c | 14 +
clang/tools/driver/CMakeLists.txt | 3 +
clang/tools/driver/cc1_main.cpp | 28 +-
clang/tools/driver/cc1modbuildd_main.cpp | 267 ++++++++++++++++++
clang/tools/driver/driver.cpp | 17 +-
19 files changed, 947 insertions(+), 9 deletions(-)
create mode 100644 clang/include/clang/Tooling/ModuleBuildDaemon/Client.h
create mode 100644 clang/include/clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h
create mode 100644 clang/include/clang/Tooling/ModuleBuildDaemon/SocketSupport.h
create mode 100644 clang/include/clang/Tooling/ModuleBuildDaemon/Utils.h
create mode 100644 clang/lib/Tooling/ModuleBuildDaemon/CMakeLists.txt
create mode 100644 clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
create mode 100644 clang/lib/Tooling/ModuleBuildDaemon/SocketSupport.cpp
create mode 100644 clang/lib/Tooling/ModuleBuildDaemon/Utils.cpp
create mode 100644 clang/test/ModuleBuildDaemon/handshake.c
create mode 100644 clang/test/ModuleBuildDaemon/launch.c
create mode 100644 clang/tools/driver/cc1modbuildd_main.cpp
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
index 0eec2b3526376..5e749ddbbdc56 100644
--- a/clang/include/clang/Driver/Options.td
+++ b/clang/include/clang/Driver/Options.td
@@ -2923,6 +2923,18 @@ defm declspec : BoolOption<"f", "declspec",
NegFlag<SetFalse, [], [ClangOption], "Disallow">,
BothFlags<[], [ClangOption, CC1Option],
" __declspec as a keyword">>, Group<f_clang_Group>;
+
+def fmodule_build_daemon : Flag<["-"], "fmodule-build-daemon">, Group<f_Group>,
+ Flags<[NoXarchOption]>,
+ Visibility<[ClangOption, CC1Option]>,
+ HelpText<"Enables module build daemon functionality">,
+ MarshallingInfoFlag<FrontendOpts<"ModuleBuildDaemon">>;
+def fmodule_build_daemon_EQ : Joined<["-"], "fmodule-build-daemon=">, Group<f_Group>,
+ Flags<[NoXarchOption]>,
+ Visibility<[ClangOption, CC1Option]>,
+ HelpText<"Enables module build daemon functionality and defines location of output files">,
+ MarshallingInfoString<FrontendOpts<"ModuleBuildDaemonPath">>;
+
def fmodules_cache_path : Joined<["-"], "fmodules-cache-path=">, Group<i_Group>,
Flags<[]>, Visibility<[ClangOption, CC1Option]>,
MetaVarName<"<directory>">,
diff --git a/clang/include/clang/Frontend/FrontendOptions.h b/clang/include/clang/Frontend/FrontendOptions.h
index 53a8681cfdbba..8bdbb69e720e6 100644
--- a/clang/include/clang/Frontend/FrontendOptions.h
+++ b/clang/include/clang/Frontend/FrontendOptions.h
@@ -383,6 +383,9 @@ class FrontendOptions {
LLVM_PREFERRED_TYPE(bool)
unsigned ModulesShareFileManager : 1;
+ /// Connect to module build daemon
+ unsigned ModuleBuildDaemon : 1;
+
CodeCompleteOptions CodeCompleteOpts;
/// Specifies the output format of the AST.
@@ -468,6 +471,10 @@ class FrontendOptions {
/// The output file, if any.
std::string OutputFile;
+ /// If given, the path to the module build daemon's output files and socket
+ /// address
+ std::string ModuleBuildDaemonPath;
+
/// If given, the new suffix for fix-it rewritten files.
std::string FixItSuffix;
diff --git a/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h b/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h
new file mode 100644
index 0000000000000..d7506fa3011cf
--- /dev/null
+++ b/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h
@@ -0,0 +1,44 @@
+//===----------------------------- Protocol.h -----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_CLIENT_H
+#define LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_CLIENT_H
+
+#include "clang/Frontend/CompilerInstance.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Config/llvm-config.h"
+#include "llvm/Support/YAMLParser.h"
+#include "llvm/Support/YAMLTraits.h"
+
+#define MAX_BUFFER 4096
+#define SOCKET_FILE_NAME "mbd.sock"
+#define STDOUT_FILE_NAME "mbd.out"
+#define STDERR_FILE_NAME "mbd.err"
+
+using namespace clang;
+using namespace llvm;
+
+namespace cc1modbuildd {
+
+// Returns where to store log files and socket address. Of the format
+// /tmp/clang-<BLAKE3HashOfClagnFullVersion>/
+std::string getBasePath();
+
+llvm::Error attemptHandshake(int SocketFD);
+
+llvm::Error spawnModuleBuildDaemon(StringRef BasePath, const char *Argv0);
+
+Expected<int> getModuleBuildDaemon(const char *Argv0, StringRef BasePath);
+
+llvm::Error handshakeModuleBuildDaemon(const CompilerInvocation &Clang,
+ const char *Argv0);
+
+} // namespace cc1modbuildd
+
+#endif // LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_PROTOCAL_H
diff --git a/clang/include/clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h b/clang/include/clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h
new file mode 100644
index 0000000000000..16666c177eaa8
--- /dev/null
+++ b/clang/include/clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h
@@ -0,0 +1,134 @@
+//===------------------------- SocketMsgSupport.h -------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_SOCKETMSGSUPPORT_H
+#define LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_SOCKETMSGSUPPORT_H
+
+#include "clang/Tooling/ModuleBuildDaemon/Client.h"
+#include "clang/Tooling/ModuleBuildDaemon/SocketSupport.h"
+
+using namespace clang;
+using namespace llvm;
+
+namespace cc1modbuildd {
+
+enum class ActionType { HANDSHAKE };
+enum class StatusType { REQUEST, SUCCESS, FAILURE };
+
+struct BaseMsg {
+ ActionType MsgAction;
+ StatusType MsgStatus;
+
+ BaseMsg() = default;
+ BaseMsg(ActionType Action, StatusType Status)
+ : MsgAction(Action), MsgStatus(Status) {}
+};
+
+struct HandshakeMsg : public BaseMsg {
+ HandshakeMsg() = default;
+ HandshakeMsg(ActionType Action, StatusType Status)
+ : BaseMsg(Action, Status) {}
+};
+
+template <typename T> std::string getBufferFromSocketMsg(T Msg) {
+ static_assert(std::is_base_of<cc1modbuildd::BaseMsg, T>::value,
+ "T must inherit from cc1modbuildd::BaseMsg");
+
+ std::string Buffer;
+ llvm::raw_string_ostream OS(Buffer);
+ llvm::yaml::Output YamlOut(OS);
+
+ YamlOut << Msg;
+ return Buffer;
+}
+
+template <typename T> Expected<T> getSocketMsgFromBuffer(const char *Buffer) {
+ static_assert(std::is_base_of<cc1modbuildd::BaseMsg, T>::value,
+ "T must inherit from cc1modbuildd::BaseMsg");
+
+ T ClientRequest;
+ llvm::yaml::Input YamlIn(Buffer);
+ YamlIn >> ClientRequest;
+
+ if (YamlIn.error()) {
+ std::string Msg = "Syntax or semantic error during YAML parsing";
+ return llvm::make_error<StringError>(Msg, inconvertibleErrorCode());
+ }
+
+ return ClientRequest;
+}
+
+template <typename T> Expected<T> readSocketMsgFromSocket(int FD) {
+ static_assert(std::is_base_of<cc1modbuildd::BaseMsg, T>::value,
+ "T must inherit from cc1modbuildd::BaseMsg");
+
+ Expected<std::string> MaybeResponseBuffer = readFromSocket(FD);
+ if (!MaybeResponseBuffer)
+ return std::move(MaybeResponseBuffer.takeError());
+
+ // Wait for response from module build daemon
+ Expected<T> MaybeResponse =
+ getSocketMsgFromBuffer<T>(std::move(*MaybeResponseBuffer).c_str());
+ if (!MaybeResponse)
+ return std::move(MaybeResponse.takeError());
+ return std::move(*MaybeResponse);
+}
+
+template <typename T> llvm::Error writeSocketMsgToSocket(T Msg, int FD) {
+ static_assert(std::is_base_of<cc1modbuildd::BaseMsg, T>::value,
+ "T must inherit from cc1modbuildd::BaseMsg");
+
+ std::string Buffer = getBufferFromSocketMsg(Msg);
+ if (llvm::Error Err = writeToSocket(Buffer, FD))
+ return std::move(Err);
+
+ return llvm::Error::success();
+}
+
+template <typename T>
+Expected<int> connectAndWriteSocketMsgToSocket(T Msg, StringRef SocketPath) {
+ static_assert(std::is_base_of<cc1modbuildd::BaseMsg, T>::value,
+ "T must inherit from cc1modbuildd::BaseMsg");
+
+ Expected<int> MaybeFD = connectToSocket(SocketPath);
+ if (!MaybeFD)
+ return std::move(MaybeFD.takeError());
+ int FD = std::move(*MaybeFD);
+
+ if (llvm::Error Err = writeSocketMsgToSocket(Msg, FD))
+ return std::move(Err);
+
+ return FD;
+}
+
+} // namespace cc1modbuildd
+
+template <>
+struct llvm::yaml::ScalarEnumerationTraits<cc1modbuildd::StatusType> {
+ static void enumeration(IO &Io, cc1modbuildd::StatusType &Value) {
+ Io.enumCase(Value, "REQUEST", cc1modbuildd::StatusType::REQUEST);
+ Io.enumCase(Value, "SUCCESS", cc1modbuildd::StatusType::SUCCESS);
+ Io.enumCase(Value, "FAILURE", cc1modbuildd::StatusType::FAILURE);
+ }
+};
+
+template <>
+struct llvm::yaml::ScalarEnumerationTraits<cc1modbuildd::ActionType> {
+ static void enumeration(IO &Io, cc1modbuildd::ActionType &Value) {
+ Io.enumCase(Value, "HANDSHAKE", cc1modbuildd::ActionType::HANDSHAKE);
+ }
+};
+
+template <> struct llvm::yaml::MappingTraits<cc1modbuildd::HandshakeMsg> {
+ static void mapping(IO &Io, cc1modbuildd::HandshakeMsg &Info) {
+ Io.mapRequired("Action", Info.MsgAction);
+ Io.mapRequired("Status", Info.MsgStatus);
+ }
+};
+
+#endif // LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_SOCKETMSGSUPPORT_H
diff --git a/clang/include/clang/Tooling/ModuleBuildDaemon/SocketSupport.h b/clang/include/clang/Tooling/ModuleBuildDaemon/SocketSupport.h
new file mode 100644
index 0000000000000..bc21084faab39
--- /dev/null
+++ b/clang/include/clang/Tooling/ModuleBuildDaemon/SocketSupport.h
@@ -0,0 +1,31 @@
+//===-------------------------- SocketSupport.h ---------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_SOCKETSUPPORT_H
+#define LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_SOCKETSUPPORT_H
+
+#include "clang/Frontend/CompilerInstance.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/YAMLParser.h"
+#include "llvm/Support/YAMLTraits.h"
+
+using namespace clang;
+using namespace llvm;
+
+namespace cc1modbuildd {
+
+Expected<int> createSocket();
+Expected<int> connectToSocket(StringRef SocketPath);
+Expected<int> connectAndWriteToSocket(std::string Buffer, StringRef SocketPath);
+Expected<std::string> readFromSocket(int FD);
+llvm::Error writeToSocket(std::string Buffer, int WriteFD);
+
+} // namespace cc1modbuildd
+
+#endif // LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_SOCKETSUPPORT_H
diff --git a/clang/include/clang/Tooling/ModuleBuildDaemon/Utils.h b/clang/include/clang/Tooling/ModuleBuildDaemon/Utils.h
new file mode 100644
index 0000000000000..000081be92793
--- /dev/null
+++ b/clang/include/clang/Tooling/ModuleBuildDaemon/Utils.h
@@ -0,0 +1,28 @@
+//===------------------------------ Utils.h -------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Functions required by both the module build daemon (server) and clang
+// invocation (client)
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_UTILS_H
+#define LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_UTILS_H
+
+#include "llvm/Support/Error.h"
+#include <string>
+
+namespace cc1modbuildd {
+
+void writeError(llvm::Error Err, std::string Msg);
+std::string getFullErrorMsg(llvm::Error Err, std::string Msg);
+llvm::Error makeStringError(llvm::Error Err, std::string Msg);
+
+} // namespace cc1modbuildd
+
+#endif // LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_UTILS_H
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
index f02f7c841b91f..8adb07e226be2 100644
--- a/clang/lib/Driver/ToolChains/Clang.cpp
+++ b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -5,7 +5,6 @@
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
-
#include "Clang.h"
#include "AMDGPU.h"
#include "Arch/AArch64.h"
@@ -3641,6 +3640,19 @@ static bool RenderModulesOptions(Compilation &C, const Driver &D,
bool HaveStdCXXModules = IsCXX && HaveStd20;
bool HaveModules = HaveStdCXXModules;
+ // -fmodule-build-daemon enables module build daemon functionality
+ if (Args.hasArg(options::OPT_fmodule_build_daemon))
+ Args.AddLastArg(CmdArgs, options::OPT_fmodule_build_daemon);
+
+ // by default module build daemon socket address and output files are saved
+ // under /tmp/ but that can be overridden by providing the
+ // -fmodule-build-daemon=<path> flag
+ if (Arg *A = Args.getLastArg(options::OPT_fmodule_build_daemon_EQ)) {
+ CmdArgs.push_back(
+ Args.MakeArgString(Twine("-fmodule-build-daemon=") + A->getValue()));
+ CmdArgs.push_back("-fmodule-build-daemon");
+ }
+
// -fmodules enables the use of precompiled modules (off by default).
// Users can pass -fno-cxx-modules to turn off modules support for
// C++/Objective-C++ programs.
diff --git a/clang/lib/Tooling/CMakeLists.txt b/clang/lib/Tooling/CMakeLists.txt
index aff39e4de13c0..85752e5773326 100644
--- a/clang/lib/Tooling/CMakeLists.txt
+++ b/clang/lib/Tooling/CMakeLists.txt
@@ -13,6 +13,7 @@ add_subdirectory(DumpTool)
add_subdirectory(Syntax)
add_subdirectory(DependencyScanning)
add_subdirectory(Transformer)
+add_subdirectory(ModuleBuildDaemon)
# Replace the last lib component of the current binary directory with include
string(FIND ${CMAKE_CURRENT_BINARY_DIR} "/lib/" PATH_LIB_START REVERSE)
diff --git a/clang/lib/Tooling/ModuleBuildDaemon/CMakeLists.txt b/clang/lib/Tooling/ModuleBuildDaemon/CMakeLists.txt
new file mode 100644
index 0000000000000..9c1f5dc1aa2c0
--- /dev/null
+++ b/clang/lib/Tooling/ModuleBuildDaemon/CMakeLists.txt
@@ -0,0 +1,9 @@
+set(LLVM_LINK_COMPONENTS
+ Support
+ )
+
+add_clang_library(clangModuleBuildDaemon
+ Client.cpp
+ SocketSupport.cpp
+ Utils.cpp
+ )
diff --git a/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp b/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
new file mode 100644
index 0000000000000..f247c4c64da95
--- /dev/null
+++ b/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
@@ -0,0 +1,167 @@
+//===----------------------------- Client.cpp -----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Tooling/ModuleBuildDaemon/Client.h"
+#include "clang/Basic/Version.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h"
+#include "clang/Tooling/ModuleBuildDaemon/SocketSupport.h"
+#include "clang/Tooling/ModuleBuildDaemon/Utils.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/ScopeExit.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/BLAKE3.h"
+
+// TODO: Make portable
+#if LLVM_ON_UNIX
+
+#include <cerrno>
+#include <filesystem>
+#include <fstream>
+#include <signal.h>
+#include <spawn.h>
+#include <string>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+using namespace clang;
+using namespace llvm;
+using namespace cc1modbuildd;
+
+std::string cc1modbuildd::getBasePath() {
+ llvm::BLAKE3 Hash;
+ Hash.update(getClangFullVersion());
+ auto HashResult = Hash.final<sizeof(uint64_t)>();
+ uint64_t HashValue =
+ llvm::support::endian::read<uint64_t, llvm::support::native>(
+ HashResult.data());
+ std::string Key = toString(llvm::APInt(64, HashValue), 36, /*Signed*/ false);
+
+ // set paths
+ SmallString<128> BasePath;
+ llvm::sys::path::system_temp_directory(/*erasedOnReboot*/ true, BasePath);
+ llvm::sys::path::append(BasePath, "clang-" + Key);
+ return BasePath.c_str();
+}
+
+llvm::Error cc1modbuildd::attemptHandshake(int SocketFD) {
+
+ HandshakeMsg Request{ActionType::HANDSHAKE, StatusType::REQUEST};
+ std::string Buffer = getBufferFromSocketMsg(Request);
+
+ if (llvm::Error Err = writeToSocket(Buffer, SocketFD))
+ return std::move(Err);
+
+ Expected<HandshakeMsg> MaybeServerResponse =
+ readSocketMsgFromSocket<HandshakeMsg>(SocketFD);
+ if (!MaybeServerResponse)
+ return std::move(MaybeServerResponse.takeError());
+
+ HandshakeMsg ServerResponse = std::move(*MaybeServerResponse);
+
+ assert(ServerResponse.MsgAction == ActionType::HANDSHAKE &&
+ "At this point response ActionType should only ever be HANDSHAKE");
+
+ if (ServerResponse.MsgStatus == StatusType::SUCCESS)
+ return llvm::Error::success();
+
+ return llvm::make_error<StringError>(
+ "Received failed handshake response from module build daemon",
+ inconvertibleErrorCode());
+}
+
+llvm::Error cc1modbuildd::spawnModuleBuildDaemon(StringRef BasePath,
+ const char *Argv0) {
+ std::string BasePathStr = BasePath.str();
+ const char *Args[] = {Argv0, "-cc1modbuildd", BasePathStr.c_str(), nullptr};
+ pid_t pid;
+ int EC = posix_spawn(&pid, Args[0],
+ /*file_actions*/ nullptr,
+ /*spawnattr*/ nullptr, const_cast<char **>(Args),
+ /*envp*/ nullptr);
+ if (EC)
+ return createStringError(std::error_code(EC, std::generic_category()),
+ "failed to spawn module build daemon");
+
+ return llvm::Error::success();
+}
+
+Expected<int> cc1modbuildd::getModuleBuildDaemon(const char *Argv0,
+ StringRef BasePath) {
+
+ SmallString<128> SocketPath = BasePath;
+ llvm::sys::path::append(SocketPath, SOCKET_FILE_NAME);
+
+ if (llvm::sys::fs::exists(SocketPath)) {
+ Expected<int> MaybeFD = connectToSocket(SocketPath);
+ if (MaybeFD)
+ return std::move(*MaybeFD);
+ consumeError(MaybeFD.takeError());
+ }
+
+ if (llvm::Error Err = cc1modbuildd::spawnModuleBuildDaemon(BasePath, Argv0))
+ return std::move(Err);
+
+ const unsigned int MICROSEC_IN_SEC = 1000000;
+ constexpr unsigned int MAX_TIME = 30 * MICROSEC_IN_SEC;
+ const unsigned short INTERVAL = 100;
+
+ unsigned int CumulativeTime = 0;
+ unsigned int WaitTime = 0;
+
+ while (CumulativeTime <= MAX_TIME) {
+ // Wait a bit then check to see if the module build daemon has initialized
+ usleep(WaitTime);
+
+ if (llvm::sys::fs::exists(SocketPath)) {
+ Expected<int> MaybeFD = connectToSocket(SocketPath);
+ if (MaybeFD)
+ return std::move(*MaybeFD);
+ consumeError(MaybeFD.takeError());
+ }
+
+ CumulativeTime += INTERVAL;
+ }
+
+ // After waiting 30 seconds give up
+ return llvm::make_error<StringError>(
+ "Module build daemon could not be spawned", inconvertibleErrorCode());
+}
+
+llvm::Error
+cc1modbuildd::handshakeModuleBuildDaemon(const CompilerInvocation &Clang,
+ const char *Argv0) {
+
+ // The module build daemon stores all output files and its socket address
+ // under BasePath. Either set BasePath to a user provided option or create an
+ // appropriate BasePath based on the hash of the clang version
+ std::string BasePath;
+ if (!Clang.getFrontendOpts().ModuleBuildDaemonPath.empty())
+ BasePath = Clang.getFrontendOpts().ModuleBuildDaemonPath;
+ else
+ BasePath = cc1modbuildd::getBasePath();
+
+ // If module build daemon does not exist spawn module build daemon
+ Expected<int> MaybeDaemonFD =
+ cc1modbuildd::getModuleBuildDaemon(Argv0, BasePath);
+ if (!MaybeDaemonFD)
+ return makeStringError(MaybeDaemonFD.takeError(),
+ "Attempt to connect to daemon has failed: ");
+ int DaemonFD = std::move(*MaybeDaemonFD);
+
+ if (llvm::Error HandshakeErr = attemptHandshake(DaemonFD))
+ return makeStringError(std::move(HandshakeErr),
+ "Attempted hadshake with daemon has failed: ");
+
+ return llvm::Error::success();
+}
+
+#endif // LLVM_ON_UNIX
diff --git a/clang/lib/Tooling/ModuleBuildDaemon/SocketSupport.cpp b/clang/lib/Tooling/ModuleBuildDaemon/SocketSupport.cpp
new file mode 100644
index 0000000000000..58526e4422f45
--- /dev/null
+++ b/clang/lib/Tooling/ModuleBuildDaemon/SocketSupport.cpp
@@ -0,0 +1,128 @@
+//===------------------------- SocketSupport.cpp --------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Tooling/ModuleBuildDaemon/SocketSupport.h"
+#include "clang/Basic/Version.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Tooling/ModuleBuildDaemon/Client.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/ScopeExit.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Config/llvm-config.h"
+#include "llvm/Support/BLAKE3.h"
+
+// TODO: Make portable
+#if LLVM_ON_UNIX
+
+#include <cerrno>
+#include <filesystem>
+#include <fstream>
+#include <signal.h>
+#include <spawn.h>
+#include <string>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+Expected<int> cc1modbuildd::createSocket() {
+ int FD;
+ if ((FD = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
+ std::string Msg = "socket create error: " + std::string(strerror(errno));
+ return createStringError(inconvertibleErrorCode(), Msg);
+ }
+ return FD;
+}
+
+Expected<int> cc1modbuildd::connectToSocket(StringRef SocketPath) {
+
+ Expected<int> MaybeFD = cc1modbuildd::createSocket();
+ if (!MaybeFD)
+ return std::move(MaybeFD.takeError());
+
+ int FD = std::move(*MaybeFD);
+
+ struct sockaddr_un Addr;
+ memset(&Addr, 0, sizeof(Addr));
+ Addr.sun_family = AF_UNIX;
+ strncpy(Addr.sun_path, SocketPath.str().c_str(), sizeof(Addr.sun_path) - 1);
+
+ if (connect(FD, (struct sockaddr *)&Addr, sizeof(Addr)) == -1) {
+ close(FD);
+ std::string msg = "socket connect error: " + std::string(strerror(errno));
+ return createStringError(inconvertibleErrorCode(), msg);
+ }
+ return FD;
+}
+
+Expected<int> cc1modbuildd::connectAndWriteToSocket(std::string Buffer,
+ StringRef SocketPath) {
+
+ Expected<int> MaybeConnectedFD = connectToSocket(SocketPath);
+ if (!MaybeConnectedFD)
+ return std::move(MaybeConnectedFD.takeError());
+
+ int ConnectedFD = std::move(*MaybeConnectedFD);
+ llvm::Error Err = writeToSocket(Buffer, ConnectedFD);
+ if (Err)
+ return std::move(Err);
+
+ return ConnectedFD;
+}
+
+Expected<std::string> cc1modbuildd::readFromSocket(int FD) {
+
+ const size_t BUFFER_SIZE = 4096;
+ std::vector<char> Buffer(BUFFER_SIZE);
+ size_t TotalBytesRead = 0;
+
+ ssize_t n;
+ while ((n = read(FD, Buffer.data() + TotalBytesRead,
+ Buffer.size() - TotalBytesRead)) > 0) {
+
+ TotalBytesRead += n;
+ // Read until ...\n encountered (last line of YAML document)
+ if (std::string(&Buffer[TotalBytesRead - 4], 4) == "...\n")
+ break;
+ if (Buffer.size() - TotalBytesRead < BUFFER_SIZE)
+ Buffer.resize(Buffer.size() + BUFFER_SIZE);
+ }
+
+ if (n < 0) {
+ std::string Msg = "socket read error: " + std::string(strerror(errno));
+ return llvm::make_error<StringError>(Msg, inconvertibleErrorCode());
+ }
+ if (n == 0)
+ return llvm::make_error<StringError>("EOF", inconvertibleErrorCode());
+ return std::string(Buffer.begin(), Buffer.end());
+}
+
+llvm::Error cc1modbuildd::writeToSocket(std::string Buffer, int WriteFD) {
+
+ ssize_t BytesToWrite = static_cast<ssize_t>(Buffer.size());
+ const char *Bytes = Buffer.c_str();
+
+ while (BytesToWrite) {
+ ssize_t BytesWritten = write(WriteFD, Bytes, BytesToWrite);
+ if (BytesWritten == -1) {
+ std::string Msg = "socket write error: " + std::string(strerror(errno));
+ return llvm::make_error<StringError>(Msg, inconvertibleErrorCode());
+ }
+
+ if (!BytesWritten || BytesWritten > BytesToWrite)
+ return llvm::errorCodeToError(
+ std::error_code(EIO, std::generic_category()));
+
+ BytesToWrite -= BytesWritten;
+ Bytes += BytesWritten;
+ }
+ return llvm::Error::success();
+}
+
+#endif // LLVM_ON_UNIX
diff --git a/clang/lib/Tooling/ModuleBuildDaemon/Utils.cpp b/clang/lib/Tooling/ModuleBuildDaemon/Utils.cpp
new file mode 100644
index 0000000000000..0e291987faf93
--- /dev/null
+++ b/clang/lib/Tooling/ModuleBuildDaemon/Utils.cpp
@@ -0,0 +1,32 @@
+//===------------------------------ Utils.cpp -----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <clang/Tooling/ModuleBuildDaemon/Utils.h>
+#include <llvm/Support/Error.h>
+#include <string>
+
+using namespace llvm;
+
+void cc1modbuildd::writeError(llvm::Error Err, std::string Msg) {
+ handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {
+ errs() << Msg << EIB.message() << '\n';
+ });
+}
+
+std::string cc1modbuildd::getFullErrorMsg(llvm::Error Err, std::string Msg) {
+ std::string ErrMessage;
+ handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {
+ ErrMessage = Msg + EIB.message();
+ });
+ return ErrMessage;
+}
+
+llvm::Error cc1modbuildd::makeStringError(llvm::Error Err, std::string Msg) {
+ std::string ErrMsg = getFullErrorMsg(std::move(Err), Msg);
+ return llvm::make_error<StringError>(ErrMsg, inconvertibleErrorCode());
+}
diff --git a/clang/test/Driver/unknown-arg.c b/clang/test/Driver/unknown-arg.c
index 52ea0f5ff3220..3a22b824adc5c 100644
--- a/clang/test/Driver/unknown-arg.c
+++ b/clang/test/Driver/unknown-arg.c
@@ -59,7 +59,7 @@
// SILENT-NOT: warning:
// CC1AS-DID-YOU-MEAN: error: unknown argument '-hell'; did you mean '-help'?
// CC1AS-DID-YOU-MEAN: error: unknown argument '--version'; did you mean '-version'?
-// UNKNOWN-INTEGRATED: error: unknown integrated tool '-cc1asphalt'. Valid tools include '-cc1' and '-cc1as'.
+// UNKNOWN-INTEGRATED: error: unknown integrated tool '-cc1asphalt'. Valid tools include '-cc1', '-cc1as', '-cc1gen-reproducer', and '-cc1modbuildd'.
// RUN: %clang -S %s -o %t.s -Wunknown-to-clang-option 2>&1 | FileCheck --check-prefix=IGNORED %s
diff --git a/clang/test/ModuleBuildDaemon/handshake.c b/clang/test/ModuleBuildDaemon/handshake.c
new file mode 100644
index 0000000000000..ac9a5ebab87e4
--- /dev/null
+++ b/clang/test/ModuleBuildDaemon/handshake.c
@@ -0,0 +1,18 @@
+// Check that clang invocation can spawn and handshake with module build daemon
+
+// REQUIRES: !system-windows
+
+// RUN: if pgrep -f "cc1modbuildd mbd-handshake"; then pkill -f "cc1modbuildd mbd-handshake"; fi
+// RUN: rm -rf mbd-handshake %t
+// RUN: split-file %s %t
+
+//--- main.c
+int main() {return 0;}
+
+// RUN: %clang -fmodule-build-daemon=mbd-handshake %t/main.c > output
+// RUN: cat output | FileCheck %s
+
+// CHECK: Completed successfull handshake with module build daemon
+
+// RUN: if pgrep -f "cc1modbuildd mbd-handshake"; then pkill -f "cc1modbuildd mbd-handshake"; fi
+// RUN: rm -rf mbd-handshake %t
diff --git a/clang/test/ModuleBuildDaemon/launch.c b/clang/test/ModuleBuildDaemon/launch.c
new file mode 100644
index 0000000000000..878bdfa4052f5
--- /dev/null
+++ b/clang/test/ModuleBuildDaemon/launch.c
@@ -0,0 +1,14 @@
+// Check that module build daemon can create unix socket
+
+// REQUIRES: !system-windows
+
+// RUN: if pgrep -f "cc1modbuildd mbd-launch"; then pkill -f "cc1modbuildd mbd-launch"; fi
+// RUN: rm -rf mbd-launch %t
+
+// RUN: %clang -cc1modbuildd mbd-launch -v
+// RUN: cat mbd-launch/mbd.out | FileCheck %s
+
+// CHECK: mbd created and binded to socket address at: mbd-launch/mbd.sock
+
+// RUN: if pgrep -f "cc1modbuildd mbd-launch"; then pkill -f "cc1modbuildd mbd-launch"; fi
+// RUN: rm -rf mbd-launch %t
diff --git a/clang/tools/driver/CMakeLists.txt b/clang/tools/driver/CMakeLists.txt
index 2182486f93a55..9f4c7a01f8489 100644
--- a/clang/tools/driver/CMakeLists.txt
+++ b/clang/tools/driver/CMakeLists.txt
@@ -28,6 +28,7 @@ add_clang_tool(clang
cc1_main.cpp
cc1as_main.cpp
cc1gen_reproducer_main.cpp
+ cc1modbuildd_main.cpp
DEPENDS
intrinsics_gen
@@ -39,9 +40,11 @@ clang_target_link_libraries(clang
PRIVATE
clangBasic
clangCodeGen
+ clangDependencyScanning
clangDriver
clangFrontend
clangFrontendTool
+ clangModuleBuildDaemon
clangSerialization
)
diff --git a/clang/tools/driver/cc1_main.cpp b/clang/tools/driver/cc1_main.cpp
index e9d2c6aad371d..25db6bf09082e 100644
--- a/clang/tools/driver/cc1_main.cpp
+++ b/clang/tools/driver/cc1_main.cpp
@@ -25,6 +25,7 @@
#include "clang/Frontend/TextDiagnosticPrinter.h"
#include "clang/Frontend/Utils.h"
#include "clang/FrontendTool/Utils.h"
+#include "clang/Tooling/ModuleBuildDaemon/Client.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Config/llvm-config.h"
#include "llvm/LinkAllPasses.h"
@@ -63,7 +64,7 @@ using namespace llvm::opt;
static void LLVMErrorHandler(void *UserData, const char *Message,
bool GenCrashDiag) {
- DiagnosticsEngine &Diags = *static_cast<DiagnosticsEngine*>(UserData);
+ DiagnosticsEngine &Diags = *static_cast<DiagnosticsEngine *>(UserData);
Diags.Report(diag::err_fe_error_backend) << Message;
@@ -201,7 +202,7 @@ static int PrintSupportedExtensions(std::string TargetStr) {
const llvm::Triple &MachineTriple = TheTargetMachine->getTargetTriple();
const llvm::MCSubtargetInfo *MCInfo = TheTargetMachine->getMCSubtargetInfo();
const llvm::ArrayRef<llvm::SubtargetFeatureKV> Features =
- MCInfo->getAllProcessorFeatures();
+ MCInfo->getAllProcessorFeatures();
llvm::StringMap<llvm::StringRef> DescMap;
for (const llvm::SubtargetFeatureKV &feature : Features)
@@ -270,7 +271,7 @@ int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
if (Clang->getHeaderSearchOpts().UseBuiltinIncludes &&
Clang->getHeaderSearchOpts().ResourceDir.empty())
Clang->getHeaderSearchOpts().ResourceDir =
- CompilerInvocation::GetResourcesPath(Argv0, MainAddr);
+ CompilerInvocation::GetResourcesPath(Argv0, MainAddr);
// Create the actual diagnostics engine.
Clang->createDiagnostics();
@@ -279,8 +280,8 @@ int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
// Set an error handler, so that any LLVM backend diagnostics go through our
// error handler.
- llvm::install_fatal_error_handler(LLVMErrorHandler,
- static_cast<void*>(&Clang->getDiagnostics()));
+ llvm::install_fatal_error_handler(
+ LLVMErrorHandler, static_cast<void *>(&Clang->getDiagnostics()));
DiagsBuffer->FlushDiagnostics(Clang->getDiagnostics());
if (!Success) {
@@ -288,6 +289,23 @@ int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
return 1;
}
+#if LLVM_ON_UNIX
+ // Handle module build daemon functionality if enabled
+ if (Clang->getFrontendOpts().ModuleBuildDaemon) {
+
+ llvm::Error HandshakeErr =
+ cc1modbuildd::handshakeModuleBuildDaemon(Clang->getInvocation(), Argv0);
+ if (HandshakeErr) {
+ handleAllErrors(std::move(HandshakeErr), [&](ErrorInfoBase &EIB) {
+ errs() << EIB.message() << '\n';
+ });
+ return 1;
+ }
+ outs() << "Completed successfull handshake with module build daemon"
+ << '\n';
+ }
+#endif
+
// Execute the frontend actions.
{
llvm::TimeTraceScope TimeScope("ExecuteCompiler");
diff --git a/clang/tools/driver/cc1modbuildd_main.cpp b/clang/tools/driver/cc1modbuildd_main.cpp
new file mode 100644
index 0000000000000..bb8ace9dfde65
--- /dev/null
+++ b/clang/tools/driver/cc1modbuildd_main.cpp
@@ -0,0 +1,267 @@
+//===------- cc1modbuildd_main.cpp - Clang CC1 Module Build Daemon --------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h"
+#include "clang/Tooling/ModuleBuildDaemon/SocketSupport.h"
+#include "clang/Tooling/ModuleBuildDaemon/Utils.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/Support/Program.h"
+#include "llvm/Support/ThreadPool.h"
+#include "llvm/Support/Threading.h"
+#include "llvm/Support/YAMLParser.h"
+#include "llvm/Support/YAMLTraits.h"
+
+// TODO: Make portable
+#if LLVM_ON_UNIX
+
+#include <errno.h>
+#include <fstream>
+#include <mutex>
+#include <optional>
+#include <signal.h>
+#include <sstream>
+#include <stdbool.h>
+#include <string>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/un.h>
+#include <type_traits>
+#include <unistd.h>
+#include <unordered_map>
+
+using namespace llvm;
+using namespace clang;
+using namespace cc1modbuildd;
+
+// Create unbuffered STDOUT stream so that any logging done by module build
+// daemon can be viewed without having to terminate the process
+static raw_fd_ostream &unbuff_outs() {
+ static raw_fd_ostream S(STDOUT_FILENO, false, true);
+ return S;
+}
+
+namespace {
+
+class ModuleBuildDaemonServer {
+public:
+ SmallString<128> BasePath;
+ SmallString<128> SocketPath;
+ SmallString<128> PidPath;
+
+ ModuleBuildDaemonServer(SmallString<128> Path, ArrayRef<const char *> Argv)
+ : BasePath(Path), SocketPath(Path) {
+ llvm::sys::path::append(SocketPath, SOCKET_FILE_NAME);
+ }
+
+ ~ModuleBuildDaemonServer() { shutdownDaemon(SIGTERM); }
+
+ int forkDaemon();
+ int launchDaemon();
+ int listenForClients();
+
+ static void handleClient(int Client);
+
+ void shutdownDaemon(int signal) {
+ unlink(SocketPath.c_str());
+ shutdown(ListenSocketFD, SHUT_RD);
+ close(ListenSocketFD);
+ exit(EXIT_SUCCESS);
+ }
+
+private:
+ // Initializes and returns DiagnosticsEngine
+ pid_t Pid = -1;
+ int ListenSocketFD = -1;
+};
+
+// Required to handle SIGTERM by calling Shutdown
+ModuleBuildDaemonServer *DaemonPtr = nullptr;
+void handleSignal(int Signal) {
+ if (DaemonPtr != nullptr) {
+ DaemonPtr->shutdownDaemon(Signal);
+ }
+}
+} // namespace
+
+static bool verbose = false;
+static void verbose_print(const llvm::Twine &message) {
+ if (verbose) {
+ unbuff_outs() << message << '\n';
+ }
+}
+
+// Forks and detaches process, creating module build daemon
+int ModuleBuildDaemonServer::forkDaemon() {
+
+ pid_t pid = fork();
+
+ if (pid < 0) {
+ exit(EXIT_FAILURE);
+ }
+ if (pid > 0) {
+ exit(EXIT_SUCCESS);
+ }
+
+ Pid = getpid();
+
+ close(STDIN_FILENO);
+ close(STDOUT_FILENO);
+ close(STDERR_FILENO);
+
+ SmallString<128> STDOUT = BasePath;
+ llvm::sys::path::append(STDOUT, STDOUT_FILE_NAME);
+ freopen(STDOUT.c_str(), "a", stdout);
+
+ SmallString<128> STDERR = BasePath;
+ llvm::sys::path::append(STDERR, STDERR_FILE_NAME);
+ freopen(STDERR.c_str(), "a", stderr);
+
+ if (signal(SIGTERM, handleSignal) == SIG_ERR) {
+ errs() << "failed to handle SIGTERM" << '\n';
+ exit(EXIT_FAILURE);
+ }
+ if (signal(SIGHUP, SIG_IGN) == SIG_ERR) {
+ errs() << "failed to ignore SIGHUP" << '\n';
+ exit(EXIT_FAILURE);
+ }
+ if (setsid() == -1) {
+ errs() << "setsid failed" << '\n';
+ exit(EXIT_FAILURE);
+ }
+
+ return EXIT_SUCCESS;
+}
+
+// Creates unix socket for IPC with module build daemon
+int ModuleBuildDaemonServer::launchDaemon() {
+
+ // new socket
+ if ((ListenSocketFD = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
+ std::perror("Socket create error: ");
+ exit(EXIT_FAILURE);
+ }
+
+ struct sockaddr_un addr;
+ memset(&addr, 0, sizeof(struct sockaddr_un));
+ addr.sun_family = AF_UNIX;
+ strncpy(addr.sun_path, SocketPath.c_str(), sizeof(addr.sun_path) - 1);
+
+ // bind to local address
+ if (bind(ListenSocketFD, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
+
+ // If the socket address is already in use, exit because another module
+ // build daemon has successfully launched. When translation units are
+ // compiled in parallel, until the socket file is created, all clang
+ // invocations will spawn a module build daemon.
+ if (errno == EADDRINUSE) {
+ close(ListenSocketFD);
+ exit(EXIT_SUCCESS);
+ }
+ std::perror("Socket bind error: ");
+ exit(EXIT_FAILURE);
+ }
+ verbose_print("mbd created and binded to socket address at: " + SocketPath);
+
+ // set socket to accept incoming connection request
+ unsigned MaxBacklog = llvm::hardware_concurrency().compute_thread_count();
+ if (listen(ListenSocketFD, MaxBacklog) == -1) {
+ std::perror("Socket listen error: ");
+ exit(EXIT_FAILURE);
+ }
+
+ return 0;
+}
+
+// Function submitted to thread pool with each client connection. Not
+// responsible for closing client connections
+void ModuleBuildDaemonServer::handleClient(int Client) {
+
+ // Read handshake from client
+ Expected<HandshakeMsg> MaybeHandshakeMsg =
+ readSocketMsgFromSocket<HandshakeMsg>(Client);
+
+ if (!MaybeHandshakeMsg) {
+ writeError(MaybeHandshakeMsg.takeError(),
+ "Failed to read handshake message from socket: ");
+ return;
+ }
+
+ // Handle HANDSHAKE
+ HandshakeMsg Msg(ActionType::HANDSHAKE, StatusType::SUCCESS);
+ llvm::Error WriteErr = writeSocketMsgToSocket(Msg, Client);
+
+ if (WriteErr) {
+ writeError(std::move(WriteErr),
+ "Failed to notify client that handshake was received");
+ return;
+ }
+ return;
+}
+
+int ModuleBuildDaemonServer::listenForClients() {
+
+ llvm::ThreadPool Pool;
+ int Client;
+
+ while (true) {
+
+ if ((Client = accept(ListenSocketFD, NULL, NULL)) == -1) {
+ std::perror("Socket accept error: ");
+ continue;
+ }
+
+ Pool.async(handleClient, Client);
+ }
+ return 0;
+}
+
+// Module build daemon is spawned with the following command line:
+//
+// clang -cc1modbuildd <path> -v
+//
+// <path> defines the location of all files created by the module build daemon
+// and should follow the format /path/to/dir. For example, `clang
+// -cc1modbuildd /tmp/` creates a socket file at `/tmp/mbd.sock`
+//
+// When a module build daemon is spawned by a cc1 invocations, <path> follows
+// the format /tmp/clang-<BLAKE3HashOfClangFullVersion> and looks something like
+// /tmp/clang-3NXKISKJ0WJTN
+//
+// -v is optional and provides berbose debug information
+//
+int cc1modbuildd_main(ArrayRef<const char *> Argv) {
+
+ if (Argv.size() < 1) {
+ outs() << "spawning a module build daemon requies a command line format of "
+ "`clang -cc1modbuildd <path>`. <path> defines where the module "
+ "build daemon will create mbd.out, mbd.err, mbd.sock"
+ << '\n';
+ return 1;
+ }
+
+ // Where to store log files and socket address
+ // TODO: Add check to confirm BasePath is directory
+ SmallString<128> BasePath(Argv[0]);
+ llvm::sys::fs::create_directories(BasePath);
+ ModuleBuildDaemonServer Daemon(BasePath, Argv);
+
+ // Used to handle signals
+ DaemonPtr = &Daemon;
+
+ if (find(Argv, StringRef("-v")) != Argv.end())
+ verbose = true;
+
+ Daemon.forkDaemon();
+ Daemon.launchDaemon();
+ Daemon.listenForClients();
+
+ return 0;
+}
+
+#endif // LLVM_ON_UNIX
diff --git a/clang/tools/driver/driver.cpp b/clang/tools/driver/driver.cpp
index 531b5b4a61c18..9697bc6d45777 100644
--- a/clang/tools/driver/driver.cpp
+++ b/clang/tools/driver/driver.cpp
@@ -213,6 +213,9 @@ extern int cc1as_main(ArrayRef<const char *> Argv, const char *Argv0,
extern int cc1gen_reproducer_main(ArrayRef<const char *> Argv,
const char *Argv0, void *MainAddr,
const llvm::ToolContext &);
+#if LLVM_ON_UNIX
+extern int cc1modbuildd_main(ArrayRef<const char *> Argv);
+#endif
static void insertTargetAndModeArgs(const ParsedClangName &NameParts,
SmallVectorImpl<const char *> &ArgVector,
@@ -369,9 +372,19 @@ static int ExecuteCC1Tool(SmallVectorImpl<const char *> &ArgV,
if (Tool == "-cc1gen-reproducer")
return cc1gen_reproducer_main(ArrayRef(ArgV).slice(2), ArgV[0],
GetExecutablePathVP, ToolContext);
- // Reject unknown tools.
+ if (Tool == "-cc1modbuildd") {
+#if LLVM_ON_UNIX
+ return cc1modbuildd_main(ArrayRef(ArgV).slice(2));
+#else
+ llvm::errs() << "-cc1modbuildd not supported by current platform" << '\n';
+ return 1;
+#endif
+ }
+
+ // Reject unknown tools
llvm::errs() << "error: unknown integrated tool '" << Tool << "'. "
- << "Valid tools include '-cc1' and '-cc1as'.\n";
+ << "Valid tools include '-cc1', '-cc1as', '-cc1gen-reproducer', "
+ "and '-cc1modbuildd'.\n";
return 1;
}
>From 7aceb6d6062fe53af4e593fcdf74e312da6d07df Mon Sep 17 00:00:00 2001
From: cpsughrue <cpsughrue at gmail.com>
Date: Fri, 29 Sep 2023 00:30:25 -0400
Subject: [PATCH 2/9] Address feedback
- Fix accidental formats
- Clarify HelpText for -fmodule-build-daemon=
- Correct file name in header license comment and header guard comment
- Moved #define(s) used by both the client and server from Client.h to Util.h
- Change socket write functions to take buffer as StringRef instead of std::string
- Fix exponential backoff behavior when waiting for module build daemon to spawn
- Remove unused function from SocketSupport.cpp
- Modify where path to stdout and stderr file descriptors get set
- Add error message for when -fmodule-build-daemon is used on unsupported platform
- Remove parameter from shutdownDaemon because it was never used
- Do not delete temp directory at end of llvm-lit test
- Rename launchDaemon to createDaemonSocket
- Rename handshakeModuleBuildDaemon to spawnModuleBuildDaemonAndHandshake
- Close client before daemon handleClient returns
- Rework read from socket to buffer to better handle stream
---
clang/include/clang/Driver/Options.td | 3 +-
.../clang/Tooling/ModuleBuildDaemon/Client.h | 13 +--
.../ModuleBuildDaemon/SocketMsgSupport.h | 10 +--
.../Tooling/ModuleBuildDaemon/SocketSupport.h | 5 +-
.../clang/Tooling/ModuleBuildDaemon/Utils.h | 5 ++
.../lib/Tooling/ModuleBuildDaemon/Client.cpp | 18 ++--
.../ModuleBuildDaemon/SocketSupport.cpp | 39 +++------
clang/test/ModuleBuildDaemon/handshake.c | 1 -
clang/test/ModuleBuildDaemon/launch.c | 1 -
clang/tools/driver/cc1_main.cpp | 12 +--
clang/tools/driver/cc1modbuildd_main.cpp | 85 ++++++++++++-------
11 files changed, 97 insertions(+), 95 deletions(-)
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
index 5e749ddbbdc56..b4ed1dc404094 100644
--- a/clang/include/clang/Driver/Options.td
+++ b/clang/include/clang/Driver/Options.td
@@ -2932,7 +2932,8 @@ def fmodule_build_daemon : Flag<["-"], "fmodule-build-daemon">, Group<f_Group>,
def fmodule_build_daemon_EQ : Joined<["-"], "fmodule-build-daemon=">, Group<f_Group>,
Flags<[NoXarchOption]>,
Visibility<[ClangOption, CC1Option]>,
- HelpText<"Enables module build daemon functionality and defines location of output files">,
+ HelpText<"Enables module build daemon functionality and defines the path to "
+ "where the module build daemon will write log and socket files">,
MarshallingInfoString<FrontendOpts<"ModuleBuildDaemonPath">>;
def fmodules_cache_path : Joined<["-"], "fmodules-cache-path=">, Group<i_Group>,
diff --git a/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h b/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h
index d7506fa3011cf..eb4cac1aa8b16 100644
--- a/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h
+++ b/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h
@@ -1,4 +1,4 @@
-//===----------------------------- Protocol.h -----------------------------===//
+//===------------------------------ Client.h ------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
@@ -16,11 +16,6 @@
#include "llvm/Support/YAMLParser.h"
#include "llvm/Support/YAMLTraits.h"
-#define MAX_BUFFER 4096
-#define SOCKET_FILE_NAME "mbd.sock"
-#define STDOUT_FILE_NAME "mbd.out"
-#define STDERR_FILE_NAME "mbd.err"
-
using namespace clang;
using namespace llvm;
@@ -36,9 +31,9 @@ llvm::Error spawnModuleBuildDaemon(StringRef BasePath, const char *Argv0);
Expected<int> getModuleBuildDaemon(const char *Argv0, StringRef BasePath);
-llvm::Error handshakeModuleBuildDaemon(const CompilerInvocation &Clang,
- const char *Argv0);
+llvm::Error spawnModuleBuildDaemonAndHandshake(const CompilerInvocation &Clang,
+ const char *Argv0);
} // namespace cc1modbuildd
-#endif // LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_PROTOCAL_H
+#endif // LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_CLIENT_H
diff --git a/clang/include/clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h b/clang/include/clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h
index 16666c177eaa8..0c2994e048925 100644
--- a/clang/include/clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h
+++ b/clang/include/clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h
@@ -47,7 +47,7 @@ template <typename T> std::string getBufferFromSocketMsg(T Msg) {
return Buffer;
}
-template <typename T> Expected<T> getSocketMsgFromBuffer(const char *Buffer) {
+template <typename T> Expected<T> getSocketMsgFromBuffer(StringRef Buffer) {
static_assert(std::is_base_of<cc1modbuildd::BaseMsg, T>::value,
"T must inherit from cc1modbuildd::BaseMsg");
@@ -67,13 +67,13 @@ template <typename T> Expected<T> readSocketMsgFromSocket(int FD) {
static_assert(std::is_base_of<cc1modbuildd::BaseMsg, T>::value,
"T must inherit from cc1modbuildd::BaseMsg");
- Expected<std::string> MaybeResponseBuffer = readFromSocket(FD);
- if (!MaybeResponseBuffer)
- return std::move(MaybeResponseBuffer.takeError());
+ std::string BufferConsumer;
+ if (llvm::Error ReadErr = readFromSocket(FD, BufferConsumer))
+ return std::move(ReadErr);
// Wait for response from module build daemon
Expected<T> MaybeResponse =
- getSocketMsgFromBuffer<T>(std::move(*MaybeResponseBuffer).c_str());
+ getSocketMsgFromBuffer<T>(std::move(BufferConsumer).c_str());
if (!MaybeResponse)
return std::move(MaybeResponse.takeError());
return std::move(*MaybeResponse);
diff --git a/clang/include/clang/Tooling/ModuleBuildDaemon/SocketSupport.h b/clang/include/clang/Tooling/ModuleBuildDaemon/SocketSupport.h
index bc21084faab39..712f65e695086 100644
--- a/clang/include/clang/Tooling/ModuleBuildDaemon/SocketSupport.h
+++ b/clang/include/clang/Tooling/ModuleBuildDaemon/SocketSupport.h
@@ -22,9 +22,8 @@ namespace cc1modbuildd {
Expected<int> createSocket();
Expected<int> connectToSocket(StringRef SocketPath);
-Expected<int> connectAndWriteToSocket(std::string Buffer, StringRef SocketPath);
-Expected<std::string> readFromSocket(int FD);
-llvm::Error writeToSocket(std::string Buffer, int WriteFD);
+llvm::Error readFromSocket(int FD, std::string &BufferConsumer);
+llvm::Error writeToSocket(StringRef Buffer, int WriteFD);
} // namespace cc1modbuildd
diff --git a/clang/include/clang/Tooling/ModuleBuildDaemon/Utils.h b/clang/include/clang/Tooling/ModuleBuildDaemon/Utils.h
index 000081be92793..63ac2bf54c6ba 100644
--- a/clang/include/clang/Tooling/ModuleBuildDaemon/Utils.h
+++ b/clang/include/clang/Tooling/ModuleBuildDaemon/Utils.h
@@ -17,6 +17,11 @@
#include "llvm/Support/Error.h"
#include <string>
+#define MAX_BUFFER 4096
+#define SOCKET_FILE_NAME "mbd.sock"
+#define STDOUT_FILE_NAME "mbd.out"
+#define STDERR_FILE_NAME "mbd.err"
+
namespace cc1modbuildd {
void writeError(llvm::Error Err, std::string Msg);
diff --git a/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp b/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
index f247c4c64da95..766b78ee940d4 100644
--- a/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
+++ b/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
@@ -45,7 +45,7 @@ std::string cc1modbuildd::getBasePath() {
HashResult.data());
std::string Key = toString(llvm::APInt(64, HashValue), 36, /*Signed*/ false);
- // set paths
+ // Set paths
SmallString<128> BasePath;
llvm::sys::path::system_temp_directory(/*erasedOnReboot*/ true, BasePath);
llvm::sys::path::append(BasePath, "clang-" + Key);
@@ -111,13 +111,12 @@ Expected<int> cc1modbuildd::getModuleBuildDaemon(const char *Argv0,
return std::move(Err);
const unsigned int MICROSEC_IN_SEC = 1000000;
- constexpr unsigned int MAX_TIME = 30 * MICROSEC_IN_SEC;
- const unsigned short INTERVAL = 100;
+ constexpr unsigned int MAX_WAIT_TIME = 30 * MICROSEC_IN_SEC;
unsigned int CumulativeTime = 0;
- unsigned int WaitTime = 0;
+ unsigned int WaitTime = 10;
- while (CumulativeTime <= MAX_TIME) {
+ while (CumulativeTime <= MAX_WAIT_TIME) {
// Wait a bit then check to see if the module build daemon has initialized
usleep(WaitTime);
@@ -128,7 +127,9 @@ Expected<int> cc1modbuildd::getModuleBuildDaemon(const char *Argv0,
consumeError(MaybeFD.takeError());
}
- CumulativeTime += INTERVAL;
+ CumulativeTime += WaitTime;
+ // Exponential backoff
+ WaitTime = WaitTime * 2;
}
// After waiting 30 seconds give up
@@ -136,9 +137,8 @@ Expected<int> cc1modbuildd::getModuleBuildDaemon(const char *Argv0,
"Module build daemon could not be spawned", inconvertibleErrorCode());
}
-llvm::Error
-cc1modbuildd::handshakeModuleBuildDaemon(const CompilerInvocation &Clang,
- const char *Argv0) {
+llvm::Error cc1modbuildd::spawnModuleBuildDaemonAndHandshake(
+ const CompilerInvocation &Clang, const char *Argv0) {
// The module build daemon stores all output files and its socket address
// under BasePath. Either set BasePath to a user provided option or create an
diff --git a/clang/lib/Tooling/ModuleBuildDaemon/SocketSupport.cpp b/clang/lib/Tooling/ModuleBuildDaemon/SocketSupport.cpp
index 58526e4422f45..ae1e40a9a4437 100644
--- a/clang/lib/Tooling/ModuleBuildDaemon/SocketSupport.cpp
+++ b/clang/lib/Tooling/ModuleBuildDaemon/SocketSupport.cpp
@@ -10,6 +10,7 @@
#include "clang/Basic/Version.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Tooling/ModuleBuildDaemon/Client.h"
+#include "clang/Tooling/ModuleBuildDaemon/Utils.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/ScopeExit.h"
#include "llvm/ADT/SmallString.h"
@@ -61,37 +62,17 @@ Expected<int> cc1modbuildd::connectToSocket(StringRef SocketPath) {
return FD;
}
-Expected<int> cc1modbuildd::connectAndWriteToSocket(std::string Buffer,
- StringRef SocketPath) {
-
- Expected<int> MaybeConnectedFD = connectToSocket(SocketPath);
- if (!MaybeConnectedFD)
- return std::move(MaybeConnectedFD.takeError());
-
- int ConnectedFD = std::move(*MaybeConnectedFD);
- llvm::Error Err = writeToSocket(Buffer, ConnectedFD);
- if (Err)
- return std::move(Err);
-
- return ConnectedFD;
-}
-
-Expected<std::string> cc1modbuildd::readFromSocket(int FD) {
-
- const size_t BUFFER_SIZE = 4096;
- std::vector<char> Buffer(BUFFER_SIZE);
- size_t TotalBytesRead = 0;
+llvm::Error cc1modbuildd::readFromSocket(int FD, std::string &BufferConsumer) {
+ char Buffer[MAX_BUFFER];
ssize_t n;
- while ((n = read(FD, Buffer.data() + TotalBytesRead,
- Buffer.size() - TotalBytesRead)) > 0) {
- TotalBytesRead += n;
+ while ((n = read(FD, Buffer, MAX_BUFFER)) > 0) {
+
+ BufferConsumer.assign(Buffer, n);
// Read until ...\n encountered (last line of YAML document)
- if (std::string(&Buffer[TotalBytesRead - 4], 4) == "...\n")
+ if (BufferConsumer.find("...\n") != std::string::npos)
break;
- if (Buffer.size() - TotalBytesRead < BUFFER_SIZE)
- Buffer.resize(Buffer.size() + BUFFER_SIZE);
}
if (n < 0) {
@@ -100,13 +81,13 @@ Expected<std::string> cc1modbuildd::readFromSocket(int FD) {
}
if (n == 0)
return llvm::make_error<StringError>("EOF", inconvertibleErrorCode());
- return std::string(Buffer.begin(), Buffer.end());
+ return llvm::Error::success();
}
-llvm::Error cc1modbuildd::writeToSocket(std::string Buffer, int WriteFD) {
+llvm::Error cc1modbuildd::writeToSocket(StringRef Buffer, int WriteFD) {
ssize_t BytesToWrite = static_cast<ssize_t>(Buffer.size());
- const char *Bytes = Buffer.c_str();
+ const char *Bytes = Buffer.data();
while (BytesToWrite) {
ssize_t BytesWritten = write(WriteFD, Bytes, BytesToWrite);
diff --git a/clang/test/ModuleBuildDaemon/handshake.c b/clang/test/ModuleBuildDaemon/handshake.c
index ac9a5ebab87e4..5dd8f1b5a03a8 100644
--- a/clang/test/ModuleBuildDaemon/handshake.c
+++ b/clang/test/ModuleBuildDaemon/handshake.c
@@ -15,4 +15,3 @@ int main() {return 0;}
// CHECK: Completed successfull handshake with module build daemon
// RUN: if pgrep -f "cc1modbuildd mbd-handshake"; then pkill -f "cc1modbuildd mbd-handshake"; fi
-// RUN: rm -rf mbd-handshake %t
diff --git a/clang/test/ModuleBuildDaemon/launch.c b/clang/test/ModuleBuildDaemon/launch.c
index 878bdfa4052f5..d447cf9e26774 100644
--- a/clang/test/ModuleBuildDaemon/launch.c
+++ b/clang/test/ModuleBuildDaemon/launch.c
@@ -11,4 +11,3 @@
// CHECK: mbd created and binded to socket address at: mbd-launch/mbd.sock
// RUN: if pgrep -f "cc1modbuildd mbd-launch"; then pkill -f "cc1modbuildd mbd-launch"; fi
-// RUN: rm -rf mbd-launch %t
diff --git a/clang/tools/driver/cc1_main.cpp b/clang/tools/driver/cc1_main.cpp
index 25db6bf09082e..46bc310bcf335 100644
--- a/clang/tools/driver/cc1_main.cpp
+++ b/clang/tools/driver/cc1_main.cpp
@@ -289,12 +289,11 @@ int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
return 1;
}
-#if LLVM_ON_UNIX
// Handle module build daemon functionality if enabled
if (Clang->getFrontendOpts().ModuleBuildDaemon) {
-
- llvm::Error HandshakeErr =
- cc1modbuildd::handshakeModuleBuildDaemon(Clang->getInvocation(), Argv0);
+#if LLVM_ON_UNIX
+ llvm::Error HandshakeErr = cc1modbuildd::spawnModuleBuildDaemonAndHandshake(
+ Clang->getInvocation(), Argv0);
if (HandshakeErr) {
handleAllErrors(std::move(HandshakeErr), [&](ErrorInfoBase &EIB) {
errs() << EIB.message() << '\n';
@@ -303,8 +302,11 @@ int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
}
outs() << "Completed successfull handshake with module build daemon"
<< '\n';
- }
+#else
+ errs() << "-fmodule-build-daemon not supported by current platform" << '\n';
+ return 1;
#endif
+ }
// Execute the frontend actions.
{
diff --git a/clang/tools/driver/cc1modbuildd_main.cpp b/clang/tools/driver/cc1modbuildd_main.cpp
index bb8ace9dfde65..1f934de3d6e9a 100644
--- a/clang/tools/driver/cc1modbuildd_main.cpp
+++ b/clang/tools/driver/cc1modbuildd_main.cpp
@@ -48,26 +48,33 @@ static raw_fd_ostream &unbuff_outs() {
namespace {
+struct ClientConnection {
+ int ClientFD;
+ std::string Buffer;
+};
+
class ModuleBuildDaemonServer {
public:
- SmallString<128> BasePath;
- SmallString<128> SocketPath;
- SmallString<128> PidPath;
+ SmallString<256> SocketPath;
+ SmallString<256> STDERR;
+ SmallString<256> STDOUT;
- ModuleBuildDaemonServer(SmallString<128> Path, ArrayRef<const char *> Argv)
- : BasePath(Path), SocketPath(Path) {
+ ModuleBuildDaemonServer(StringRef Path, ArrayRef<const char *> Argv)
+ : SocketPath(Path), STDERR(Path), STDOUT(Path) {
llvm::sys::path::append(SocketPath, SOCKET_FILE_NAME);
+ llvm::sys::path::append(STDOUT, STDOUT_FILE_NAME);
+ llvm::sys::path::append(STDERR, STDERR_FILE_NAME);
}
- ~ModuleBuildDaemonServer() { shutdownDaemon(SIGTERM); }
+ ~ModuleBuildDaemonServer() { shutdownDaemon(); }
int forkDaemon();
- int launchDaemon();
+ int createDaemonSocket();
int listenForClients();
- static void handleClient(int Client);
+ static void handleClient(ClientConnection Connection);
- void shutdownDaemon(int signal) {
+ void shutdownDaemon() {
unlink(SocketPath.c_str());
shutdown(ListenSocketFD, SHUT_RD);
close(ListenSocketFD);
@@ -84,14 +91,14 @@ class ModuleBuildDaemonServer {
ModuleBuildDaemonServer *DaemonPtr = nullptr;
void handleSignal(int Signal) {
if (DaemonPtr != nullptr) {
- DaemonPtr->shutdownDaemon(Signal);
+ DaemonPtr->shutdownDaemon();
}
}
} // namespace
-static bool verbose = false;
-static void verbose_print(const llvm::Twine &message) {
- if (verbose) {
+static bool VerboseLog = false;
+static void printVerboseLog(const llvm::Twine &message) {
+ if (VerboseLog) {
unbuff_outs() << message << '\n';
}
}
@@ -114,12 +121,7 @@ int ModuleBuildDaemonServer::forkDaemon() {
close(STDOUT_FILENO);
close(STDERR_FILENO);
- SmallString<128> STDOUT = BasePath;
- llvm::sys::path::append(STDOUT, STDOUT_FILE_NAME);
freopen(STDOUT.c_str(), "a", stdout);
-
- SmallString<128> STDERR = BasePath;
- llvm::sys::path::append(STDERR, STDERR_FILE_NAME);
freopen(STDERR.c_str(), "a", stderr);
if (signal(SIGTERM, handleSignal) == SIG_ERR) {
@@ -139,7 +141,7 @@ int ModuleBuildDaemonServer::forkDaemon() {
}
// Creates unix socket for IPC with module build daemon
-int ModuleBuildDaemonServer::launchDaemon() {
+int ModuleBuildDaemonServer::createDaemonSocket() {
// new socket
if ((ListenSocketFD = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
@@ -166,7 +168,7 @@ int ModuleBuildDaemonServer::launchDaemon() {
std::perror("Socket bind error: ");
exit(EXIT_FAILURE);
}
- verbose_print("mbd created and binded to socket address at: " + SocketPath);
+ printVerboseLog("mbd created and binded to socket address at: " + SocketPath);
// set socket to accept incoming connection request
unsigned MaxBacklog = llvm::hardware_concurrency().compute_thread_count();
@@ -180,27 +182,43 @@ int ModuleBuildDaemonServer::launchDaemon() {
// Function submitted to thread pool with each client connection. Not
// responsible for closing client connections
-void ModuleBuildDaemonServer::handleClient(int Client) {
+// TODO: Setup something like ScopedHandle to auto close client on return
+void ModuleBuildDaemonServer::handleClient(ClientConnection Connection) {
// Read handshake from client
- Expected<HandshakeMsg> MaybeHandshakeMsg =
- readSocketMsgFromSocket<HandshakeMsg>(Client);
+ if (llvm::Error ReadErr =
+ readFromSocket(Connection.ClientFD, Connection.Buffer)) {
+ writeError(std::move(ReadErr), "Daemon failed to read buffer from socket");
+ close(Connection.ClientFD);
+ return;
+ }
+ // Wait for response from module build daemon
+ Expected<HandshakeMsg> MaybeHandshakeMsg =
+ getSocketMsgFromBuffer<HandshakeMsg>(Connection.Buffer);
if (!MaybeHandshakeMsg) {
writeError(MaybeHandshakeMsg.takeError(),
- "Failed to read handshake message from socket: ");
+ "Failed to convert buffer to HandshakeMsg: ");
+ close(Connection.ClientFD);
return;
}
- // Handle HANDSHAKE
+ // Have received HandshakeMsg - send HandshakeMsg response to clang invocation
HandshakeMsg Msg(ActionType::HANDSHAKE, StatusType::SUCCESS);
- llvm::Error WriteErr = writeSocketMsgToSocket(Msg, Client);
-
- if (WriteErr) {
+ if (llvm::Error WriteErr = writeSocketMsgToSocket(Msg, Connection.ClientFD)) {
writeError(std::move(WriteErr),
"Failed to notify client that handshake was received");
+ close(Connection.ClientFD);
return;
}
+
+ // Remove HandshakeMsg from Buffer in preperation for next read. Not currently
+ // necessary but will be once Daemon increases communication
+ size_t Position = Connection.Buffer.find("...\n");
+ if (Position != std::string::npos)
+ Connection.Buffer = Connection.Buffer.substr(Position + 4);
+
+ close(Connection.ClientFD);
return;
}
@@ -216,7 +234,10 @@ int ModuleBuildDaemonServer::listenForClients() {
continue;
}
- Pool.async(handleClient, Client);
+ ClientConnection Connection;
+ Connection.ClientFD = Client;
+
+ Pool.async(handleClient, Connection);
}
return 0;
}
@@ -247,7 +268,7 @@ int cc1modbuildd_main(ArrayRef<const char *> Argv) {
// Where to store log files and socket address
// TODO: Add check to confirm BasePath is directory
- SmallString<128> BasePath(Argv[0]);
+ std::string BasePath(Argv[0]);
llvm::sys::fs::create_directories(BasePath);
ModuleBuildDaemonServer Daemon(BasePath, Argv);
@@ -255,10 +276,10 @@ int cc1modbuildd_main(ArrayRef<const char *> Argv) {
DaemonPtr = &Daemon;
if (find(Argv, StringRef("-v")) != Argv.end())
- verbose = true;
+ VerboseLog = true;
Daemon.forkDaemon();
- Daemon.launchDaemon();
+ Daemon.createDaemonSocket();
Daemon.listenForClients();
return 0;
>From a2190a5210bb48eb1ce1d695563b8b88c0739624 Mon Sep 17 00:00:00 2001
From: cpsughrue <cpsughrue at gmail.com>
Date: Fri, 29 Sep 2023 14:43:34 -0400
Subject: [PATCH 3/9] Address feedback
- Add remark for module build daemon and update tests
- Change return value of spawnModuleBuildDaemonAndHandshake to void
- Add check to make sure provided socket address is an appropriate length
- Make ListenSocketFD atomic
---
.../clang/Basic/DiagnosticFrontendKinds.td | 5 ++
clang/include/clang/Basic/DiagnosticGroups.td | 1 +
.../clang/Tooling/ModuleBuildDaemon/Client.h | 14 +--
.../lib/Tooling/ModuleBuildDaemon/Client.cpp | 86 ++++++++++++++-----
clang/test/ModuleBuildDaemon/handshake.c | 26 +++++-
clang/test/ModuleBuildDaemon/launch.c | 2 +-
clang/tools/driver/cc1_main.cpp | 12 +--
clang/tools/driver/cc1modbuildd_main.cpp | 36 +++++---
8 files changed, 129 insertions(+), 53 deletions(-)
diff --git a/clang/include/clang/Basic/DiagnosticFrontendKinds.td b/clang/include/clang/Basic/DiagnosticFrontendKinds.td
index 715e0c0dc8fa8..2b175a6096cb1 100644
--- a/clang/include/clang/Basic/DiagnosticFrontendKinds.td
+++ b/clang/include/clang/Basic/DiagnosticFrontendKinds.td
@@ -261,6 +261,11 @@ def err_test_module_file_extension_version : Error<
"test module file extension '%0' has different version (%1.%2) than expected "
"(%3.%4)">;
+def warn_module_build_daemon : Warning<"%0">,
+ InGroup<ModuleBuildDaemon>;
+def remark_module_build_daemon : Remark<"%0">,
+ InGroup<ModuleBuildDaemon>;
+
def warn_eagerly_load_for_standard_cplusplus_modules : Warning<
"the form '-fmodule-file=<BMI-path>' is deprecated for standard C++ named modules;"
"consider to use '-fmodule-file=<module-name>=<BMI-path>' instead">,
diff --git a/clang/include/clang/Basic/DiagnosticGroups.td b/clang/include/clang/Basic/DiagnosticGroups.td
index ff028bbbf7426..949cce9a5e913 100644
--- a/clang/include/clang/Basic/DiagnosticGroups.td
+++ b/clang/include/clang/Basic/DiagnosticGroups.td
@@ -515,6 +515,7 @@ def MismatchedTags : DiagGroup<"mismatched-tags">;
def MissingFieldInitializers : DiagGroup<"missing-field-initializers">;
def ModuleLock : DiagGroup<"module-lock">;
def ModuleBuild : DiagGroup<"module-build">;
+def ModuleBuildDaemon : DiagGroup<"module-build-daemon">;
def ModuleImport : DiagGroup<"module-import">;
def ModuleConflict : DiagGroup<"module-conflict">;
def ModuleFileExtension : DiagGroup<"module-file-extension">;
diff --git a/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h b/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h
index eb4cac1aa8b16..de9db38a6612b 100644
--- a/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h
+++ b/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h
@@ -12,7 +12,6 @@
#include "clang/Frontend/CompilerInstance.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringRef.h"
-#include "llvm/Config/llvm-config.h"
#include "llvm/Support/YAMLParser.h"
#include "llvm/Support/YAMLTraits.h"
@@ -25,14 +24,17 @@ namespace cc1modbuildd {
// /tmp/clang-<BLAKE3HashOfClagnFullVersion>/
std::string getBasePath();
-llvm::Error attemptHandshake(int SocketFD);
+llvm::Error attemptHandshake(int SocketFD, DiagnosticsEngine &Diag);
-llvm::Error spawnModuleBuildDaemon(StringRef BasePath, const char *Argv0);
+llvm::Error spawnModuleBuildDaemon(StringRef BasePath, const char *Argv0,
+ DiagnosticsEngine &Diag);
-Expected<int> getModuleBuildDaemon(const char *Argv0, StringRef BasePath);
+Expected<int> getModuleBuildDaemon(const char *Argv0, StringRef BasePath,
+ DiagnosticsEngine &Diag);
-llvm::Error spawnModuleBuildDaemonAndHandshake(const CompilerInvocation &Clang,
- const char *Argv0);
+void spawnModuleBuildDaemonAndHandshake(const CompilerInvocation &Clang,
+ DiagnosticsEngine &Diag,
+ const char *Argv0);
} // namespace cc1modbuildd
diff --git a/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp b/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
index 766b78ee940d4..2516a8bcc2d8a 100644
--- a/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
+++ b/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
@@ -9,6 +9,7 @@
#include "clang/Tooling/ModuleBuildDaemon/Client.h"
#include "clang/Basic/Version.h"
#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Frontend/FrontendDiagnostic.h"
#include "clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h"
#include "clang/Tooling/ModuleBuildDaemon/SocketSupport.h"
#include "clang/Tooling/ModuleBuildDaemon/Utils.h"
@@ -52,26 +53,37 @@ std::string cc1modbuildd::getBasePath() {
return BasePath.c_str();
}
-llvm::Error cc1modbuildd::attemptHandshake(int SocketFD) {
+llvm::Error cc1modbuildd::attemptHandshake(int SocketFD,
+ DiagnosticsEngine &Diag) {
HandshakeMsg Request{ActionType::HANDSHAKE, StatusType::REQUEST};
std::string Buffer = getBufferFromSocketMsg(Request);
+ // Send HandshakeMsg to module build daemon
+ Diag.Report(diag::remark_module_build_daemon)
+ << "Trying to send HandshakeMsg to module build daemon";
if (llvm::Error Err = writeToSocket(Buffer, SocketFD))
return std::move(Err);
+ Diag.Report(diag::remark_module_build_daemon)
+ << "Successfully sent HandshakeMsg to module build daemon";
+ // Receive response from module build daemon
+ Diag.Report(diag::remark_module_build_daemon)
+ << "Waiting to receive module build daemon response";
Expected<HandshakeMsg> MaybeServerResponse =
readSocketMsgFromSocket<HandshakeMsg>(SocketFD);
if (!MaybeServerResponse)
return std::move(MaybeServerResponse.takeError());
-
HandshakeMsg ServerResponse = std::move(*MaybeServerResponse);
assert(ServerResponse.MsgAction == ActionType::HANDSHAKE &&
- "At this point response ActionType should only ever be HANDSHAKE");
+ "Response ActionType should only ever be HANDSHAKE");
- if (ServerResponse.MsgStatus == StatusType::SUCCESS)
+ if (ServerResponse.MsgStatus == StatusType::SUCCESS) {
+ Diag.Report(diag::remark_module_build_daemon)
+ << "Successfully received HandshakeMsg from module build daemon";
return llvm::Error::success();
+ }
return llvm::make_error<StringError>(
"Received failed handshake response from module build daemon",
@@ -79,35 +91,45 @@ llvm::Error cc1modbuildd::attemptHandshake(int SocketFD) {
}
llvm::Error cc1modbuildd::spawnModuleBuildDaemon(StringRef BasePath,
- const char *Argv0) {
+ const char *Argv0,
+ DiagnosticsEngine &Diag) {
std::string BasePathStr = BasePath.str();
const char *Args[] = {Argv0, "-cc1modbuildd", BasePathStr.c_str(), nullptr};
pid_t pid;
+ Diag.Report(diag::remark_module_build_daemon)
+ << "Trying to spawn module build daemon";
int EC = posix_spawn(&pid, Args[0],
/*file_actions*/ nullptr,
/*spawnattr*/ nullptr, const_cast<char **>(Args),
/*envp*/ nullptr);
if (EC)
return createStringError(std::error_code(EC, std::generic_category()),
- "failed to spawn module build daemon");
+ "Failed to spawn module build daemon");
+ Diag.Report(diag::remark_module_build_daemon)
+ << "Successfully spawned module build daemon";
return llvm::Error::success();
}
Expected<int> cc1modbuildd::getModuleBuildDaemon(const char *Argv0,
- StringRef BasePath) {
+ StringRef BasePath,
+ DiagnosticsEngine &Diag) {
SmallString<128> SocketPath = BasePath;
llvm::sys::path::append(SocketPath, SOCKET_FILE_NAME);
if (llvm::sys::fs::exists(SocketPath)) {
Expected<int> MaybeFD = connectToSocket(SocketPath);
- if (MaybeFD)
+ if (MaybeFD) {
+ Diag.Report(diag::remark_module_build_daemon)
+ << "Module build daemon already exists";
return std::move(*MaybeFD);
+ }
consumeError(MaybeFD.takeError());
}
- if (llvm::Error Err = cc1modbuildd::spawnModuleBuildDaemon(BasePath, Argv0))
+ if (llvm::Error Err =
+ cc1modbuildd::spawnModuleBuildDaemon(BasePath, Argv0, Diag))
return std::move(Err);
const unsigned int MICROSEC_IN_SEC = 1000000;
@@ -120,10 +142,15 @@ Expected<int> cc1modbuildd::getModuleBuildDaemon(const char *Argv0,
// Wait a bit then check to see if the module build daemon has initialized
usleep(WaitTime);
+ Diag.Report(diag::remark_module_build_daemon)
+ << "Trying to connect to recently spawned module build daemon";
if (llvm::sys::fs::exists(SocketPath)) {
Expected<int> MaybeFD = connectToSocket(SocketPath);
- if (MaybeFD)
+ if (MaybeFD) {
+ Diag.Report(diag::remark_module_build_daemon)
+ << "Succesfully connected to recently spawned module build daemon";
return std::move(*MaybeFD);
+ }
consumeError(MaybeFD.takeError());
}
@@ -137,31 +164,48 @@ Expected<int> cc1modbuildd::getModuleBuildDaemon(const char *Argv0,
"Module build daemon could not be spawned", inconvertibleErrorCode());
}
-llvm::Error cc1modbuildd::spawnModuleBuildDaemonAndHandshake(
- const CompilerInvocation &Clang, const char *Argv0) {
+void cc1modbuildd::spawnModuleBuildDaemonAndHandshake(
+ const CompilerInvocation &Clang, DiagnosticsEngine &Diag,
+ const char *Argv0) {
// The module build daemon stores all output files and its socket address
// under BasePath. Either set BasePath to a user provided option or create an
- // appropriate BasePath based on the hash of the clang version
+ // appropriate BasePath based on the hash of the full clang version
std::string BasePath;
if (!Clang.getFrontendOpts().ModuleBuildDaemonPath.empty())
BasePath = Clang.getFrontendOpts().ModuleBuildDaemonPath;
else
BasePath = cc1modbuildd::getBasePath();
+ // On most unix platforms a socket address cannot be over 108 characters
+ int MAX_ADDR = 108;
+ if (BasePath.length() >= MAX_ADDR - std::string(SOCKET_FILE_NAME).length()) {
+ Diag.Report(diag::warn_module_build_daemon)
+ << "Provided socket path" + BasePath +
+ " is too long. Socket path much be equal to or less then 100 "
+ "characters. Invocation will not spawn module build daemon.";
+ return;
+ }
+
// If module build daemon does not exist spawn module build daemon
Expected<int> MaybeDaemonFD =
- cc1modbuildd::getModuleBuildDaemon(Argv0, BasePath);
- if (!MaybeDaemonFD)
- return makeStringError(MaybeDaemonFD.takeError(),
- "Attempt to connect to daemon has failed: ");
+ cc1modbuildd::getModuleBuildDaemon(Argv0, BasePath, Diag);
+ if (!MaybeDaemonFD) {
+ Diag.Report(diag::warn_module_build_daemon) << getFullErrorMsg(
+ MaybeDaemonFD.takeError(), "Attempt to connect to daemon has failed: ");
+ return;
+ }
int DaemonFD = std::move(*MaybeDaemonFD);
- if (llvm::Error HandshakeErr = attemptHandshake(DaemonFD))
- return makeStringError(std::move(HandshakeErr),
- "Attempted hadshake with daemon has failed: ");
+ if (llvm::Error HandshakeErr = attemptHandshake(DaemonFD, Diag)) {
+ Diag.Report(diag::warn_module_build_daemon) << getFullErrorMsg(
+ std::move(HandshakeErr), "Attempted hadshake with daemon has failed: ");
+ return;
+ }
- return llvm::Error::success();
+ Diag.Report(diag::remark_module_build_daemon)
+ << "Completed successfull handshake with module build daemon";
+ return;
}
#endif // LLVM_ON_UNIX
diff --git a/clang/test/ModuleBuildDaemon/handshake.c b/clang/test/ModuleBuildDaemon/handshake.c
index 5dd8f1b5a03a8..497b47af039f4 100644
--- a/clang/test/ModuleBuildDaemon/handshake.c
+++ b/clang/test/ModuleBuildDaemon/handshake.c
@@ -1,4 +1,5 @@
-// Check that clang invocation can spawn and handshake with module build daemon
+// COM: Check that clang invocation can spawn and handshake with module build daemon
+// COM: Also check that clang invocation can handshake with existing module build daemon
// REQUIRES: !system-windows
@@ -9,9 +10,26 @@
//--- main.c
int main() {return 0;}
-// RUN: %clang -fmodule-build-daemon=mbd-handshake %t/main.c > output
-// RUN: cat output | FileCheck %s
+// RUN: %clang -fmodule-build-daemon=mbd-handshake -Rmodule-build-daemon %t/main.c &> %t/output-new
+// RUN: cat %t/output-new | FileCheck %s
+// RUN: %clang -fmodule-build-daemon=mbd-handshake -Rmodule-build-daemon %t/main.c &> %t/output-existing
+// RUN: cat %t/output-existing | FileCheck %s --check-prefix=CHECK-EXIST
-// CHECK: Completed successfull handshake with module build daemon
+// CHECK: remark: Trying to spawn module build daemon [-Rmodule-build-daemon]
+// CHECK: remark: Successfully spawned module build daemon [-Rmodule-build-daemon]
+// CHECK: remark: Trying to connect to recently spawned module build daemon [-Rmodule-build-daemon]
+// CHECK: remark: Succesfully connected to recently spawned module build daemon [-Rmodule-build-daemon]
+// CHECK: remark: Trying to send HandshakeMsg to module build daemon [-Rmodule-build-daemon]
+// CHECK: remark: Successfully sent HandshakeMsg to module build daemon [-Rmodule-build-daemon]
+// CHECK: remark: Waiting to receive module build daemon response [-Rmodule-build-daemon]
+// CHECK: remark: Successfully received HandshakeMsg from module build daemon [-Rmodule-build-daemon]
+// CHECK: remark: Completed successfull handshake with module build daemon [-Rmodule-build-daemon]
+
+// CHECK-EXIST: remark: Module build daemon already exists [-Rmodule-build-daemon]
+// CHECK-EXIST: remark: Trying to send HandshakeMsg to module build daemon [-Rmodule-build-daemon]
+// CHECK-EXIST: remark: Successfully sent HandshakeMsg to module build daemon [-Rmodule-build-daemon]
+// CHECK-EXIST: remark: Waiting to receive module build daemon response [-Rmodule-build-daemon]
+// CHECK-EXIST: remark: Successfully received HandshakeMsg from module build daemon [-Rmodule-build-daemon]
+// CHECK-EXIST: remark: Completed successfull handshake with module build daemon [-Rmodule-build-daemon]
// RUN: if pgrep -f "cc1modbuildd mbd-handshake"; then pkill -f "cc1modbuildd mbd-handshake"; fi
diff --git a/clang/test/ModuleBuildDaemon/launch.c b/clang/test/ModuleBuildDaemon/launch.c
index d447cf9e26774..cb4cdbc2b32af 100644
--- a/clang/test/ModuleBuildDaemon/launch.c
+++ b/clang/test/ModuleBuildDaemon/launch.c
@@ -1,4 +1,4 @@
-// Check that module build daemon can create unix socket
+// COM: Check that module build daemon can create unix socket
// REQUIRES: !system-windows
diff --git a/clang/tools/driver/cc1_main.cpp b/clang/tools/driver/cc1_main.cpp
index 46bc310bcf335..2bf4f95c34b46 100644
--- a/clang/tools/driver/cc1_main.cpp
+++ b/clang/tools/driver/cc1_main.cpp
@@ -292,16 +292,8 @@ int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
// Handle module build daemon functionality if enabled
if (Clang->getFrontendOpts().ModuleBuildDaemon) {
#if LLVM_ON_UNIX
- llvm::Error HandshakeErr = cc1modbuildd::spawnModuleBuildDaemonAndHandshake(
- Clang->getInvocation(), Argv0);
- if (HandshakeErr) {
- handleAllErrors(std::move(HandshakeErr), [&](ErrorInfoBase &EIB) {
- errs() << EIB.message() << '\n';
- });
- return 1;
- }
- outs() << "Completed successfull handshake with module build daemon"
- << '\n';
+ cc1modbuildd::spawnModuleBuildDaemonAndHandshake(
+ Clang->getInvocation(), Clang->getDiagnostics(), Argv0);
#else
errs() << "-fmodule-build-daemon not supported by current platform" << '\n';
return 1;
diff --git a/clang/tools/driver/cc1modbuildd_main.cpp b/clang/tools/driver/cc1modbuildd_main.cpp
index 1f934de3d6e9a..75d2771c74774 100644
--- a/clang/tools/driver/cc1modbuildd_main.cpp
+++ b/clang/tools/driver/cc1modbuildd_main.cpp
@@ -75,16 +75,17 @@ class ModuleBuildDaemonServer {
static void handleClient(ClientConnection Connection);
void shutdownDaemon() {
+ int SocketFD = ListenSocketFD.load();
+
unlink(SocketPath.c_str());
- shutdown(ListenSocketFD, SHUT_RD);
- close(ListenSocketFD);
+ shutdown(SocketFD, SHUT_RD);
+ close(SocketFD);
exit(EXIT_SUCCESS);
}
private:
- // Initializes and returns DiagnosticsEngine
pid_t Pid = -1;
- int ListenSocketFD = -1;
+ std::atomic<int> ListenSocketFD = -1;
};
// Required to handle SIGTERM by calling Shutdown
@@ -143,8 +144,10 @@ int ModuleBuildDaemonServer::forkDaemon() {
// Creates unix socket for IPC with module build daemon
int ModuleBuildDaemonServer::createDaemonSocket() {
- // new socket
- if ((ListenSocketFD = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
+ // New socket
+ int SocketFD = socket(AF_UNIX, SOCK_STREAM, 0);
+
+ if (SocketFD == -1) {
std::perror("Socket create error: ");
exit(EXIT_FAILURE);
}
@@ -155,14 +158,14 @@ int ModuleBuildDaemonServer::createDaemonSocket() {
strncpy(addr.sun_path, SocketPath.c_str(), sizeof(addr.sun_path) - 1);
// bind to local address
- if (bind(ListenSocketFD, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
+ if (bind(SocketFD, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
// If the socket address is already in use, exit because another module
// build daemon has successfully launched. When translation units are
// compiled in parallel, until the socket file is created, all clang
// invocations will spawn a module build daemon.
if (errno == EADDRINUSE) {
- close(ListenSocketFD);
+ close(SocketFD);
exit(EXIT_SUCCESS);
}
std::perror("Socket bind error: ");
@@ -172,11 +175,12 @@ int ModuleBuildDaemonServer::createDaemonSocket() {
// set socket to accept incoming connection request
unsigned MaxBacklog = llvm::hardware_concurrency().compute_thread_count();
- if (listen(ListenSocketFD, MaxBacklog) == -1) {
+ if (listen(SocketFD, MaxBacklog) == -1) {
std::perror("Socket listen error: ");
exit(EXIT_FAILURE);
}
+ ListenSocketFD.store(SocketFD);
return 0;
}
@@ -229,7 +233,7 @@ int ModuleBuildDaemonServer::listenForClients() {
while (true) {
- if ((Client = accept(ListenSocketFD, NULL, NULL)) == -1) {
+ if ((Client = accept(ListenSocketFD.load(), NULL, NULL)) == -1) {
std::perror("Socket accept error: ");
continue;
}
@@ -259,7 +263,7 @@ int ModuleBuildDaemonServer::listenForClients() {
int cc1modbuildd_main(ArrayRef<const char *> Argv) {
if (Argv.size() < 1) {
- outs() << "spawning a module build daemon requies a command line format of "
+ errs() << "spawning a module build daemon requies a command line format of "
"`clang -cc1modbuildd <path>`. <path> defines where the module "
"build daemon will create mbd.out, mbd.err, mbd.sock"
<< '\n';
@@ -269,6 +273,16 @@ int cc1modbuildd_main(ArrayRef<const char *> Argv) {
// Where to store log files and socket address
// TODO: Add check to confirm BasePath is directory
std::string BasePath(Argv[0]);
+
+ // On most unix platforms a socket address cannot be over 108 characters
+ int MAX_ADDR = 108;
+ if (BasePath.length() >= MAX_ADDR - std::string(SOCKET_FILE_NAME).length()) {
+ errs() << "Provided socket path" + BasePath +
+ " is too long. Socket path much be equal to or less then 100 "
+ "characters. Module build daemon will not be spawned.";
+ return 1;
+ }
+
llvm::sys::fs::create_directories(BasePath);
ModuleBuildDaemonServer Daemon(BasePath, Argv);
>From 522ab54f50b59bd278b94d81d4b34028511cd05e Mon Sep 17 00:00:00 2001
From: cpsughrue <cpsughrue at gmail.com>
Date: Sat, 30 Sep 2023 14:24:47 -0400
Subject: [PATCH 4/9] Updated test Frontend/warning-options.cpp
Adding -Wmodule-build-daemon prevents the compiler from suggesting
-Wmodule-conflict as an alternative to -Wmodule-build
---
clang/test/Frontend/warning-options.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/clang/test/Frontend/warning-options.cpp b/clang/test/Frontend/warning-options.cpp
index 444733c8b7f36..42a7109b8d48c 100644
--- a/clang/test/Frontend/warning-options.cpp
+++ b/clang/test/Frontend/warning-options.cpp
@@ -3,6 +3,6 @@
// CHECK: unknown warning option '-Wmonkey'
// CHECK: unknown warning option '-Wno-monkey'
// CHECK: unknown warning option '-Wno-unused-command-line-arguments'; did you mean '-Wno-unused-command-line-argument'?
-// CHECK: unknown warning option '-Wmodule-build'; did you mean '-Wmodule-conflict'?
+// CHECK: unknown warning option '-Wmodule-build'
// CHECK-NEXT: unknown -Werror warning specifier: '-Werror-vla'
// CHECK: unknown remark option '-Rmodule-built'; did you mean '-Rmodule-build'?
>From e41294683d7bfadd735b600187c7e2f4992d14c1 Mon Sep 17 00:00:00 2001
From: cpsughrue <cpsughrue at gmail.com>
Date: Wed, 25 Oct 2023 13:56:27 -0400
Subject: [PATCH 5/9] Address feedback
- In readFromSocket change assign to append
- Change token used to find end of YAML document
- Remove condition from writeToSocket that will never be met
- Change exit to _Exit in signal handle
- Remove unessary use of remark and update test
- Convert warning to error for when socket address is too long to fit in unix_path.sun_addr
- Improve diagnositc options for module build daemon
---
.../clang/Basic/DiagnosticFrontendKinds.td | 20 ++++++++-
.../clang/Tooling/ModuleBuildDaemon/Client.h | 2 +-
.../ModuleBuildDaemon/SocketMsgSupport.h | 1 +
.../lib/Tooling/ModuleBuildDaemon/Client.cpp | 42 ++++++-------------
.../ModuleBuildDaemon/SocketSupport.cpp | 10 ++---
clang/test/ModuleBuildDaemon/handshake.c | 22 +++-------
clang/tools/driver/cc1modbuildd_main.cpp | 5 ++-
7 files changed, 45 insertions(+), 57 deletions(-)
diff --git a/clang/include/clang/Basic/DiagnosticFrontendKinds.td b/clang/include/clang/Basic/DiagnosticFrontendKinds.td
index 2b175a6096cb1..3b12d6b9543a2 100644
--- a/clang/include/clang/Basic/DiagnosticFrontendKinds.td
+++ b/clang/include/clang/Basic/DiagnosticFrontendKinds.td
@@ -261,9 +261,25 @@ def err_test_module_file_extension_version : Error<
"test module file extension '%0' has different version (%1.%2) than expected "
"(%3.%4)">;
-def warn_module_build_daemon : Warning<"%0">,
+def err_unix_socket_addr_length :
+ Error<"Socket address %0 is %1 characters long which is larger then the max length of %2">,
+ DefaultFatal;
+
+// Module Build Daemon
+def err_mbd_handshake :
+ Error<"Attempt to hadshake with daemon has failed: %0">,
+ DefaultFatal;
+def err_mbd_connect :
+ Error<"Attempt to connect to daemon has failed: %0">,
+ DefaultFatal;
+def remark_mbd_spawn :
+ Remark<"Successfully spawned module build daemon">,
+ InGroup<ModuleBuildDaemon>;
+def remark_mbd_connection :
+ Remark<"Successfully connected to module build daemon at %0">,
InGroup<ModuleBuildDaemon>;
-def remark_module_build_daemon : Remark<"%0">,
+def remark_mbd_handshake :
+ Remark<"Successfully completed handshake with module build daemon">,
InGroup<ModuleBuildDaemon>;
def warn_eagerly_load_for_standard_cplusplus_modules : Warning<
diff --git a/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h b/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h
index de9db38a6612b..648e9bf440b95 100644
--- a/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h
+++ b/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h
@@ -21,7 +21,7 @@ using namespace llvm;
namespace cc1modbuildd {
// Returns where to store log files and socket address. Of the format
-// /tmp/clang-<BLAKE3HashOfClagnFullVersion>/
+// /tmp/clang-<BLAKE3HashOfClangFullVersion>/
std::string getBasePath();
llvm::Error attemptHandshake(int SocketFD, DiagnosticsEngine &Diag);
diff --git a/clang/include/clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h b/clang/include/clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h
index 0c2994e048925..280a528131412 100644
--- a/clang/include/clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h
+++ b/clang/include/clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h
@@ -55,6 +55,7 @@ template <typename T> Expected<T> getSocketMsgFromBuffer(StringRef Buffer) {
llvm::yaml::Input YamlIn(Buffer);
YamlIn >> ClientRequest;
+ // YamlIn.error() dumps an error message if there is one
if (YamlIn.error()) {
std::string Msg = "Syntax or semantic error during YAML parsing";
return llvm::make_error<StringError>(Msg, inconvertibleErrorCode());
diff --git a/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp b/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
index 2516a8bcc2d8a..b2a444dd362f5 100644
--- a/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
+++ b/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
@@ -60,16 +60,10 @@ llvm::Error cc1modbuildd::attemptHandshake(int SocketFD,
std::string Buffer = getBufferFromSocketMsg(Request);
// Send HandshakeMsg to module build daemon
- Diag.Report(diag::remark_module_build_daemon)
- << "Trying to send HandshakeMsg to module build daemon";
if (llvm::Error Err = writeToSocket(Buffer, SocketFD))
return std::move(Err);
- Diag.Report(diag::remark_module_build_daemon)
- << "Successfully sent HandshakeMsg to module build daemon";
// Receive response from module build daemon
- Diag.Report(diag::remark_module_build_daemon)
- << "Waiting to receive module build daemon response";
Expected<HandshakeMsg> MaybeServerResponse =
readSocketMsgFromSocket<HandshakeMsg>(SocketFD);
if (!MaybeServerResponse)
@@ -80,8 +74,6 @@ llvm::Error cc1modbuildd::attemptHandshake(int SocketFD,
"Response ActionType should only ever be HANDSHAKE");
if (ServerResponse.MsgStatus == StatusType::SUCCESS) {
- Diag.Report(diag::remark_module_build_daemon)
- << "Successfully received HandshakeMsg from module build daemon";
return llvm::Error::success();
}
@@ -96,8 +88,8 @@ llvm::Error cc1modbuildd::spawnModuleBuildDaemon(StringRef BasePath,
std::string BasePathStr = BasePath.str();
const char *Args[] = {Argv0, "-cc1modbuildd", BasePathStr.c_str(), nullptr};
pid_t pid;
- Diag.Report(diag::remark_module_build_daemon)
- << "Trying to spawn module build daemon";
+
+ // TODO: Swich to llvm::sys::ExecuteNoWait
int EC = posix_spawn(&pid, Args[0],
/*file_actions*/ nullptr,
/*spawnattr*/ nullptr, const_cast<char **>(Args),
@@ -106,8 +98,7 @@ llvm::Error cc1modbuildd::spawnModuleBuildDaemon(StringRef BasePath,
return createStringError(std::error_code(EC, std::generic_category()),
"Failed to spawn module build daemon");
- Diag.Report(diag::remark_module_build_daemon)
- << "Successfully spawned module build daemon";
+ Diag.Report(diag::remark_mbd_spawn);
return llvm::Error::success();
}
@@ -121,8 +112,6 @@ Expected<int> cc1modbuildd::getModuleBuildDaemon(const char *Argv0,
if (llvm::sys::fs::exists(SocketPath)) {
Expected<int> MaybeFD = connectToSocket(SocketPath);
if (MaybeFD) {
- Diag.Report(diag::remark_module_build_daemon)
- << "Module build daemon already exists";
return std::move(*MaybeFD);
}
consumeError(MaybeFD.takeError());
@@ -142,13 +131,10 @@ Expected<int> cc1modbuildd::getModuleBuildDaemon(const char *Argv0,
// Wait a bit then check to see if the module build daemon has initialized
usleep(WaitTime);
- Diag.Report(diag::remark_module_build_daemon)
- << "Trying to connect to recently spawned module build daemon";
if (llvm::sys::fs::exists(SocketPath)) {
Expected<int> MaybeFD = connectToSocket(SocketPath);
if (MaybeFD) {
- Diag.Report(diag::remark_module_build_daemon)
- << "Succesfully connected to recently spawned module build daemon";
+ Diag.Report(diag::remark_mbd_connection) << SocketPath;
return std::move(*MaybeFD);
}
consumeError(MaybeFD.takeError());
@@ -177,13 +163,14 @@ void cc1modbuildd::spawnModuleBuildDaemonAndHandshake(
else
BasePath = cc1modbuildd::getBasePath();
- // On most unix platforms a socket address cannot be over 108 characters
+ // TODO: Max length may vary across different platforms. Incoming llvm/Support
+ // for sockets will help make this portable. On most unix platforms a socket
+ // address cannot be over 108 characters. The socket file, mbd.sock, takes up
+ // 8 characters leaving 100 characters left for the user/system
int MAX_ADDR = 108;
if (BasePath.length() >= MAX_ADDR - std::string(SOCKET_FILE_NAME).length()) {
- Diag.Report(diag::warn_module_build_daemon)
- << "Provided socket path" + BasePath +
- " is too long. Socket path much be equal to or less then 100 "
- "characters. Invocation will not spawn module build daemon.";
+ Diag.Report(diag::err_unix_socket_addr_length)
+ << BasePath << BasePath.length() << 100;
return;
}
@@ -191,20 +178,17 @@ void cc1modbuildd::spawnModuleBuildDaemonAndHandshake(
Expected<int> MaybeDaemonFD =
cc1modbuildd::getModuleBuildDaemon(Argv0, BasePath, Diag);
if (!MaybeDaemonFD) {
- Diag.Report(diag::warn_module_build_daemon) << getFullErrorMsg(
- MaybeDaemonFD.takeError(), "Attempt to connect to daemon has failed: ");
+ Diag.Report(diag::err_mbd_connect) << MaybeDaemonFD.takeError();
return;
}
int DaemonFD = std::move(*MaybeDaemonFD);
if (llvm::Error HandshakeErr = attemptHandshake(DaemonFD, Diag)) {
- Diag.Report(diag::warn_module_build_daemon) << getFullErrorMsg(
- std::move(HandshakeErr), "Attempted hadshake with daemon has failed: ");
+ Diag.Report(diag::err_mbd_handshake) << std::move(HandshakeErr);
return;
}
- Diag.Report(diag::remark_module_build_daemon)
- << "Completed successfull handshake with module build daemon";
+ Diag.Report(diag::remark_mbd_handshake);
return;
}
diff --git a/clang/lib/Tooling/ModuleBuildDaemon/SocketSupport.cpp b/clang/lib/Tooling/ModuleBuildDaemon/SocketSupport.cpp
index ae1e40a9a4437..a2997aa11756b 100644
--- a/clang/lib/Tooling/ModuleBuildDaemon/SocketSupport.cpp
+++ b/clang/lib/Tooling/ModuleBuildDaemon/SocketSupport.cpp
@@ -69,9 +69,9 @@ llvm::Error cc1modbuildd::readFromSocket(int FD, std::string &BufferConsumer) {
while ((n = read(FD, Buffer, MAX_BUFFER)) > 0) {
- BufferConsumer.assign(Buffer, n);
- // Read until ...\n encountered (last line of YAML document)
- if (BufferConsumer.find("...\n") != std::string::npos)
+ BufferConsumer.append(Buffer, n);
+ // Read until \n... encountered (last line of YAML document)
+ if (BufferConsumer.find("\n...") != std::string::npos)
break;
}
@@ -96,10 +96,6 @@ llvm::Error cc1modbuildd::writeToSocket(StringRef Buffer, int WriteFD) {
return llvm::make_error<StringError>(Msg, inconvertibleErrorCode());
}
- if (!BytesWritten || BytesWritten > BytesToWrite)
- return llvm::errorCodeToError(
- std::error_code(EIO, std::generic_category()));
-
BytesToWrite -= BytesWritten;
Bytes += BytesWritten;
}
diff --git a/clang/test/ModuleBuildDaemon/handshake.c b/clang/test/ModuleBuildDaemon/handshake.c
index 497b47af039f4..288e99f51bea4 100644
--- a/clang/test/ModuleBuildDaemon/handshake.c
+++ b/clang/test/ModuleBuildDaemon/handshake.c
@@ -1,6 +1,3 @@
-// COM: Check that clang invocation can spawn and handshake with module build daemon
-// COM: Also check that clang invocation can handshake with existing module build daemon
-
// REQUIRES: !system-windows
// RUN: if pgrep -f "cc1modbuildd mbd-handshake"; then pkill -f "cc1modbuildd mbd-handshake"; fi
@@ -15,21 +12,12 @@ int main() {return 0;}
// RUN: %clang -fmodule-build-daemon=mbd-handshake -Rmodule-build-daemon %t/main.c &> %t/output-existing
// RUN: cat %t/output-existing | FileCheck %s --check-prefix=CHECK-EXIST
-// CHECK: remark: Trying to spawn module build daemon [-Rmodule-build-daemon]
+// COM: Check that clang invocation can spawn and handshake with module build daemon
// CHECK: remark: Successfully spawned module build daemon [-Rmodule-build-daemon]
-// CHECK: remark: Trying to connect to recently spawned module build daemon [-Rmodule-build-daemon]
-// CHECK: remark: Succesfully connected to recently spawned module build daemon [-Rmodule-build-daemon]
-// CHECK: remark: Trying to send HandshakeMsg to module build daemon [-Rmodule-build-daemon]
-// CHECK: remark: Successfully sent HandshakeMsg to module build daemon [-Rmodule-build-daemon]
-// CHECK: remark: Waiting to receive module build daemon response [-Rmodule-build-daemon]
-// CHECK: remark: Successfully received HandshakeMsg from module build daemon [-Rmodule-build-daemon]
-// CHECK: remark: Completed successfull handshake with module build daemon [-Rmodule-build-daemon]
+// CHECK: remark: Successfully connected to module build daemon at mbd-handshake/mbd.sock [-Rmodule-build-daemon]
+// CHECK: remark: Successfully completed handshake with module build daemon [-Rmodule-build-daemon]
-// CHECK-EXIST: remark: Module build daemon already exists [-Rmodule-build-daemon]
-// CHECK-EXIST: remark: Trying to send HandshakeMsg to module build daemon [-Rmodule-build-daemon]
-// CHECK-EXIST: remark: Successfully sent HandshakeMsg to module build daemon [-Rmodule-build-daemon]
-// CHECK-EXIST: remark: Waiting to receive module build daemon response [-Rmodule-build-daemon]
-// CHECK-EXIST: remark: Successfully received HandshakeMsg from module build daemon [-Rmodule-build-daemon]
-// CHECK-EXIST: remark: Completed successfull handshake with module build daemon [-Rmodule-build-daemon]
+// COM: Check that clang invocation can handshake with existing module build daemon
+// CHECK-EXIST: remark: Successfully completed handshake with module build daemon [-Rmodule-build-daemon]
// RUN: if pgrep -f "cc1modbuildd mbd-handshake"; then pkill -f "cc1modbuildd mbd-handshake"; fi
diff --git a/clang/tools/driver/cc1modbuildd_main.cpp b/clang/tools/driver/cc1modbuildd_main.cpp
index 75d2771c74774..a20016b89961d 100644
--- a/clang/tools/driver/cc1modbuildd_main.cpp
+++ b/clang/tools/driver/cc1modbuildd_main.cpp
@@ -74,13 +74,16 @@ class ModuleBuildDaemonServer {
static void handleClient(ClientConnection Connection);
+ // TODO: modify so when shutdownDaemon is called the daemon stops accepting
+ // new client connections and waits for all existing client connections to
+ // terminate before exiting
void shutdownDaemon() {
int SocketFD = ListenSocketFD.load();
unlink(SocketPath.c_str());
shutdown(SocketFD, SHUT_RD);
close(SocketFD);
- exit(EXIT_SUCCESS);
+ _Exit(EXIT_SUCCESS);
}
private:
>From 0b57e5abbe4cd3965f79dfa51f0b1fcb91bcc117 Mon Sep 17 00:00:00 2001
From: cpsughrue <cpsughrue at gmail.com>
Date: Tue, 31 Oct 2023 21:47:00 -0400
Subject: [PATCH 6/9] Address Feedback
- Improve regression tests so that daemon is shutdown even when clang fails
- Allow <path> in [-cc1modbuildd <path>] to be optional
- Fix namespace issues
- Clean up error handling
- Replace client side posix_spawn with ExecuteNoWait
- Rebase fixes
---
.../clang/Basic/DiagnosticFrontendKinds.td | 10 +--
.../clang/Tooling/ModuleBuildDaemon/Client.h | 26 +++----
.../ModuleBuildDaemon/SocketMsgSupport.h | 46 ++++++------
.../Tooling/ModuleBuildDaemon/SocketSupport.h | 13 ++--
.../clang/Tooling/ModuleBuildDaemon/Utils.h | 8 +-
.../lib/Tooling/ModuleBuildDaemon/Client.cpp | 75 +++++++------------
.../ModuleBuildDaemon/SocketSupport.cpp | 22 ++++--
clang/lib/Tooling/ModuleBuildDaemon/Utils.cpp | 37 +++++++--
clang/test/ModuleBuildDaemon/handshake.c | 13 ++--
clang/test/ModuleBuildDaemon/launch.c | 4 +-
clang/tools/driver/cc1_main.cpp | 5 +-
clang/tools/driver/cc1modbuildd_main.cpp | 53 +++++++------
12 files changed, 161 insertions(+), 151 deletions(-)
diff --git a/clang/include/clang/Basic/DiagnosticFrontendKinds.td b/clang/include/clang/Basic/DiagnosticFrontendKinds.td
index 3b12d6b9543a2..d1623494d160b 100644
--- a/clang/include/clang/Basic/DiagnosticFrontendKinds.td
+++ b/clang/include/clang/Basic/DiagnosticFrontendKinds.td
@@ -261,24 +261,24 @@ def err_test_module_file_extension_version : Error<
"test module file extension '%0' has different version (%1.%2) than expected "
"(%3.%4)">;
-def err_unix_socket_addr_length :
+def err_unix_socket_addr_length :
Error<"Socket address %0 is %1 characters long which is larger then the max length of %2">,
DefaultFatal;
// Module Build Daemon
-def err_mbd_handshake :
+def err_mbd_handshake :
Error<"Attempt to hadshake with daemon has failed: %0">,
DefaultFatal;
-def err_mbd_connect :
+def err_mbd_connect :
Error<"Attempt to connect to daemon has failed: %0">,
DefaultFatal;
-def remark_mbd_spawn :
+def remark_mbd_spawn :
Remark<"Successfully spawned module build daemon">,
InGroup<ModuleBuildDaemon>;
def remark_mbd_connection :
Remark<"Successfully connected to module build daemon at %0">,
InGroup<ModuleBuildDaemon>;
-def remark_mbd_handshake :
+def remark_mbd_handshake :
Remark<"Successfully completed handshake with module build daemon">,
InGroup<ModuleBuildDaemon>;
diff --git a/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h b/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h
index 648e9bf440b95..045fc7ffb4f25 100644
--- a/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h
+++ b/clang/include/clang/Tooling/ModuleBuildDaemon/Client.h
@@ -15,27 +15,21 @@
#include "llvm/Support/YAMLParser.h"
#include "llvm/Support/YAMLTraits.h"
-using namespace clang;
-using namespace llvm;
+namespace clang::tooling::cc1modbuildd {
-namespace cc1modbuildd {
+llvm::Error attemptHandshake(int SocketFD, clang::DiagnosticsEngine &Diag);
-// Returns where to store log files and socket address. Of the format
-// /tmp/clang-<BLAKE3HashOfClangFullVersion>/
-std::string getBasePath();
+llvm::Error spawnModuleBuildDaemon(llvm::StringRef BasePath, const char *Argv0,
+ clang::DiagnosticsEngine &Diag);
-llvm::Error attemptHandshake(int SocketFD, DiagnosticsEngine &Diag);
+llvm::Expected<int> getModuleBuildDaemon(const char *Argv0,
+ llvm::StringRef BasePath,
+ clang::DiagnosticsEngine &Diag);
-llvm::Error spawnModuleBuildDaemon(StringRef BasePath, const char *Argv0,
- DiagnosticsEngine &Diag);
-
-Expected<int> getModuleBuildDaemon(const char *Argv0, StringRef BasePath,
- DiagnosticsEngine &Diag);
-
-void spawnModuleBuildDaemonAndHandshake(const CompilerInvocation &Clang,
- DiagnosticsEngine &Diag,
+void spawnModuleBuildDaemonAndHandshake(const clang::CompilerInvocation &Clang,
+ clang::DiagnosticsEngine &Diag,
const char *Argv0);
-} // namespace cc1modbuildd
+} // namespace clang::tooling::cc1modbuildd
#endif // LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_CLIENT_H
diff --git a/clang/include/clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h b/clang/include/clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h
index 280a528131412..b8d6717b02cb5 100644
--- a/clang/include/clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h
+++ b/clang/include/clang/Tooling/ModuleBuildDaemon/SocketMsgSupport.h
@@ -12,10 +12,7 @@
#include "clang/Tooling/ModuleBuildDaemon/Client.h"
#include "clang/Tooling/ModuleBuildDaemon/SocketSupport.h"
-using namespace clang;
-using namespace llvm;
-
-namespace cc1modbuildd {
+namespace clang::tooling::cc1modbuildd {
enum class ActionType { HANDSHAKE };
enum class StatusType { REQUEST, SUCCESS, FAILURE };
@@ -47,7 +44,8 @@ template <typename T> std::string getBufferFromSocketMsg(T Msg) {
return Buffer;
}
-template <typename T> Expected<T> getSocketMsgFromBuffer(StringRef Buffer) {
+template <typename T>
+llvm::Expected<T> getSocketMsgFromBuffer(llvm::StringRef Buffer) {
static_assert(std::is_base_of<cc1modbuildd::BaseMsg, T>::value,
"T must inherit from cc1modbuildd::BaseMsg");
@@ -58,13 +56,14 @@ template <typename T> Expected<T> getSocketMsgFromBuffer(StringRef Buffer) {
// YamlIn.error() dumps an error message if there is one
if (YamlIn.error()) {
std::string Msg = "Syntax or semantic error during YAML parsing";
- return llvm::make_error<StringError>(Msg, inconvertibleErrorCode());
+ return llvm::make_error<llvm::StringError>(Msg,
+ llvm::inconvertibleErrorCode());
}
return ClientRequest;
}
-template <typename T> Expected<T> readSocketMsgFromSocket(int FD) {
+template <typename T> llvm::Expected<T> readSocketMsgFromSocket(int FD) {
static_assert(std::is_base_of<cc1modbuildd::BaseMsg, T>::value,
"T must inherit from cc1modbuildd::BaseMsg");
@@ -73,7 +72,7 @@ template <typename T> Expected<T> readSocketMsgFromSocket(int FD) {
return std::move(ReadErr);
// Wait for response from module build daemon
- Expected<T> MaybeResponse =
+ llvm::Expected<T> MaybeResponse =
getSocketMsgFromBuffer<T>(std::move(BufferConsumer).c_str());
if (!MaybeResponse)
return std::move(MaybeResponse.takeError());
@@ -92,11 +91,12 @@ template <typename T> llvm::Error writeSocketMsgToSocket(T Msg, int FD) {
}
template <typename T>
-Expected<int> connectAndWriteSocketMsgToSocket(T Msg, StringRef SocketPath) {
+llvm::Expected<int>
+connectAndWriteSocketMsgToSocket(T Msg, llvm::StringRef SocketPath) {
static_assert(std::is_base_of<cc1modbuildd::BaseMsg, T>::value,
"T must inherit from cc1modbuildd::BaseMsg");
- Expected<int> MaybeFD = connectToSocket(SocketPath);
+ llvm::Expected<int> MaybeFD = connectToSocket(SocketPath);
if (!MaybeFD)
return std::move(MaybeFD.takeError());
int FD = std::move(*MaybeFD);
@@ -107,26 +107,26 @@ Expected<int> connectAndWriteSocketMsgToSocket(T Msg, StringRef SocketPath) {
return FD;
}
-} // namespace cc1modbuildd
+} // namespace clang::tooling::cc1modbuildd
+
+namespace cc1mod = clang::tooling::cc1modbuildd;
-template <>
-struct llvm::yaml::ScalarEnumerationTraits<cc1modbuildd::StatusType> {
- static void enumeration(IO &Io, cc1modbuildd::StatusType &Value) {
- Io.enumCase(Value, "REQUEST", cc1modbuildd::StatusType::REQUEST);
- Io.enumCase(Value, "SUCCESS", cc1modbuildd::StatusType::SUCCESS);
- Io.enumCase(Value, "FAILURE", cc1modbuildd::StatusType::FAILURE);
+template <> struct llvm::yaml::ScalarEnumerationTraits<cc1mod::StatusType> {
+ static void enumeration(IO &Io, cc1mod::StatusType &Value) {
+ Io.enumCase(Value, "REQUEST", cc1mod::StatusType::REQUEST);
+ Io.enumCase(Value, "SUCCESS", cc1mod::StatusType::SUCCESS);
+ Io.enumCase(Value, "FAILURE", cc1mod::StatusType::FAILURE);
}
};
-template <>
-struct llvm::yaml::ScalarEnumerationTraits<cc1modbuildd::ActionType> {
- static void enumeration(IO &Io, cc1modbuildd::ActionType &Value) {
- Io.enumCase(Value, "HANDSHAKE", cc1modbuildd::ActionType::HANDSHAKE);
+template <> struct llvm::yaml::ScalarEnumerationTraits<cc1mod::ActionType> {
+ static void enumeration(IO &Io, cc1mod::ActionType &Value) {
+ Io.enumCase(Value, "HANDSHAKE", cc1mod::ActionType::HANDSHAKE);
}
};
-template <> struct llvm::yaml::MappingTraits<cc1modbuildd::HandshakeMsg> {
- static void mapping(IO &Io, cc1modbuildd::HandshakeMsg &Info) {
+template <> struct llvm::yaml::MappingTraits<cc1mod::HandshakeMsg> {
+ static void mapping(IO &Io, cc1mod::HandshakeMsg &Info) {
Io.mapRequired("Action", Info.MsgAction);
Io.mapRequired("Status", Info.MsgStatus);
}
diff --git a/clang/include/clang/Tooling/ModuleBuildDaemon/SocketSupport.h b/clang/include/clang/Tooling/ModuleBuildDaemon/SocketSupport.h
index 712f65e695086..55a09c142a654 100644
--- a/clang/include/clang/Tooling/ModuleBuildDaemon/SocketSupport.h
+++ b/clang/include/clang/Tooling/ModuleBuildDaemon/SocketSupport.h
@@ -15,16 +15,13 @@
#include "llvm/Support/YAMLParser.h"
#include "llvm/Support/YAMLTraits.h"
-using namespace clang;
-using namespace llvm;
+namespace clang::tooling::cc1modbuildd {
-namespace cc1modbuildd {
-
-Expected<int> createSocket();
-Expected<int> connectToSocket(StringRef SocketPath);
+llvm::Expected<int> createSocket();
+llvm::Expected<int> connectToSocket(llvm::StringRef SocketPath);
llvm::Error readFromSocket(int FD, std::string &BufferConsumer);
-llvm::Error writeToSocket(StringRef Buffer, int WriteFD);
+llvm::Error writeToSocket(llvm::StringRef Buffer, int WriteFD);
-} // namespace cc1modbuildd
+} // namespace clang::tooling::cc1modbuildd
#endif // LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_SOCKETSUPPORT_H
diff --git a/clang/include/clang/Tooling/ModuleBuildDaemon/Utils.h b/clang/include/clang/Tooling/ModuleBuildDaemon/Utils.h
index 63ac2bf54c6ba..4dfde73a1143f 100644
--- a/clang/include/clang/Tooling/ModuleBuildDaemon/Utils.h
+++ b/clang/include/clang/Tooling/ModuleBuildDaemon/Utils.h
@@ -22,12 +22,16 @@
#define STDOUT_FILE_NAME "mbd.out"
#define STDERR_FILE_NAME "mbd.err"
-namespace cc1modbuildd {
+namespace clang::tooling::cc1modbuildd {
void writeError(llvm::Error Err, std::string Msg);
std::string getFullErrorMsg(llvm::Error Err, std::string Msg);
llvm::Error makeStringError(llvm::Error Err, std::string Msg);
-} // namespace cc1modbuildd
+// Get a temprary location where the daemon can store log files and a socket
+// address. Of the format /tmp/clang-<BLAKE3HashOfClangFullVersion>/
+std::string getBasePath();
+
+} // namespace clang::tooling::cc1modbuildd
#endif // LLVM_CLANG_TOOLING_MODULEBUILDDAEMON_UTILS_H
diff --git a/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp b/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
index b2a444dd362f5..f57dd6b2e367c 100644
--- a/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
+++ b/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
@@ -18,6 +18,7 @@
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/BLAKE3.h"
+#include "llvm/Support/Program.h"
// TODO: Make portable
#if LLVM_ON_UNIX
@@ -25,6 +26,7 @@
#include <cerrno>
#include <filesystem>
#include <fstream>
+#include <optional>
#include <signal.h>
#include <spawn.h>
#include <string>
@@ -33,28 +35,11 @@
#include <sys/un.h>
#include <unistd.h>
-using namespace clang;
using namespace llvm;
-using namespace cc1modbuildd;
-
-std::string cc1modbuildd::getBasePath() {
- llvm::BLAKE3 Hash;
- Hash.update(getClangFullVersion());
- auto HashResult = Hash.final<sizeof(uint64_t)>();
- uint64_t HashValue =
- llvm::support::endian::read<uint64_t, llvm::support::native>(
- HashResult.data());
- std::string Key = toString(llvm::APInt(64, HashValue), 36, /*Signed*/ false);
-
- // Set paths
- SmallString<128> BasePath;
- llvm::sys::path::system_temp_directory(/*erasedOnReboot*/ true, BasePath);
- llvm::sys::path::append(BasePath, "clang-" + Key);
- return BasePath.c_str();
-}
-llvm::Error cc1modbuildd::attemptHandshake(int SocketFD,
- DiagnosticsEngine &Diag) {
+namespace clang::tooling::cc1modbuildd {
+
+llvm::Error attemptHandshake(int SocketFD, DiagnosticsEngine &Diag) {
HandshakeMsg Request{ActionType::HANDSHAKE, StatusType::REQUEST};
std::string Buffer = getBufferFromSocketMsg(Request);
@@ -82,29 +67,25 @@ llvm::Error cc1modbuildd::attemptHandshake(int SocketFD,
inconvertibleErrorCode());
}
-llvm::Error cc1modbuildd::spawnModuleBuildDaemon(StringRef BasePath,
- const char *Argv0,
- DiagnosticsEngine &Diag) {
- std::string BasePathStr = BasePath.str();
- const char *Args[] = {Argv0, "-cc1modbuildd", BasePathStr.c_str(), nullptr};
- pid_t pid;
-
- // TODO: Swich to llvm::sys::ExecuteNoWait
- int EC = posix_spawn(&pid, Args[0],
- /*file_actions*/ nullptr,
- /*spawnattr*/ nullptr, const_cast<char **>(Args),
- /*envp*/ nullptr);
- if (EC)
- return createStringError(std::error_code(EC, std::generic_category()),
- "Failed to spawn module build daemon");
+llvm::Error spawnModuleBuildDaemon(StringRef BasePath, const char *Argv0,
+ DiagnosticsEngine &Diag) {
+
+ std::vector<StringRef> Args = {Argv0, "-cc1modbuildd", BasePath.str()};
+
+ std::string ErrorBuffer;
+ // Will wait until module build daemon has forked and parent process. There
+ // is extra work that needs to be done for Windows when using ExecuteNoWait
+ llvm::sys::ExecuteAndWait(Argv0, Args, std::nullopt, {}, 0, 0, &ErrorBuffer);
+
+ if (!ErrorBuffer.empty())
+ return llvm::make_error<StringError>(ErrorBuffer, inconvertibleErrorCode());
Diag.Report(diag::remark_mbd_spawn);
return llvm::Error::success();
}
-Expected<int> cc1modbuildd::getModuleBuildDaemon(const char *Argv0,
- StringRef BasePath,
- DiagnosticsEngine &Diag) {
+Expected<int> getModuleBuildDaemon(const char *Argv0, StringRef BasePath,
+ DiagnosticsEngine &Diag) {
SmallString<128> SocketPath = BasePath;
llvm::sys::path::append(SocketPath, SOCKET_FILE_NAME);
@@ -117,8 +98,7 @@ Expected<int> cc1modbuildd::getModuleBuildDaemon(const char *Argv0,
consumeError(MaybeFD.takeError());
}
- if (llvm::Error Err =
- cc1modbuildd::spawnModuleBuildDaemon(BasePath, Argv0, Diag))
+ if (llvm::Error Err = spawnModuleBuildDaemon(BasePath, Argv0, Diag))
return std::move(Err);
const unsigned int MICROSEC_IN_SEC = 1000000;
@@ -150,18 +130,18 @@ Expected<int> cc1modbuildd::getModuleBuildDaemon(const char *Argv0,
"Module build daemon could not be spawned", inconvertibleErrorCode());
}
-void cc1modbuildd::spawnModuleBuildDaemonAndHandshake(
- const CompilerInvocation &Clang, DiagnosticsEngine &Diag,
- const char *Argv0) {
+void spawnModuleBuildDaemonAndHandshake(const CompilerInvocation &Clang,
+ DiagnosticsEngine &Diag,
+ const char *Argv0) {
// The module build daemon stores all output files and its socket address
// under BasePath. Either set BasePath to a user provided option or create an
- // appropriate BasePath based on the hash of the full clang version
+ // appropriate BasePath based on the BLAKE3 hash of the full clang version
std::string BasePath;
if (!Clang.getFrontendOpts().ModuleBuildDaemonPath.empty())
BasePath = Clang.getFrontendOpts().ModuleBuildDaemonPath;
else
- BasePath = cc1modbuildd::getBasePath();
+ BasePath = getBasePath();
// TODO: Max length may vary across different platforms. Incoming llvm/Support
// for sockets will help make this portable. On most unix platforms a socket
@@ -175,8 +155,7 @@ void cc1modbuildd::spawnModuleBuildDaemonAndHandshake(
}
// If module build daemon does not exist spawn module build daemon
- Expected<int> MaybeDaemonFD =
- cc1modbuildd::getModuleBuildDaemon(Argv0, BasePath, Diag);
+ Expected<int> MaybeDaemonFD = getModuleBuildDaemon(Argv0, BasePath, Diag);
if (!MaybeDaemonFD) {
Diag.Report(diag::err_mbd_connect) << MaybeDaemonFD.takeError();
return;
@@ -192,4 +171,6 @@ void cc1modbuildd::spawnModuleBuildDaemonAndHandshake(
return;
}
+} // namespace clang::tooling::cc1modbuildd
+
#endif // LLVM_ON_UNIX
diff --git a/clang/lib/Tooling/ModuleBuildDaemon/SocketSupport.cpp b/clang/lib/Tooling/ModuleBuildDaemon/SocketSupport.cpp
index a2997aa11756b..1ac7acefe1c24 100644
--- a/clang/lib/Tooling/ModuleBuildDaemon/SocketSupport.cpp
+++ b/clang/lib/Tooling/ModuleBuildDaemon/SocketSupport.cpp
@@ -32,18 +32,22 @@
#include <sys/un.h>
#include <unistd.h>
-Expected<int> cc1modbuildd::createSocket() {
+using namespace llvm;
+
+namespace clang::tooling::cc1modbuildd {
+
+Expected<int> createSocket() {
int FD;
if ((FD = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
std::string Msg = "socket create error: " + std::string(strerror(errno));
- return createStringError(inconvertibleErrorCode(), Msg);
+ return llvm::make_error<StringError>(Msg, inconvertibleErrorCode());
}
return FD;
}
-Expected<int> cc1modbuildd::connectToSocket(StringRef SocketPath) {
+Expected<int> connectToSocket(StringRef SocketPath) {
- Expected<int> MaybeFD = cc1modbuildd::createSocket();
+ Expected<int> MaybeFD = createSocket();
if (!MaybeFD)
return std::move(MaybeFD.takeError());
@@ -56,13 +60,13 @@ Expected<int> cc1modbuildd::connectToSocket(StringRef SocketPath) {
if (connect(FD, (struct sockaddr *)&Addr, sizeof(Addr)) == -1) {
close(FD);
- std::string msg = "socket connect error: " + std::string(strerror(errno));
- return createStringError(inconvertibleErrorCode(), msg);
+ std::string Msg = "socket connect error: " + std::string(strerror(errno));
+ return llvm::make_error<StringError>(Msg, inconvertibleErrorCode());
}
return FD;
}
-llvm::Error cc1modbuildd::readFromSocket(int FD, std::string &BufferConsumer) {
+llvm::Error readFromSocket(int FD, std::string &BufferConsumer) {
char Buffer[MAX_BUFFER];
ssize_t n;
@@ -84,7 +88,7 @@ llvm::Error cc1modbuildd::readFromSocket(int FD, std::string &BufferConsumer) {
return llvm::Error::success();
}
-llvm::Error cc1modbuildd::writeToSocket(StringRef Buffer, int WriteFD) {
+llvm::Error writeToSocket(StringRef Buffer, int WriteFD) {
ssize_t BytesToWrite = static_cast<ssize_t>(Buffer.size());
const char *Bytes = Buffer.data();
@@ -102,4 +106,6 @@ llvm::Error cc1modbuildd::writeToSocket(StringRef Buffer, int WriteFD) {
return llvm::Error::success();
}
+} // namespace clang::tooling::cc1modbuildd
+
#endif // LLVM_ON_UNIX
diff --git a/clang/lib/Tooling/ModuleBuildDaemon/Utils.cpp b/clang/lib/Tooling/ModuleBuildDaemon/Utils.cpp
index 0e291987faf93..dcef183a06c07 100644
--- a/clang/lib/Tooling/ModuleBuildDaemon/Utils.cpp
+++ b/clang/lib/Tooling/ModuleBuildDaemon/Utils.cpp
@@ -6,19 +6,28 @@
//
//===----------------------------------------------------------------------===//
-#include <clang/Tooling/ModuleBuildDaemon/Utils.h>
-#include <llvm/Support/Error.h>
+#include "clang/Tooling/ModuleBuildDaemon/Utils.h"
+#include "clang/Basic/Version.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/BLAKE3.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/Path.h"
+
#include <string>
using namespace llvm;
-void cc1modbuildd::writeError(llvm::Error Err, std::string Msg) {
+namespace clang::tooling::cc1modbuildd {
+
+void writeError(llvm::Error Err, std::string Msg) {
handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {
errs() << Msg << EIB.message() << '\n';
});
}
-std::string cc1modbuildd::getFullErrorMsg(llvm::Error Err, std::string Msg) {
+std::string getFullErrorMsg(llvm::Error Err, std::string Msg) {
std::string ErrMessage;
handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {
ErrMessage = Msg + EIB.message();
@@ -26,7 +35,25 @@ std::string cc1modbuildd::getFullErrorMsg(llvm::Error Err, std::string Msg) {
return ErrMessage;
}
-llvm::Error cc1modbuildd::makeStringError(llvm::Error Err, std::string Msg) {
+llvm::Error makeStringError(llvm::Error Err, std::string Msg) {
std::string ErrMsg = getFullErrorMsg(std::move(Err), Msg);
return llvm::make_error<StringError>(ErrMsg, inconvertibleErrorCode());
}
+
+std::string getBasePath() {
+ llvm::BLAKE3 Hash;
+ Hash.update(clang::getClangFullVersion());
+ auto HashResult = Hash.final<sizeof(uint64_t)>();
+ uint64_t HashValue =
+ llvm::support::endian::read<uint64_t, llvm::endianness::native>(
+ HashResult.data());
+ std::string Key = toString(llvm::APInt(64, HashValue), 36, /*Signed*/ false);
+
+ // Set paths
+ SmallString<128> BasePath;
+ llvm::sys::path::system_temp_directory(/*erasedOnReboot*/ true, BasePath);
+ llvm::sys::path::append(BasePath, "clang-" + Key);
+ return BasePath.c_str();
+}
+
+} // namespace clang::tooling::cc1modbuildd
\ No newline at end of file
diff --git a/clang/test/ModuleBuildDaemon/handshake.c b/clang/test/ModuleBuildDaemon/handshake.c
index 288e99f51bea4..976cac47c1bce 100644
--- a/clang/test/ModuleBuildDaemon/handshake.c
+++ b/clang/test/ModuleBuildDaemon/handshake.c
@@ -7,17 +7,18 @@
//--- main.c
int main() {return 0;}
-// RUN: %clang -fmodule-build-daemon=mbd-handshake -Rmodule-build-daemon %t/main.c &> %t/output-new
+// Add '|| true' to ensure RUN command never fails so that daemon shutdown command is always run
+// RUN: %clang -fmodule-build-daemon=mbd-handshake -Rmodule-build-daemon %t/main.c &> %t/output-new || true
+// RUN: %clang -fmodule-build-daemon=mbd-handshake -Rmodule-build-daemon %t/main.c &> %t/output-existing || true
+// RUN: if pgrep -f "cc1modbuildd mbd-handshake"; then pkill -f "cc1modbuildd mbd-handshake"; fi
+
// RUN: cat %t/output-new | FileCheck %s
-// RUN: %clang -fmodule-build-daemon=mbd-handshake -Rmodule-build-daemon %t/main.c &> %t/output-existing
// RUN: cat %t/output-existing | FileCheck %s --check-prefix=CHECK-EXIST
-// COM: Check that clang invocation can spawn and handshake with module build daemon
+// Check that a clang invocation can spawn and handshake with a module build daemon
// CHECK: remark: Successfully spawned module build daemon [-Rmodule-build-daemon]
// CHECK: remark: Successfully connected to module build daemon at mbd-handshake/mbd.sock [-Rmodule-build-daemon]
// CHECK: remark: Successfully completed handshake with module build daemon [-Rmodule-build-daemon]
-// COM: Check that clang invocation can handshake with existing module build daemon
+// Check that a clang invocation can handshake with an existing module build daemon
// CHECK-EXIST: remark: Successfully completed handshake with module build daemon [-Rmodule-build-daemon]
-
-// RUN: if pgrep -f "cc1modbuildd mbd-handshake"; then pkill -f "cc1modbuildd mbd-handshake"; fi
diff --git a/clang/test/ModuleBuildDaemon/launch.c b/clang/test/ModuleBuildDaemon/launch.c
index cb4cdbc2b32af..d1bd8af7f244f 100644
--- a/clang/test/ModuleBuildDaemon/launch.c
+++ b/clang/test/ModuleBuildDaemon/launch.c
@@ -1,4 +1,4 @@
-// COM: Check that module build daemon can create unix socket
+// Check that the module build daemon can create a unix socket
// REQUIRES: !system-windows
@@ -8,6 +8,6 @@
// RUN: %clang -cc1modbuildd mbd-launch -v
// RUN: cat mbd-launch/mbd.out | FileCheck %s
-// CHECK: mbd created and binded to socket address at: mbd-launch/mbd.sock
+// CHECK: mbd created and binded to socket at: mbd-launch/mbd.sock
// RUN: if pgrep -f "cc1modbuildd mbd-launch"; then pkill -f "cc1modbuildd mbd-launch"; fi
diff --git a/clang/tools/driver/cc1_main.cpp b/clang/tools/driver/cc1_main.cpp
index 2bf4f95c34b46..b0c044feaa938 100644
--- a/clang/tools/driver/cc1_main.cpp
+++ b/clang/tools/driver/cc1_main.cpp
@@ -292,10 +292,11 @@ int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
// Handle module build daemon functionality if enabled
if (Clang->getFrontendOpts().ModuleBuildDaemon) {
#if LLVM_ON_UNIX
- cc1modbuildd::spawnModuleBuildDaemonAndHandshake(
+ clang::tooling::cc1modbuildd::spawnModuleBuildDaemonAndHandshake(
Clang->getInvocation(), Clang->getDiagnostics(), Argv0);
#else
- errs() << "-fmodule-build-daemon not supported by current platform" << '\n';
+ llvm::errs() << "-fmodule-build-daemon not supported by current platform"
+ << '\n';
return 1;
#endif
}
diff --git a/clang/tools/driver/cc1modbuildd_main.cpp b/clang/tools/driver/cc1modbuildd_main.cpp
index a20016b89961d..bfe636b258731 100644
--- a/clang/tools/driver/cc1modbuildd_main.cpp
+++ b/clang/tools/driver/cc1modbuildd_main.cpp
@@ -36,8 +36,7 @@
#include <unordered_map>
using namespace llvm;
-using namespace clang;
-using namespace cc1modbuildd;
+using namespace clang::tooling::cc1modbuildd;
// Create unbuffered STDOUT stream so that any logging done by module build
// daemon can be viewed without having to terminate the process
@@ -76,7 +75,7 @@ class ModuleBuildDaemonServer {
// TODO: modify so when shutdownDaemon is called the daemon stops accepting
// new client connections and waits for all existing client connections to
- // terminate before exiting
+ // terminate before closing the file descriptor and exiting
void shutdownDaemon() {
int SocketFD = ListenSocketFD.load();
@@ -174,7 +173,7 @@ int ModuleBuildDaemonServer::createDaemonSocket() {
std::perror("Socket bind error: ");
exit(EXIT_FAILURE);
}
- printVerboseLog("mbd created and binded to socket address at: " + SocketPath);
+ printVerboseLog("mbd created and binded to socket at: " + SocketPath);
// set socket to accept incoming connection request
unsigned MaxBacklog = llvm::hardware_concurrency().compute_thread_count();
@@ -251,34 +250,37 @@ int ModuleBuildDaemonServer::listenForClients() {
// Module build daemon is spawned with the following command line:
//
-// clang -cc1modbuildd <path> -v
+// clang [-cc1modbuildd <path>] [-v]
//
-// <path> defines the location of all files created by the module build daemon
-// and should follow the format /path/to/dir. For example, `clang
-// -cc1modbuildd /tmp/` creates a socket file at `/tmp/mbd.sock`
+// OPTIONS
+// -cc1modbuildd <path>
+// Specifies the path to all the files created by the module build daemon.
+// The <path> should immediately follow the -cc1modbuildd option.
//
-// When a module build daemon is spawned by a cc1 invocations, <path> follows
-// the format /tmp/clang-<BLAKE3HashOfClangFullVersion> and looks something like
-// /tmp/clang-3NXKISKJ0WJTN
+// -v
+// Provides verbose debug information.
//
-// -v is optional and provides berbose debug information
+// NOTES
+// The arguments <path> and -v are optional. By default <path> follows the
+// format: /tmp/clang-<BLAKE3HashOfClangFullVersion>.
//
int cc1modbuildd_main(ArrayRef<const char *> Argv) {
- if (Argv.size() < 1) {
- errs() << "spawning a module build daemon requies a command line format of "
- "`clang -cc1modbuildd <path>`. <path> defines where the module "
- "build daemon will create mbd.out, mbd.err, mbd.sock"
- << '\n';
- return 1;
- }
+ std::string BasePath;
+ if (!Argv.empty()) {
- // Where to store log files and socket address
- // TODO: Add check to confirm BasePath is directory
- std::string BasePath(Argv[0]);
+ if (find(Argv, StringRef("-v")) != Argv.end())
+ VerboseLog = true;
- // On most unix platforms a socket address cannot be over 108 characters
- int MAX_ADDR = 108;
+ if (strcmp(Argv[0], "-v") != 0)
+ BasePath = Argv[0];
+ } else
+ BasePath = getBasePath();
+
+ // TODO: Make portable. On most unix platforms a socket address cannot be over
+ // 108 characters but that may not always be the case. Functionality will be
+ // provided by llvm/Support/Sockets once that is implemented
+ const int MAX_ADDR = 108;
if (BasePath.length() >= MAX_ADDR - std::string(SOCKET_FILE_NAME).length()) {
errs() << "Provided socket path" + BasePath +
" is too long. Socket path much be equal to or less then 100 "
@@ -292,9 +294,6 @@ int cc1modbuildd_main(ArrayRef<const char *> Argv) {
// Used to handle signals
DaemonPtr = &Daemon;
- if (find(Argv, StringRef("-v")) != Argv.end())
- VerboseLog = true;
-
Daemon.forkDaemon();
Daemon.createDaemonSocket();
Daemon.listenForClients();
>From f206512283c07d2ad9f476f95b88451a91a56c3b Mon Sep 17 00:00:00 2001
From: Connor Sughrue <cpsughrue at gmail.com>
Date: Sun, 26 Nov 2023 21:13:15 -0500
Subject: [PATCH 7/9] Improve portability by removing MBD related guards in
driver.cpp and cc1_main.cpp
---
clang/tools/driver/cc1_main.cpp | 6 ---
clang/tools/driver/cc1modbuildd_main.cpp | 57 ++++++++++++++----------
clang/tools/driver/driver.cpp | 5 ---
3 files changed, 34 insertions(+), 34 deletions(-)
diff --git a/clang/tools/driver/cc1_main.cpp b/clang/tools/driver/cc1_main.cpp
index b0c044feaa938..1161ffa6e5a60 100644
--- a/clang/tools/driver/cc1_main.cpp
+++ b/clang/tools/driver/cc1_main.cpp
@@ -291,14 +291,8 @@ int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
// Handle module build daemon functionality if enabled
if (Clang->getFrontendOpts().ModuleBuildDaemon) {
-#if LLVM_ON_UNIX
clang::tooling::cc1modbuildd::spawnModuleBuildDaemonAndHandshake(
Clang->getInvocation(), Clang->getDiagnostics(), Argv0);
-#else
- llvm::errs() << "-fmodule-build-daemon not supported by current platform"
- << '\n';
- return 1;
-#endif
}
// Execute the frontend actions.
diff --git a/clang/tools/driver/cc1modbuildd_main.cpp b/clang/tools/driver/cc1modbuildd_main.cpp
index bfe636b258731..ea441bdfbfb04 100644
--- a/clang/tools/driver/cc1modbuildd_main.cpp
+++ b/clang/tools/driver/cc1modbuildd_main.cpp
@@ -17,41 +17,50 @@
#include "llvm/Support/YAMLParser.h"
#include "llvm/Support/YAMLTraits.h"
-// TODO: Make portable
-#if LLVM_ON_UNIX
+using namespace llvm;
+using namespace clang::tooling::cc1modbuildd;
#include <errno.h>
#include <fstream>
#include <mutex>
#include <optional>
-#include <signal.h>
#include <sstream>
#include <stdbool.h>
#include <string>
+#include <type_traits>
+#include <unordered_map>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <signal.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/un.h>
-#include <type_traits>
#include <unistd.h>
-#include <unordered_map>
-
-using namespace llvm;
-using namespace clang::tooling::cc1modbuildd;
+#endif
// Create unbuffered STDOUT stream so that any logging done by module build
// daemon can be viewed without having to terminate the process
static raw_fd_ostream &unbuff_outs() {
- static raw_fd_ostream S(STDOUT_FILENO, false, true);
+ static raw_fd_ostream S(fileno(stdout), false, true);
return S;
}
-namespace {
+static bool VerboseLog = false;
+static void printVerboseLog(const llvm::Twine &message) {
+ if (VerboseLog) {
+ unbuff_outs() << message << '\n';
+ }
+}
struct ClientConnection {
int ClientFD;
std::string Buffer;
};
+namespace {
+
class ModuleBuildDaemonServer {
public:
SmallString<256> SocketPath;
@@ -77,16 +86,21 @@ class ModuleBuildDaemonServer {
// new client connections and waits for all existing client connections to
// terminate before closing the file descriptor and exiting
void shutdownDaemon() {
+#ifdef _WIN32
+ // TODO: implement windows version
+#else
int SocketFD = ListenSocketFD.load();
-
unlink(SocketPath.c_str());
shutdown(SocketFD, SHUT_RD);
close(SocketFD);
_Exit(EXIT_SUCCESS);
+#endif
}
private:
+#ifndef _WIN32
pid_t Pid = -1;
+#endif
std::atomic<int> ListenSocketFD = -1;
};
@@ -99,13 +113,7 @@ void handleSignal(int Signal) {
}
} // namespace
-static bool VerboseLog = false;
-static void printVerboseLog(const llvm::Twine &message) {
- if (VerboseLog) {
- unbuff_outs() << message << '\n';
- }
-}
-
+#ifndef _WIN32
// Forks and detaches process, creating module build daemon
int ModuleBuildDaemonServer::forkDaemon() {
@@ -143,6 +151,7 @@ int ModuleBuildDaemonServer::forkDaemon() {
return EXIT_SUCCESS;
}
+// TODO: Make portable
// Creates unix socket for IPC with module build daemon
int ModuleBuildDaemonServer::createDaemonSocket() {
@@ -247,15 +256,16 @@ int ModuleBuildDaemonServer::listenForClients() {
}
return 0;
}
+#endif // LLVM_ON_UNIX
// Module build daemon is spawned with the following command line:
//
-// clang [-cc1modbuildd <path>] [-v]
+// clang -cc1modbuildd [<path>] [-v]
//
// OPTIONS
-// -cc1modbuildd <path>
+// <path>
// Specifies the path to all the files created by the module build daemon.
-// The <path> should immediately follow the -cc1modbuildd option.
+// If provided, <path> should immediately follow -cc1modbuildd.
//
// -v
// Provides verbose debug information.
@@ -264,6 +274,7 @@ int ModuleBuildDaemonServer::listenForClients() {
// The arguments <path> and -v are optional. By default <path> follows the
// format: /tmp/clang-<BLAKE3HashOfClangFullVersion>.
//
+
int cc1modbuildd_main(ArrayRef<const char *> Argv) {
std::string BasePath;
@@ -294,11 +305,11 @@ int cc1modbuildd_main(ArrayRef<const char *> Argv) {
// Used to handle signals
DaemonPtr = &Daemon;
+#ifndef _WIN32
Daemon.forkDaemon();
Daemon.createDaemonSocket();
Daemon.listenForClients();
+#endif
return 0;
}
-
-#endif // LLVM_ON_UNIX
diff --git a/clang/tools/driver/driver.cpp b/clang/tools/driver/driver.cpp
index 9697bc6d45777..3a648e4e1b235 100644
--- a/clang/tools/driver/driver.cpp
+++ b/clang/tools/driver/driver.cpp
@@ -373,12 +373,7 @@ static int ExecuteCC1Tool(SmallVectorImpl<const char *> &ArgV,
return cc1gen_reproducer_main(ArrayRef(ArgV).slice(2), ArgV[0],
GetExecutablePathVP, ToolContext);
if (Tool == "-cc1modbuildd") {
-#if LLVM_ON_UNIX
return cc1modbuildd_main(ArrayRef(ArgV).slice(2));
-#else
- llvm::errs() << "-cc1modbuildd not supported by current platform" << '\n';
- return 1;
-#endif
}
// Reject unknown tools
>From d10463305dbc2ab20346e9832a1dfefc6ce9e3a2 Mon Sep 17 00:00:00 2001
From: cpsughrue <cpsughrue at gmail.com>
Date: Wed, 6 Dec 2023 12:21:01 -0500
Subject: [PATCH 8/9] Add ability to detach process when using
llvm::sys::Execute
---
llvm/include/llvm/Support/Program.h | 3 ++-
llvm/lib/Support/Program.cpp | 9 +++++----
llvm/lib/Support/Unix/Program.inc | 18 ++++++++++++++----
llvm/lib/Support/Windows/Program.inc | 7 +++++--
4 files changed, 26 insertions(+), 11 deletions(-)
diff --git a/llvm/include/llvm/Support/Program.h b/llvm/include/llvm/Support/Program.h
index 4c1133e44a21c..a6a897704f208 100644
--- a/llvm/include/llvm/Support/Program.h
+++ b/llvm/include/llvm/Support/Program.h
@@ -152,7 +152,8 @@ namespace sys {
unsigned MemoryLimit = 0,
std::string *ErrMsg = nullptr,
bool *ExecutionFailed = nullptr,
- BitVector *AffinityMask = nullptr);
+ BitVector *AffinityMask = nullptr,
+ bool DetachProcess = false);
/// Return true if the given arguments fit within system-specific
/// argument length limits.
diff --git a/llvm/lib/Support/Program.cpp b/llvm/lib/Support/Program.cpp
index 1dcd45e2d69e8..642f6e73f32a7 100644
--- a/llvm/lib/Support/Program.cpp
+++ b/llvm/lib/Support/Program.cpp
@@ -27,7 +27,7 @@ static bool Execute(ProcessInfo &PI, StringRef Program,
std::optional<ArrayRef<StringRef>> Env,
ArrayRef<std::optional<StringRef>> Redirects,
unsigned MemoryLimit, std::string *ErrMsg,
- BitVector *AffinityMask);
+ BitVector *AffinityMask, bool DetachProcess);
int sys::ExecuteAndWait(StringRef Program, ArrayRef<StringRef> Args,
std::optional<ArrayRef<StringRef>> Env,
@@ -39,7 +39,7 @@ int sys::ExecuteAndWait(StringRef Program, ArrayRef<StringRef> Args,
assert(Redirects.empty() || Redirects.size() == 3);
ProcessInfo PI;
if (Execute(PI, Program, Args, Env, Redirects, MemoryLimit, ErrMsg,
- AffinityMask)) {
+ AffinityMask, /*DetachProcess*/ false)) {
if (ExecutionFailed)
*ExecutionFailed = false;
ProcessInfo Result = Wait(
@@ -58,13 +58,14 @@ ProcessInfo sys::ExecuteNoWait(StringRef Program, ArrayRef<StringRef> Args,
std::optional<ArrayRef<StringRef>> Env,
ArrayRef<std::optional<StringRef>> Redirects,
unsigned MemoryLimit, std::string *ErrMsg,
- bool *ExecutionFailed, BitVector *AffinityMask) {
+ bool *ExecutionFailed, BitVector *AffinityMask,
+ bool DetachProcess) {
assert(Redirects.empty() || Redirects.size() == 3);
ProcessInfo PI;
if (ExecutionFailed)
*ExecutionFailed = false;
if (!Execute(PI, Program, Args, Env, Redirects, MemoryLimit, ErrMsg,
- AffinityMask))
+ AffinityMask, DetachProcess))
if (ExecutionFailed)
*ExecutionFailed = true;
diff --git a/llvm/lib/Support/Unix/Program.inc b/llvm/lib/Support/Unix/Program.inc
index 9466d0f0ba859..c57053d37fc71 100644
--- a/llvm/lib/Support/Unix/Program.inc
+++ b/llvm/lib/Support/Unix/Program.inc
@@ -171,10 +171,11 @@ toNullTerminatedCStringArray(ArrayRef<StringRef> Strings, StringSaver &Saver) {
}
static bool Execute(ProcessInfo &PI, StringRef Program,
- ArrayRef<StringRef> Args, std::optional<ArrayRef<StringRef>> Env,
+ ArrayRef<StringRef> Args,
+ std::optional<ArrayRef<StringRef>> Env,
ArrayRef<std::optional<StringRef>> Redirects,
unsigned MemoryLimit, std::string *ErrMsg,
- BitVector *AffinityMask) {
+ BitVector *AffinityMask, bool DetachProcess) {
if (!llvm::sys::fs::exists(Program)) {
if (ErrMsg)
*ErrMsg = std::string("Executable \"") + Program.str() +
@@ -200,7 +201,8 @@ static bool Execute(ProcessInfo &PI, StringRef Program,
// If this OS has posix_spawn and there is no memory limit being implied, use
// posix_spawn. It is more efficient than fork/exec.
#ifdef HAVE_POSIX_SPAWN
- if (MemoryLimit == 0) {
+ // Cannot use posix_spawn if you would like to detach the process
+ if (MemoryLimit == 0 && !DetachProcess) {
posix_spawn_file_actions_t FileActionsStore;
posix_spawn_file_actions_t *FileActions = nullptr;
@@ -268,7 +270,7 @@ static bool Execute(ProcessInfo &PI, StringRef Program,
return true;
}
-#endif
+#endif // HAVE_POSIX_SPAWN
// Create a child process.
int child = fork();
@@ -305,6 +307,14 @@ static bool Execute(ProcessInfo &PI, StringRef Program,
}
}
+ if (DetachProcess) {
+ // Detach from controlling terminal
+ if (setsid() == -1) {
+ MakeErrMsg(ErrMsg, "Couldn't detach process, setsid() failed");
+ return false;
+ }
+ }
+
// Set memory limits
if (MemoryLimit != 0) {
SetMemoryLimits(MemoryLimit);
diff --git a/llvm/lib/Support/Windows/Program.inc b/llvm/lib/Support/Windows/Program.inc
index 0de9d3f756448..d98d55f317a35 100644
--- a/llvm/lib/Support/Windows/Program.inc
+++ b/llvm/lib/Support/Windows/Program.inc
@@ -172,10 +172,11 @@ static HANDLE RedirectIO(std::optional<StringRef> Path, int fd,
} // namespace llvm
static bool Execute(ProcessInfo &PI, StringRef Program,
- ArrayRef<StringRef> Args, std::optional<ArrayRef<StringRef>> Env,
+ ArrayRef<StringRef> Args,
+ std::optional<ArrayRef<StringRef>> Env,
ArrayRef<std::optional<StringRef>> Redirects,
unsigned MemoryLimit, std::string *ErrMsg,
- BitVector *AffinityMask) {
+ BitVector *AffinityMask, bool DetachProcess) {
if (!sys::fs::can_execute(Program)) {
if (ErrMsg)
*ErrMsg = "program not executable";
@@ -284,6 +285,8 @@ static bool Execute(ProcessInfo &PI, StringRef Program,
unsigned CreateFlags = CREATE_UNICODE_ENVIRONMENT;
if (AffinityMask)
CreateFlags |= CREATE_SUSPENDED;
+ if (DetachProcess)
+ CreateFlags |= DETACHED_PROCESS;
std::vector<wchar_t> CommandUtf16(Command.size() + 1, 0);
std::copy(Command.begin(), Command.end(), CommandUtf16.begin());
>From 3b74c4428aad705d4fa031fb01dde9dab7e7adbb Mon Sep 17 00:00:00 2001
From: cpsughrue <cpsughrue at gmail.com>
Date: Wed, 6 Dec 2023 15:18:06 -0500
Subject: [PATCH 9/9] WIP
---
clang/lib/Tooling/ModuleBuildDaemon/Client.cpp | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp b/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
index f57dd6b2e367c..e04a7d1a480c4 100644
--- a/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
+++ b/clang/lib/Tooling/ModuleBuildDaemon/Client.cpp
@@ -73,8 +73,7 @@ llvm::Error spawnModuleBuildDaemon(StringRef BasePath, const char *Argv0,
std::vector<StringRef> Args = {Argv0, "-cc1modbuildd", BasePath.str()};
std::string ErrorBuffer;
- // Will wait until module build daemon has forked and parent process. There
- // is extra work that needs to be done for Windows when using ExecuteNoWait
+ // TODO: Switch to ExecuteNoWait and set DetachProcess to true
llvm::sys::ExecuteAndWait(Argv0, Args, std::nullopt, {}, 0, 0, &ErrorBuffer);
if (!ErrorBuffer.empty())
More information about the cfe-commits
mailing list