[DL] check register_alpaqa_problem_version() before loading

Author: tttapa

doxygen/pages/Problem-formulations.md

@@ -275,6 +275,10 @@ register_alpaqa_problem(alpaqa_register_arg_t user_data) noexcept try {
 } catch (...) {
     return {.exception = new alpaqa_exception_ptr_t{std::current_exception()}};
 }
+
+/// Used by @ref alpaqa::dl::DLProblem to ensure binary compatibility.
+extern "C" alpaqa_dl_abi_version_t
+register_alpaqa_problem_version() { return ALPAQA_DL_ABI_VERSION; }
 ```
 
 A full example can be found in @ref problems/sparse-logistic-regression.cpp.

examples/C++/DLProblem/CMakeLists.txt

@@ -1,24 +1,16 @@
-add_library(problem-c MODULE problem.c)
-set_target_properties(problem-c PROPERTIES PREFIX "" DEBUG_POSTFIX "")
-
-# DLL import/export
-include(GenerateExportHeader)
-generate_export_header(problem-c
-    EXPORT_FILE_NAME problem-c-export.h)
-set_target_properties(problem-c PROPERTIES
-    C_VISIBILITY_PRESET "hidden"
-    VISIBILITY_INLINES_HIDDEN true)
+# Build the loadable problem
+alpaqa_add_dl_problem_module(problem-c FILES problem.c)
 target_compile_features(problem-c PRIVATE c_std_11)
-target_include_directories(problem-c PRIVATE
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>)
-target_link_libraries(problem-c PRIVATE alpaqa::dl-api alpaqa::warnings)
+target_link_libraries(problem-c PRIVATE alpaqa::warnings)
 
+# Build the driver program that loads the problem
 add_executable(dl-problem-example main.cpp)
 target_link_libraries(dl-problem-example
     PRIVATE alpaqa::alpaqa alpaqa::warnings alpaqa::dl-loader)
-target_compile_definitions(dl-problem-example PRIVATE
-    DLPROBLEM_DLL=\"$<TARGET_FILE_NAME:problem-c>\")
+target_compile_definitions(dl-problem-example
+    PRIVATE DLPROBLEM_DLL=\"$<TARGET_FILE_NAME:problem-c>\")
 add_dependencies(dl-problem-example problem-c)
 
+# Stand-alone executable to test the matrix functions used by problem-c
 add_executable(test-matmul "test-matmul.c")
 target_link_libraries(test-matmul PRIVATE alpaqa::dl-api alpaqa::warnings)

examples/C++/DLProblem/problem.c

@@ -1,5 +1,5 @@
 #include <alpaqa/dl/dl-problem.h>
-#include <problem-c-export.h>
+#include <problem-c/export.h>
 
 #include <stdlib.h>
 #include <string.h>
@@ -114,3 +114,7 @@ register_alpaqa_problem(alpaqa_register_arg_t user_data) {
     result.functions = &problem->functions;
     return result;
 }
+
+PROBLEM_C_EXPORT alpaqa_dl_abi_version_t register_alpaqa_problem_version(void) {
+    return ALPAQA_DL_ABI_VERSION;
+}

examples/examples.dox

@@ -187,7 +187,7 @@
  * problem, and a pointer to the provided functions (the `funcs` member from
  * earlier).
  *
- * The entry point also accepts a pointer to type-erased user data. You can
+ * The entry point also accepts an argument with type-erased user data. You can
  * use this to pass any additional data to the problem constructor, such as
  * problem parameters. When using the `alpaqa-driver` program, the type of this
  * user data is always `std::any *`. Inside of the `std::any`, there is a span

examples/problems/sparse-logistic-regression.cpp

@@ -260,3 +260,11 @@ register_alpaqa_problem(alpaqa_register_arg_t user_data_v) noexcept try {
 } catch (...) {
     return {.exception = new alpaqa_exception_ptr_t{std::current_exception()}};
 }
+
+/// Returns the alpaqa DL ABI version. This version is verified for
+/// compatibility by the @ref alpaqa::dl::DLProblem constructor before
+/// registering the problem.
+extern "C" SPARSE_LOGISTIC_REGRESSION_EXPORT alpaqa_dl_abi_version_t
+register_alpaqa_problem_version() {
+    return ALPAQA_DL_ABI_VERSION;
+}

src/cmake/dl-problem.cmake

@@ -9,7 +9,11 @@ function(alpaqa_configure_dl_problem_visibility target)
     if (CMAKE_SYSTEM_NAME MATCHES "Linux")
         set(VERSION_SCRIPT "${CMAKE_CURRENT_BINARY_DIR}/${target}-export.lds")
         file(WRITE ${VERSION_SCRIPT}
-            "{ global: ${ALPAQA_CONFIG_VIS_FUNCTION_NAME}; local: *; };")
+            "{ local: *;"
+            " global: ${ALPAQA_CONFIG_VIS_FUNCTION_NAME};"
+            " global: ${ALPAQA_CONFIG_VIS_FUNCTION_NAME}_version;"
+            " global: _ZTI*;"
+            " global: _ZTS*; };")
         target_link_options(${target} PRIVATE
             "LINKER:--version-script=${VERSION_SCRIPT}"
             "LINKER:--exclude-libs,ALL")

src/interop/dl-api/include/alpaqa/dl/dl-problem.h

@@ -31,6 +31,7 @@ extern "C" {
 typedef double alpaqa_real_t;
 typedef ptrdiff_t alpaqa_length_t;
 typedef alpaqa_length_t alpaqa_index_t;
+typedef uint64_t alpaqa_dl_abi_version_t;
 
 /// User-provided argument that is passed to the problem registration functions.
 ALPAQA_BEGIN_STRUCT(alpaqa_register_arg_t) {
@@ -418,7 +419,7 @@ typedef struct alpaqa_exception_ptr_s alpaqa_exception_ptr_t;
 ALPAQA_BEGIN_STRUCT(alpaqa_problem_register_t) {
     /// To check whether the loaded problem is compatible with the version of
     /// the solver.
-    uint64_t abi_version ALPAQA_DEFAULT(ALPAQA_DL_ABI_VERSION);
+    alpaqa_dl_abi_version_t abi_version ALPAQA_DEFAULT(ALPAQA_DL_ABI_VERSION);
     /// Owning pointer.
     void *instance ALPAQA_DEFAULT(nullptr);
     /// Non-owning pointer, lifetime at least as long as @ref instance.
@@ -594,7 +595,7 @@ ALPAQA_END_STRUCT(alpaqa_control_problem_functions_t);
 ALPAQA_BEGIN_STRUCT(alpaqa_control_problem_register_t) {
     /// To check whether the loaded problem is compatible with the version of
     /// the solver.
-    uint64_t abi_version ALPAQA_DEFAULT(ALPAQA_DL_ABI_VERSION);
+    alpaqa_dl_abi_version_t abi_version ALPAQA_DEFAULT(ALPAQA_DL_ABI_VERSION);
     /// Owning pointer.
     void *instance ALPAQA_DEFAULT(nullptr);
     /// Non-owning pointer, lifetime at least as long as @ref instance.

src/interop/dl/include/alpaqa/dl/dl-problem.hpp

@@ -17,6 +17,14 @@
 
 namespace alpaqa::dl {
 
+struct DL_LOADER_EXPORT invalid_abi_error : std::runtime_error {
+    using std::runtime_error::runtime_error;
+};
+
+struct DL_LOADER_EXPORT function_load_error : std::runtime_error {
+    using std::runtime_error::runtime_error;
+};
+
 class ExtraFuncs {
   public:
     /// Unique type for calling an extra function that is a member function.

src/interop/dl/src/dl-problem.cpp

@@ -6,6 +6,7 @@
 #include <algorithm>
 #include <cassert>
 #include <charconv>
+#include <iostream>
 #include <list>
 #include <memory>
 #include <mutex>
@@ -35,7 +36,7 @@ void check_abi_version(uint64_t abi_version) {
     if (abi_version != ALPAQA_DL_ABI_VERSION) {
         auto prob_version   = format_abi_version(abi_version);
         auto alpaqa_version = format_abi_version(ALPAQA_DL_ABI_VERSION);
-        throw std::runtime_error(
+        throw invalid_abi_error(
             "alpaqa::dl::DLProblem::DLProblem: "
             "Incompatible problem definition (problem ABI version 0x" +
             prob_version + ", this version of alpaqa supports 0x" +
@@ -62,8 +63,8 @@ std::shared_ptr<void> load_lib(const std::filesystem::path &so_filename) {
     assert(!so_filename.empty());
     void *h = LoadLibraryW(so_filename.c_str());
     if (!h)
-        throw std::runtime_error("Unable to load \"" + so_filename.string() +
-                                 "\": " + get_last_error_msg().get());
+        throw function_load_error("Unable to load \"" + so_filename.string() +
+                                  "\": " + get_last_error_msg().get());
 #if ALPAQA_NO_DLCLOSE
     return std::shared_ptr<void>{h, +[](void *) {}};
 #else
@@ -77,8 +78,8 @@ F *load_func(void *handle, const std::string &name) {
     assert(handle);
     auto *h = GetProcAddress(static_cast<HMODULE>(handle), name.c_str());
     if (!h)
-        throw std::runtime_error("Unable to load function '" + name +
-                                 "': " + get_last_error_msg().get());
+        throw function_load_error("Unable to load function '" + name +
+                                  "': " + get_last_error_msg().get());
     // We can only hope that the user got the signature right ...
     return reinterpret_cast<F *>(h);
 }
@@ -88,7 +89,7 @@ std::shared_ptr<void> load_lib(const std::filesystem::path &so_filename) {
     ::dlerror();
     void *h = ::dlopen(so_filename.c_str(), RTLD_LOCAL | RTLD_NOW);
     if (auto *err = ::dlerror())
-        throw std::runtime_error(err);
+        throw function_load_error(err);
 #if ALPAQA_NO_DLCLOSE
     return std::shared_ptr<void>{h, +[](void *) {}};
 #else
@@ -102,8 +103,8 @@ F *load_func(void *handle, const std::string &name) {
     ::dlerror();
     auto *h = ::dlsym(handle, name.c_str());
     if (auto *err = ::dlerror())
-        throw std::runtime_error("Unable to load function '" + name +
-                                 "': " + err);
+        throw function_load_error("Unable to load function '" + name +
+                                  "': " + err);
     // We can only hope that the user got the signature right ...
     return reinterpret_cast<F *>(h);
 }
@@ -205,7 +206,17 @@ DLProblem::DLProblem(const std::filesystem::path &so_filename,
     : BoxConstrProblem{0, 0} {
     if (so_filename.empty())
         throw std::invalid_argument("Invalid problem filename");
-    handle              = load_lib(so_filename);
+    handle = load_lib(so_filename);
+    try {
+        auto *version_func = load_func<alpaqa_dl_abi_version_t(void)>(
+            handle.get(), function_name + "_version");
+        check_abi_version(version_func());
+    } catch (const function_load_error &) {
+        std::cerr << "Warning: problem " << so_filename
+                  << " does not provide a function to query the ABI version, "
+                     "alpaqa_dl_abi_version_t "
+                  << function_name << "_version(void)\n";
+    }
     auto *register_func = load_func<problem_register_t(alpaqa_register_arg_t)>(
         handle.get(), function_name);
     auto r = register_func(user_param);
@@ -342,6 +353,16 @@ DLControlProblem::DLControlProblem(const std::filesystem::path &so_filename,
     if (so_filename.empty())
         throw std::invalid_argument("Invalid problem filename");
     handle = load_lib(so_filename);
+    try {
+        auto *version_func = load_func<alpaqa_dl_abi_version_t(void)>(
+            handle.get(), function_name + "_version");
+        check_abi_version(version_func());
+    } catch (const function_load_error &) {
+        std::cerr << "Warning: problem " << so_filename
+                  << " does not provide a function to query the ABI version, "
+                     "alpaqa_dl_abi_version_t "
+                  << function_name << "_version(void)\n";
+    }
     auto *register_func =
         load_func<control_problem_register_t(alpaqa_register_arg_t)>(
             handle.get(), function_name);