load DLLs only from safe load list

Author: KFilipek

.github/scripts/check_dll_flags.ps1

@@ -0,0 +1,42 @@
+# Copyright (C) 2023-2024 Intel Corporation
+# Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+# Invoke-CmdScript runs a command script and updates the current environment 
+# with any flag changes set by the script.
+function Invoke-CmdScript {
+  param(
+    [String] $scriptName
+  )
+  $cmdLine = """$scriptName"" $args & set"
+  & $Env:SystemRoot\system32\cmd.exe /c $cmdLine |
+  select-string '^([^=]*)=(.*)$' | foreach-object {
+    $varName = $_.Matches[0].Groups[1].Value
+    $varValue = $_.Matches[0].Groups[2].Value
+    set-item Env:$varName $varValue
+  }
+}
+
+# Get the path to vcvarsall.bat
+$vsPath = & "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe" `
+  -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 `
+  -property installationPath
+$vsPath = "$vsPath\VC\Auxiliary\Build"
+$vcvarsall = "${vsPath}\vcvarsall.bat"
+echo "Visual Studio path: $vsPath"
+echo "vcvarsall.bat path: $vcvarsall"
+
+# Call vcvarsall.bat so we can run MSVC commands
+echo "Setting up MSVC environment..."
+Invoke-CmdScript "$vcvarsall" x86
+
+# Get umf.dll configuration flags and check if DEPENDENTLOADFLAG is set to 0x2000
+$flags = & "${env:VCToolsInstallDir}\bin\Hostx64\x64\dumpbin.exe" /LOADCONFIG "$args/build/bin/Release/umf.dll"
+if (($flags | Where-Object { $_ -match '(\d+).*Dependent' } | ForEach-Object { $matches[1] } ) -eq "2000") { 
+  echo "The DEPENDENTLOADFLAG is correclty set to 0x2000."
+  exit 0
+} else {
+  echo "The DEPENDENTLOADFLAG is not correclty set"
+  echo "$flags"
+  exit 1
+}

.github/workflows/basic.yml

@@ -228,6 +228,57 @@ jobs:
         --umf-version ${{env.UMF_VERSION}}
         ${{ matrix.shared_library == 'ON' && '--shared-library' || ''}}
 
+  windows-build_hwloc:
+    name: "Windows + static hwloc"
+    env:
+      VCPKG_PATH: "${{github.workspace}}/build/vcpkg/packages/tbb_x64-windows;${{github.workspace}}/build/vcpkg/packages/jemalloc_x64-windows"
+      BUILD_DIR : "${{github.workspace}}/build/${{matrix.build_type}}"
+      INSTL_DIR : "${{github.workspace}}/../install-dir"
+    strategy:
+      matrix:
+        os: ['windows-2019', 'windows-2022']
+        build_type: [Release]
+        shared_library: ['ON']
+        level_zero_provider: ['OFF']
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+
+    - name: Initialize vcpkg
+      uses: lukka/run-vcpkg@5e0cab206a5ea620130caf672fce3e4a6b5666a1 # v11.5
+      with:
+        vcpkgGitCommitId: 3dd44b931481d7a8e9ba412621fa810232b66289
+        vcpkgDirectory: ${{github.workspace}}/build/vcpkg
+        vcpkgJsonGlob: '**/vcpkg.json'
+
+    - name: Install dependencies
+      run: vcpkg install
+      shell: pwsh # Specifies PowerShell as the shell for running the script.
+
+    - name: Configure build
+      run: >
+        cmake
+        -B ${{env.BUILD_DIR}}
+        -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
+        -DUMF_BUILD_SHARED_LIBRARY=${{matrix.shared_library}}
+        -DUMF_FORMAT_CODE_STYLE=OFF
+        -DUMF_DEVELOPER_MODE=ON
+        -DUMF_BUILD_LIBUMF_POOL_DISJOINT=ON
+        -DUMF_BUILD_LIBUMF_POOL_JEMALLOC=ON
+        -DUMF_BUILD_LEVEL_ZERO_PROVIDER=${{matrix.level_zero_provider}}
+        -DUMF_TESTS_FAIL_ON_SKIP=ON
+        -DUMF_LINK_HWLOC_STATICALLY=ON
+
+    - name: Build UMF
+      run: cmake --build ${{env.BUILD_DIR}} --config ${{matrix.build_type}} -j $Env:NUMBER_OF_PROCESSORS
+
+    - name: Run tests
+      working-directory: ${{env.BUILD_DIR}}
+      run: ctest -C ${{matrix.build_type}} --output-on-failure --test-dir test
+
   macos-build:
     name: MacOS
     strategy:

.github/workflows/pr_push.yml

@@ -82,6 +82,7 @@ jobs:
       run: >
         cmake
         -B ${{github.workspace}}/build
+        -DCMAKE_VERBOSE_MAKEFILE=ON
         -DCMAKE_PREFIX_PATH="${{env.VCPKG_PATH}}"
         -DUMF_FORMAT_CODE_STYLE=OFF
         -DUMF_DEVELOPER_MODE=ON
@@ -91,6 +92,7 @@ jobs:
         -DUMF_BUILD_EXAMPLES=ON
         -DUMF_BUILD_LEVEL_ZERO_PROVIDER=ON
         -DUMF_TESTS_FAIL_ON_SKIP=ON
+        -DUMF_BUILD_SHARED_LIBRARY=ON
         ${{matrix.extra_build_options}}
 
     - name: Configure CMake (simple)
@@ -114,6 +116,11 @@ jobs:
       working-directory: ${{github.workspace}}/build
       run: ctest --output-on-failure --test-dir test -C Release
 
+    - name: check /DEPENDENTLOADFLAG (Windows only)
+      if: matrix.os == 'windows-latest'
+      run: ${{github.workspace}}/.github/scripts/check_dll_flags.ps1 ${{github.workspace}}
+      shell: pwsh
+
   CodeStyle:
     name: Coding style
     runs-on: ubuntu-latest

CMakeLists.txt

@@ -14,6 +14,11 @@ set(UMF_CMAKE_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 list(APPEND CMAKE_MODULE_PATH "${UMF_CMAKE_SOURCE_DIR}/cmake")
 include(${UMF_CMAKE_SOURCE_DIR}/cmake/helpers.cmake)
 
+include(CTest)
+include(CMakePackageConfigHelpers)
+include(GNUInstallDirs)
+find_package(PkgConfig)
+
 # CMAKE_PROJECT_VERSION[_MAJOR|_MINOR|_PATCH] variables are set via 'project'
 # command. They cannot contain any "pre-release" part, though. We use custom
 # "UMF_SRC_VERSION" to store more accurate (source) version - this var should be
@@ -37,6 +42,8 @@ option(UMF_BUILD_BENCHMARKS "Build UMF benchmarks" OFF)
 option(UMF_BUILD_BENCHMARKS_MT "Build UMF multithreaded benchmarks" OFF)
 option(UMF_BUILD_EXAMPLES "Build UMF examples" ON)
 option(UMF_BUILD_GPU_EXAMPLES "Build UMF GPU examples" OFF)
+option(UMF_LINK_HWLOC_STATICALLY
+       "Link UMF with HWLOC library statically (Windows+Release only)" OFF)
 option(UMF_DEVELOPER_MODE "Enable developer checks, treats warnings as errors"
        OFF)
 option(UMF_FORMAT_CODE_STYLE
@@ -83,6 +90,47 @@ else()
     message(FATAL_ERROR "Unknown OS type")
 endif()
 
+if(NOT UMF_LINK_HWLOC_STATICALLY)
+    pkg_check_modules(LIBHWLOC hwloc>=2.3.0)
+    if(NOT LIBHWLOC_FOUND)
+        find_package(LIBHWLOC 2.3.0 REQUIRED hwloc)
+    endif()
+    # add PATH to DLL on Windows
+    set(DLL_PATH_LIST
+        "${DLL_PATH_LIST};PATH=path_list_append:${LIBHWLOC_LIBRARY_DIRS}/../bin"
+    )
+else()
+    if(NOT WIN32)
+        message(FATAL_ERROR "hwloc can be static linked only on Windows")
+    endif()
+    include(FetchContent)
+    FetchContent_Declare(
+        hwloc_targ
+        GIT_REPOSITORY "https://github.com/open-mpi/hwloc.git"
+        GIT_TAG hwloc-2.10.0
+        FIND_PACKAGE_ARGS)
+
+    FetchContent_GetProperties(hwloc_targ)
+    if(NOT hwloc_targ_POPULATED)
+        FetchContent_MakeAvailable(hwloc_targ)
+    endif()
+
+    set(HWLOC_ENABLE_TESTING OFF)
+    set(HWLOC_SKIP_LSTOPO ON)
+    set(HWLOC_SKIP_TOOLS ON)
+    set(hwloc_cmake ${hwloc_targ_SOURCE_DIR}/contrib/windows-cmake)
+
+    add_subdirectory(${hwloc_cmake} ${hwloc_targ_SOURCE_DIR})
+
+    set(LIBHWLOC_INCLUDE_DIRS ${hwloc_targ_SOURCE_DIR}/include)
+    set(LIBHWLOC_LIBRARY_DIRS ${hwloc_targ_SOURCE_DIR}/Release)
+    set(LIBHWLOC_LIBRARIES ${LIBHWLOC_LIBRARY_DIRS}/hwloc.lib)
+
+    message(STATUS "    LIBHWLOC_LIBRARIES = ${LIBHWLOC_LIBRARIES}")
+    message(STATUS "    LIBHWLOC_INCLUDE_DIRS = ${LIBHWLOC_INCLUDE_DIRS}")
+    message(STATUS "    LIBHWLOC_LIBRARY_DIRS = ${LIBHWLOC_LIBRARY_DIRS}")
+endif()
+
 # This build type check is not possible on Windows when CMAKE_BUILD_TYPE is not
 # set, because in this case the build type is determined after a CMake
 # configuration is done (at the build time)
@@ -130,11 +178,6 @@ foreach(option_name ${OPTIONS_REQUIRING_CXX})
     endif()
 endforeach()
 
-include(CTest)
-include(CMakePackageConfigHelpers)
-include(GNUInstallDirs)
-find_package(PkgConfig)
-
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
 set(CMAKE_UMF_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
@@ -179,7 +222,8 @@ if(WINDOWS)
     add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
     # set PATH to DLLs on Windows
     set(DLL_PATH_LIST
-        "PATH=path_list_append:${PROJECT_BINARY_DIR}/bin/$<CONFIG>")
+        "${DLL_PATH_LIST};PATH=path_list_append:${PROJECT_BINARY_DIR}/bin/$<CONFIG>"
+    )
     # add path to the proxy lib DLL
     set(DLL_PATH_LIST
         "${DLL_PATH_LIST};PATH=path_list_append:${PROJECT_BINARY_DIR}/src/proxy_lib"
@@ -190,14 +234,6 @@ if(WINDOWS)
     )
 endif()
 
-pkg_check_modules(LIBHWLOC hwloc>=2.3.0)
-if(NOT LIBHWLOC_FOUND)
-    find_package(LIBHWLOC 2.3.0 REQUIRED hwloc)
-endif()
-# add PATH to DLL on Windows
-set(DLL_PATH_LIST
-    "${DLL_PATH_LIST};PATH=path_list_append:${LIBHWLOC_LIBRARY_DIRS}/../bin")
-
 pkg_check_modules(TBB tbb)
 if(NOT TBB_FOUND)
     find_package(TBB OPTIONAL_COMPONENTS tbb)

README.md

@@ -126,6 +126,7 @@ List of options provided by CMake:
 | USE_MSAN | Enable MemorySanitizer checks | ON/OFF | OFF |
 | USE_VALGRIND | Enable Valgrind instrumentation | ON/OFF | OFF |
 | USE_GCOV | Enable gcov support (Linux only) | ON/OFF | OFF |
+| UMF_LINK_HWLOC_STATICALLY | Link UMF with HWLOC library statically (Windows+Release only) | ON/OFF | OFF |
 
 ## Architecture: memory pools and providers
 

cmake/helpers.cmake

@@ -136,12 +136,22 @@ function(add_umf_target_link_options name)
             endif()
         endif()
     elseif(MSVC)
+        message(STATUS "CXX_COMPILER_ID: ${CXX_COMPILER_ID}")
+        message(STATUS "CLANG_CXX_COMPILER_ID: ${CLANG_CXX_COMPILER_ID}")
+        message(STATUS "CLANG_CXX_LINKER_ID: ${CLANG_CXX_LINKER_ID}")
+        message(
+            STATUS
+                "CLANG_CXX_COMPILER_LINKER_ID: ${CLANG_CXX_COMPILER_LINKER_ID}")
         target_link_options(
             ${name}
             PRIVATE
+            # allow loading a DLL only from safe load list
+            $<$<CXX_COMPILER_ID:MSVC>:/DEPENDENTLOADFLAG:0x2000>
             /DYNAMICBASE
             /HIGHENTROPYVA
             /NXCOMPAT)
+        get_target_property(my_link_options ${name} LINK_OPTIONS)
+        message(STATUS "Link options for my_executable: ${my_link_options}")
     endif()
 endfunction()
 

src/CMakeLists.txt

@@ -131,6 +131,10 @@ else()
         LIBS ${UMF_LIBS})
 endif()
 
+if(UMF_LINK_HWLOC_STATICALLY)
+    add_dependencies(umf hwloc)
+endif()
+
 target_link_directories(umf PRIVATE ${UMF_PRIVATE_LIBRARY_DIRS})
 
 target_compile_definitions(umf PRIVATE ${UMF_PRIVATE_COMPILE_DEFINITIONS})