Userland/BuggieBox: Build a static-pie version

In this version we only need the dynamic loader to load this program,
but any other library is contained in the generated binary, hence making
it possible to embed it in emergency environment or containers.

As an immediate result, the next commit would make it possible to only
copy the dynamic loader and the static-pie version of BuggieBox into a
containerized environment, in which it can happily run without any other
dependencies anymore.

Personally, this has been a goal I worked on for a very long time, and I
finally succeeded to finish this patch by realizing (with the help of
ChatGPT) that I needed to include the whole LibC archive during linking
because of how weak symbols are being resolved with library archives vs
library shared objects.

Author: supercomputer7

Meta/CMake/utils.cmake

@@ -126,6 +126,17 @@ if (NOT COMMAND serenity_bin)
     endfunction()
 endif()
 
+if (NOT COMMAND serenity_static_bin)
+    function(serenity_static_bin target_name)
+        serenity_install_sources()
+        add_executable(${target_name} ${SOURCES})
+        target_link_libraries(${target_name} PUBLIC GenericClangPlugin)
+        set_target_properties(${target_name} PROPERTIES EXCLUDE_FROM_ALL TRUE)
+        install(TARGETS ${target_name} RUNTIME DESTINATION bin OPTIONAL)
+        serenity_generated_sources(${target_name})
+    endfunction()
+endif()
+
 if (NOT COMMAND serenity_test)
     function(serenity_test test_src sub_dir)
         cmake_parse_arguments(PARSE_ARGV 2 SERENITY_TEST "MAIN_ALREADY_DEFINED" "CUSTOM_MAIN" "LIBS")

Userland/BuggieBox/CMakeLists.txt

@@ -4,9 +4,15 @@ serenity_component(
     TARGETS BuggieBox
 )
 
-function (buggiebox_utility src)
+serenity_component(
+    BuggieBoxStatic
+    REQUIRED
+    TARGETS BuggieBoxStatic
+)
+
+function (buggiebox_utility buggiebox src)
     get_filename_component(utility ${src} NAME_WE)
-    target_sources(BuggieBox PRIVATE ${src})
+    target_sources(${buggiebox} PRIVATE ${src})
     set_source_files_properties(${src} PROPERTIES COMPILE_DEFINITIONS "serenity_main=${utility}_main")
 endfunction()
 
@@ -18,8 +24,8 @@ set(utility_srcs
     ../Utilities/cp.cpp
     ../Utilities/df.cpp
     ../Utilities/env.cpp
-    ../Utilities/file.cpp
     ../Utilities/find.cpp
+    ../Utilities/file.cpp
     ../Utilities/id.cpp
     ../Utilities/init.cpp
     ../Utilities/less.cpp
@@ -44,9 +50,28 @@ serenity_bin(BuggieBox)
 target_sources(BuggieBox PRIVATE main.cpp)
 target_link_libraries(BuggieBox PRIVATE LibMain LibShellMinimal LibArchive LibCompress LibCore LibCrypto LibELF LibFileSystem LibGfx LibLine LibRegex LibAudio LibURL)
 
+serenity_static_bin(BuggieBoxStatic)
+target_sources(BuggieBoxStatic PRIVATE main.cpp)
+target_link_libraries(BuggieBoxStatic PRIVATE StaticPIE_CompileOptions LibStaticPIE)
+
+# If we don't include the whole archive, the linker might miss some weak symbols to override such as pthread_cond_broadcast.
+target_link_libraries(BuggieBoxStatic PRIVATE
+    $<LINK_LIBRARY:WHOLE_ARCHIVE,BuggieBox_LibC>
+)
+
+target_link_libraries(BuggieBoxStatic PRIVATE BuggieBox_LibMain 
+                    BuggieBox_LibSystem BuggieBox_LibShellMinimal BuggieBox_LibCoreMinimal BuggieBox_LibCoreBasic 
+                    BuggieBox_LibELF BuggieBox_LibArchive BuggieBox_LibAudio BuggieBox_LibGfx)
+
+                    
+foreach(file IN LISTS utility_srcs)
+   buggiebox_utility(BuggieBox ${file})
+endforeach()
+
 foreach(file IN LISTS utility_srcs)
-   buggiebox_utility(${file})
+   buggiebox_utility(BuggieBoxStatic ${file})
 endforeach()
 
 target_sources(BuggieBox PRIVATE ../Shell/main.cpp)
+target_sources(BuggieBoxStatic PRIVATE ../Shell/main.cpp)
 set_source_files_properties( ../Shell/main.cpp PROPERTIES COMPILE_DEFINITIONS "serenity_main=sh_main")

Userland/BuggieBox/main.cpp

@@ -7,7 +7,6 @@
 
 #include <AK/LexicalPath.h>
 #include <LibMain/Main.h>
-#include <LibShell/Shell.h>
 
 #define ENUMERATE_UTILITIES(E, ALIAS) \
     ALIAS(b2sum, checksum)            \
@@ -126,7 +125,7 @@ static ErrorOr<int> buggiebox_main(Main::Arguments arguments)
 ErrorOr<int> serenity_main(Main::Arguments arguments)
 {
     LexicalPath runbase { arguments.strings[0] };
-    if (runbase.basename() == "BuggieBox"sv) {
+    if (runbase.basename() == "BuggieBox"sv || runbase.basename() == "BuggieBoxStatic"sv) {
         Main::Arguments utility_arguments = arguments;
         utility_arguments.argc--;
         utility_arguments.argv++;

Userland/DynamicLoader/CMakeLists.txt

@@ -3,6 +3,10 @@ set(SOURCES
     misc.cpp
 )
 
+# ===== LibPIERuntime for Static PIE programs =====
+add_library(LibPIERuntime STATIC misc.cpp)
+target_link_libraries(LibPIERuntime PRIVATE StaticPIE_CompileOptions)
+
 add_library(DynamicLoader_CompileOptions INTERFACE)
 target_compile_definitions(DynamicLoader_CompileOptions INTERFACE NO_TLS _DYNAMIC_LOADER)
 target_compile_options(DynamicLoader_CompileOptions INTERFACE -fno-rtti -fpie -ffunction-sections -fdata-sections)

Userland/Libraries/CMakeLists.txt

@@ -76,3 +76,17 @@ add_subdirectory(LibWeb)
 add_subdirectory(LibWebSocket)
 add_subdirectory(LibWebView)
 add_subdirectory(LibXML)
+
+add_library(StaticPIE_CompileOptions INTERFACE)
+target_compile_options(StaticPIE_CompileOptions INTERFACE -ffunction-sections -fdata-sections)
+target_compile_definitions(StaticPIE_CompileOptions INTERFACE NO_LIBC)
+target_compile_options(StaticPIE_CompileOptions INTERFACE)
+target_link_options(StaticPIE_CompileOptions INTERFACE -nolibc -pthread -nostartfiles -static-libgcc -static-libstdc++ -Wl,--gc-sections)
+add_dependencies(StaticPIE_CompileOptions install_libc_headers)
+
+add_library(LibStaticPIE)
+target_link_libraries(LibStaticPIE
+    PUBLIC StaticPIE_CompileOptions
+)
+target_sources(LibStaticPIE PRIVATE ./LibC/crt0_standalone.cpp)
+target_sources(LibStaticPIE PRIVATE ../DynamicLoader/misc.cpp)

Userland/Libraries/LibArchive/CMakeLists.txt

@@ -6,3 +6,10 @@ set(SOURCES
 
 serenity_lib(LibArchive archive)
 target_link_libraries(LibArchive PRIVATE LibCompress LibCore LibCrypto)
+
+# ===== LibArchive for BuggieBox =====
+add_library(BuggieBox_LibArchive STATIC ${SOURCES})
+target_link_libraries(BuggieBox_LibArchive
+    PUBLIC StaticPIE_CompileOptions
+    PRIVATE BuggieBox_LibCompress BuggieBox_LibCore BuggieBox_LibCrypto
+)

Userland/Libraries/LibAudio/CMakeLists.txt

@@ -37,6 +37,14 @@ endif()
 serenity_lib(LibAudio audio)
 target_link_libraries(LibAudio PRIVATE LibCore LibRIFF LibIPC LibThreading LibUnicode LibCrypto)
 
+if (SERENITYOS)
+    add_library(BuggieBox_LibAudio STATIC ${SOURCES})
+    target_link_libraries(BuggieBox_LibAudio
+        PUBLIC StaticPIE_CompileOptions
+        PRIVATE BuggieBox_LibCore BuggieBox_LibRIFF BuggieBox_LibIPC BuggieBox_LibThreading BuggieBox_LibUnicode BuggieBox_LibCrypto
+    )
+endif()
+
 if (HAVE_PULSEAUDIO)
     target_link_libraries(LibAudio PRIVATE pulse)
     target_compile_definitions(LibAudio PRIVATE HAVE_PULSEAUDIO=1)

Userland/Libraries/LibC/CMakeLists.txt

@@ -131,3 +131,10 @@ target_link_libraries(DynamicLoader_LibC
     PUBLIC DynamicLoader_CompileOptions
     PRIVATE DynamicLoader_LibSystem
 )
+
+# ===== LibC for BuggieBox =====
+add_library(BuggieBox_LibC STATIC ${SOURCES})
+target_link_libraries(BuggieBox_LibC
+    PUBLIC StaticPIE_CompileOptions
+    PRIVATE BuggieBox_LibSystem
+)

Userland/Libraries/LibC/crt0_standalone.cpp

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/Types.h>
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/internals.h>
+#include <unistd.h>
+
+extern "C" {
+
+int main(int, char**, char**);
+
+// Tell the compiler that this may be called from somewhere else.
+int _entry(int argc, char** argv) __attribute__((used));
+void _start(int, char**, char**) __attribute__((used));
+
+NAKED void _start(int, char**, char**)
+{
+#if ARCH(AARCH64)
+    asm(
+        "mov x29, 0\n"
+        "mov x30, 0\n"
+        "bl _entry\n");
+#elif ARCH(RISCV64)
+    asm(
+        "li fp, 0\n"
+        "li ra, 0\n"
+        "tail _entry@plt\n");
+#elif ARCH(X86_64)
+    asm(
+        "push $0\n"
+        "jmp _entry@plt\n");
+#else
+#    error "Unknown architecture"
+#endif
+}
+
+int _entry(int argc, char** argv)
+{
+    // In the original crt0.cpp, we didn't need this line, but we don't
+    // run with libc as **defined** dependency (i.e. shared object),
+    // therefore the expected initialization of the dynamic libc.so that
+    // should done by the DynamicLinker is never actually done,
+    // specifically at DynamicLinker::initialize_libc method.
+    // Thus, let's initialize our own "copy" of libc in this binary so
+    // everything could work as expected.
+    __libc_init();
+
+    __begin_atexit_locking();
+
+    int status = main(argc, argv, environ);
+
+    exit(status);
+
+    return 20150614;
+}
+}

Userland/Libraries/LibC/libcinit.cpp

@@ -25,7 +25,17 @@ bool __stdio_is_initialized = false;
 void* __auxiliary_vector = reinterpret_cast<void*>(explode_byte(0xe1));
 
 #ifndef _DYNAMIC_LOADER
+#    ifdef NO_LIBC
+// NOTE: For static-PIE programs that don't depend on libc, but are not dynamic loader
+// we need to wait for crt0_standalone.cpp to actually call __libc_init() to ensure
+// we actually have a proper environment set here.
+// For the time being, just declare it as an empty array.
+char* __static_environ[] = { nullptr };
+char** environ = __static_environ;
+#    else
 char** environ = reinterpret_cast<char**>(explode_byte(0xe2));
+#    endif
+
 uintptr_t __stack_chk_guard;
 #endif