Removed artificial limits using PATH_MAX.

Petter Reinholdtsen · Petter Reinholdtsen · commit a6123da185e7 · 2026-03-28T11:25:15.000+01:00
Rewrote all code using PATH_MAX to instead dynamically allocate the required
buffers.  As the actually max path length depend on the file system used, it
is not a good idea to pretend a compiled in buffer limit will work everywhere.

This also fixes build problems detected on GNU Hurd.
diff --git a/src/tbb/cgroup_info.h b/src/tbb/cgroup_info.h
@@ -149,26 +149,43 @@ class cgroup_info {
     }
 
     static bool try_read_cgroup_v1_num_cpus_from(const char* dir, int& num_cpus) {
-        char path[PATH_MAX] = {0};
-        if (std::snprintf(path, PATH_MAX, "%s/cpu.cfs_quota_us", dir) < 0)
+        std::size_t pathlen = strlen(dir) + 30;
+        char *path = (char*)calloc(pathlen, 1);
+        if (std::snprintf(path, pathlen, "%s/cpu.cfs_quota_us", dir) < 0) {
+            free(path);
+            path = NULL;
             return false;       // Failed to create path
+        }
 
         unique_file_t fd(std::fopen(path, "r"), &close_file);
-        if (!fd)
+        if (!fd) {
+            free(path);
+            path = NULL;
             return false;
+        }
 
         long long cpu_quota = 0;
-        if (std::fscanf(fd.get(), "%lld", &cpu_quota) != 1)
+        if (std::fscanf(fd.get(), "%lld", &cpu_quota) != 1) {
+            free(path);
+            path = NULL;
             return false;
+        }
 
         if (-1 == cpu_quota) {
             num_cpus = unlimited_num_cpus; // -1 quota means maximum available CPUs
+            free(path);
+            path = NULL;
             return true;
         }
 
-        if (std::snprintf(path, PATH_MAX, "%s/cpu.cfs_period_us", dir) < 0)
+        if (std::snprintf(path, pathlen, "%s/cpu.cfs_period_us", dir) < 0) {
+            free(path);
+            path = NULL;
             return false;       // Failed to create path;
+        }
         fd.reset(std::fopen(path, "r"));
+        free(path);
+        path = NULL;
         if (!fd)
             return false;
 
@@ -181,11 +198,17 @@ class cgroup_info {
     }
 
     static bool try_read_cgroup_v2_num_cpus_from(const char* dir, int& num_cpus) {
-        char path[PATH_MAX] = {0};
-        if (std::snprintf(path, PATH_MAX, "%s/cpu.max", dir) < 0)
+        std::size_t pathlen = strlen(dir) + 30;
+        char *path = (char*)calloc(pathlen, 1);
+        if (std::snprintf(path, pathlen, "%s/cpu.max", dir) < 0) {
+            free(path);
+            path = NULL;
             return false;       // Failed to create path
+        }
 
         unique_file_t fd(std::fopen(path, "r"), &close_file);
+        free(path);
+        path = NULL;
         if (!fd)
             return false;
 
@@ -222,14 +245,19 @@ class cgroup_info {
 
     static int parse_cgroup_entry(const char* mnt_dir, process_cgroup_data& pcd) {
         int num_cpus = error_value; // Initialize to an impossible value
-        char dir[PATH_MAX] = {0};
-        if (std::snprintf(dir, PATH_MAX, "%s/%s", mnt_dir, pcd.relative_path) >= 0) {
+        std::size_t dirlen = strlen(mnt_dir) + strlen(pcd.relative_path) + 2;
+        char *dir = (char*)calloc(dirlen, 1);
+        if (std::snprintf(dir, dirlen, "%s/%s", mnt_dir, pcd.relative_path) >= 0) {
             if (try_read_cgroup_num_cpus_from(dir, num_cpus, pcd.version)) {
+                free(dir);
+                dir = NULL;
                 return num_cpus;
             }
         }
-
-        return try_read_cgroup_num_cpus_from(mnt_dir, num_cpus, pcd.version) ? num_cpus : error_value;
+        num_cpus = try_read_cgroup_num_cpus_from(mnt_dir, num_cpus, pcd.version) ? num_cpus : error_value;
+        free(dir);
+        dir = NULL;
+        return num_cpus;
     }
 
     static bool is_cpu_restriction_possible(process_cgroup_data& pcd) {
@@ -276,17 +304,22 @@ class cgroup_info {
     static int try_common_cgroup_mount_path(const process_cgroup_data& pcd,
                                             const cgroup_settings& cg_cfg) {
         int num_cpus = error_value;
-        char dir[PATH_MAX] = {0};
+        std::size_t dirlen = (strlen(pcd.relative_path)
+                              + strlen(cg_cfg.sys_fs_cgroup_dir_path)
+                              + 25);
+        char *dir = (char*)calloc(dirlen, 1);
         __TBB_ASSERT(*pcd.relative_path, nullptr);
-        if (0 <= std::snprintf(dir, PATH_MAX, "%s/%s", cg_cfg.sys_fs_cgroup_dir_path,
+        if (0 <= std::snprintf(dir, dirlen, "%s/%s", cg_cfg.sys_fs_cgroup_dir_path,
                                pcd.relative_path))
             try_read_cgroup_num_cpus_from(dir, num_cpus, pcd.version);
 
         if (error_value == num_cpus && pcd.version == process_cgroup_data::cgroup_version::v2) {
-            if (0 <= std::snprintf(dir, PATH_MAX, "%s/%s", "/sys/fs/cgroup/unified",
+            if (0 <= std::snprintf(dir, dirlen, "%s/%s", "/sys/fs/cgroup/unified",
                                    pcd.relative_path))
                 try_read_cgroup_v2_num_cpus_from(dir, num_cpus);
         }
+        free(dir);
+        dir = NULL;
         return num_cpus;
     }
 
diff --git a/src/tbb/dynamic_link.cpp b/src/tbb/dynamic_link.cpp
@@ -45,9 +45,6 @@
     #include <wintrust.h>
     #pragma comment (lib, "wintrust")     // Link with the Wintrust.lib file.
 #endif
-#ifndef PATH_MAX
-    #define PATH_MAX                MAX_PATH
-#endif
 #else /* _WIN32 */
     #include <dlfcn.h>
     #include <unistd.h>
@@ -177,7 +174,7 @@ namespace r1 {
             break;
         case dl_buff_too_small:
             TBB_FPRINTF(stderr, "%s An internal buffer representing a path to dynamically loaded "
-                        "module is small. Consider compiling with larger value for PATH_MAX macro.\n",
+                        "module is small.\n",
                         prefix);
             break;
         case dl_unload_fail:
@@ -340,12 +337,15 @@ namespace r1 {
     static std::once_flag init_dl_data_state;
 
     static struct ap_data_t {
-        char _path[PATH_MAX+1];
+        char *_path;
+        std::size_t _capacity;
         std::size_t _len;
     } ap_data;
 
     static void init_ap_data() {
     #if _WIN32
+        ap_data._capacity = MAX_PATH;
+        ap_data._path = (char*)calloc(ap_data._capacity, 1);
         // Get handle of our DLL first.
         HMODULE handle;
         BOOL brc = GetModuleHandleEx(
@@ -356,30 +356,45 @@ namespace r1 {
         if ( !brc ) { // Error occurred.
             int err = GetLastError();
             DYNAMIC_LINK_WARNING( dl_sys_fail, "GetModuleHandleEx", err );
+            free(ap_data._path);
+            ap_data._path = NULL;
+            ap_data._capacity = 0;
             return;
         }
         // Now get path to our DLL.
-        DWORD drc = GetModuleFileName( handle, ap_data._path, static_cast< DWORD >( PATH_MAX ) );
+        DWORD drc = GetModuleFileName( handle, ap_data._path, static_cast< DWORD >( ap_data._capacity ) );
         if ( drc == 0 ) { // Error occurred.
             int err = GetLastError();
             DYNAMIC_LINK_WARNING( dl_sys_fail, "GetModuleFileName", err );
+            free(ap_data._path);
+            ap_data._path = NULL;
+            ap_data._capacity = 0;
             return;
         }
-        if ( drc >= PATH_MAX ) { // Buffer too short.
+        if ( drc >= ap_data._capacity ) { // Buffer too short.
             DYNAMIC_LINK_WARNING( dl_buff_too_small );
+            free(ap_data._path);
+            ap_data._path = NULL;
+            ap_data._capacity = 0;
             return;
         }
         // Find the position of the last backslash.
         char *backslash = std::strrchr( ap_data._path, '\\' );
 
         if ( !backslash ) {    // Backslash not found.
             __TBB_ASSERT_EX( backslash != nullptr, "Unbelievable.");
+            free(ap_data._path);
+            ap_data._path = NULL;
+            ap_data._capacity = 0;
             return;
         }
         __TBB_ASSERT_EX( backslash >= ap_data._path, "Unbelievable.");
         ap_data._len = (std::size_t)(backslash - ap_data._path) + 1;
         *(backslash+1) = 0;
     #else
+        // Initial capacity, double until large enough
+        ap_data._capacity = 4096;
+        ap_data._path = (char*)calloc(ap_data._capacity, 1);
         // There is an use case, when we want to find TBB library, not just some shared object
         // providing "dynamic_link" symbol (it can be shared object that directly includes
         // dynamic_link.cpp). For this case we use a public TBB symbol. Searching for public symbol
@@ -397,6 +412,9 @@ namespace r1 {
         if ( !res ) {
             char const * err = dlerror();
             DYNAMIC_LINK_WARNING( dl_sys_fail, "dladdr", err );
+            free(ap_data._path);
+            ap_data._path = NULL;
+            ap_data._capacity = 0;
             return;
         } else {
             __TBB_ASSERT_EX( dlinfo.dli_fname!=nullptr, "Unbelievable." );
@@ -416,9 +434,14 @@ namespace r1 {
             ap_data._len = 0;
         } else {
             // The library path is relative so get the current working directory
-            if ( !getcwd( ap_data._path, sizeof(ap_data._path)/sizeof(ap_data._path[0]) ) ) {
-                DYNAMIC_LINK_WARNING( dl_buff_too_small );
-                return;
+            while ( !getcwd( ap_data._path, ap_data._capacity) ) {
+                free(ap_data._path);
+                ap_data._capacity *= 2;
+                ap_data._path = (char*)calloc(ap_data._capacity, 1);
+                if (NULL == ap_data._path) {
+                    DYNAMIC_LINK_WARNING( dl_buff_too_small );
+                    return;
+                }
             }
             ap_data._len = std::strlen( ap_data._path );
             ap_data._path[ap_data._len++]='/';
@@ -427,9 +450,12 @@ namespace r1 {
 
         if ( fname_len>0 ) {
             ap_data._len += fname_len;
-            if ( ap_data._len>PATH_MAX ) {
+            if ( ap_data._len>ap_data._capacity ) {
                 DYNAMIC_LINK_WARNING( dl_buff_too_small );
                 ap_data._len=0;
+                free(ap_data._path);
+                ap_data._path = NULL;
+                ap_data._capacity = 0;
                 return;
             }
             std::strncpy( ap_data._path+rc, dlinfo.dli_fname, fname_len );
@@ -463,7 +489,9 @@ namespace r1 {
         if ( full_len < len ) {
             __TBB_ASSERT_EX( ap_data._path[ap_data._len] == 0, nullptr );
             __TBB_ASSERT_EX( std::strlen(ap_data._path) == ap_data._len, nullptr );
-            std::strncpy( path, ap_data._path, ap_data._len + 1 );
+            // No need for strncpy, test above confirmed enough space
+            // and do not need zero padding at the end.
+            std::strcpy( path, ap_data._path);
             __TBB_ASSERT_EX( path[ap_data._len] == 0, nullptr );
             std::strncat( path, name, len - ap_data._len );
             __TBB_ASSERT_EX( std::strlen(path) == full_len, nullptr );
@@ -662,14 +690,17 @@ namespace r1 {
      *         occurs, in which case the error is optionally reported.
      */
     bool has_valid_signature(const char* filepath, const std::size_t length) {
-        __TBB_ASSERT_EX(length <= PATH_MAX, "Too small buffer for path conversion");
-        wchar_t wfilepath[PATH_MAX] = {0};
+        std::size_t pathlen = strlen(filepath)+1;
+        wchar_t *wfilepath = (wchar_t*)calloc(pathlen, sizeof(wchar_t));
         {
             std::mbstate_t state{};
             const char* ansi_filepath = filepath; // mbsrtowcs moves original pointer
             const size_t num_converted = mbsrtowcs(wfilepath, &ansi_filepath, length, &state);
-            if (num_converted == std::size_t(-1))
+            if (num_converted == std::size_t(-1)) {
+                free (wfilepath);
+                wfilepath = NULL;
                 return false;
+            }
         }
         WINTRUST_FILE_INFO fdata;
         std::memset(&fdata, 0, sizeof(fdata));
@@ -699,6 +730,8 @@ namespace r1 {
         pWVTData.dwStateAction = WTD_STATEACTION_CLOSE;       // Release WVT state data
         (void)WinVerifyTrust(NULL, &pgActionID, &pWVTData);
 
+        free (wfilepath);
+        wfilepath = NULL;
         return ERROR_SUCCESS == rc;
     }
 #endif  // _WIN32 && !__TBB_SKIP_DEPENDENCY_SIGNATURE_VERIFICATION
@@ -710,42 +743,50 @@ namespace r1 {
         dynamic_link_handle library_handle = nullptr;
 #if __TBB_DYNAMIC_LOAD_ENABLED
         const char* path = library;
-        std::size_t const len = PATH_MAX + 1;
-        char absolute_path[ len ] = {0};
+        std::size_t len = abs_path( library, NULL, 1);
+        char *absolute_path = (char*)calloc(len, 1);
         std::size_t length = 0;
         const bool build_absolute_path = flags & DYNAMIC_LINK_BUILD_ABSOLUTE_PATH;
         if (build_absolute_path) {
             length = abs_path( library, absolute_path, len );
-            if (length > len) {
-                DYNAMIC_LINK_WARNING( dl_buff_too_small );
-                return nullptr;
-            } else if (length == 0) {
+            if (length == 0) {
                 // length == 0 means failing of init_ap_data so the warning has already been issued.
+                free(absolute_path);
+                absolute_path = NULL;
                 return nullptr;
             } else if (!file_exists(absolute_path)) {
                 // Path to a file has been built manually. It is not proven to exist however.
                 DYNAMIC_LINK_WARNING( dl_lib_not_found, absolute_path, dlerror() );
+                free(absolute_path);
+                absolute_path = NULL;
                 return nullptr;
             }
             path = absolute_path;
         }
 #if _WIN32
 #if !__TBB_SKIP_DEPENDENCY_SIGNATURE_VERIFICATION
         if (!build_absolute_path) { // Get the path if it is not yet built
-            length = get_module_path(absolute_path, len, library);
+            length = get_module_path(absolute_path, (unsigned)len, library);
             if (length == 0) {
                 DYNAMIC_LINK_WARNING( dl_lib_not_found, path, dlerror() );
+                free(absolute_path);
+                absolute_path = NULL;
                 return library_handle;
             } else if (length >= len) { // The buffer length was insufficient
                 DYNAMIC_LINK_WARNING( dl_buff_too_small );
+                free(absolute_path);
+                absolute_path = NULL;
                 return library_handle;
             }
             length += 1;   // Count terminating NULL character as part of string length
             path = absolute_path;
         }
 
-        if (!has_valid_signature(path, length))
+        if (!has_valid_signature(path, length)) {
+            free(absolute_path);
+            absolute_path = NULL;
             return library_handle; // Warning (if any) has already been reported
+        }
 #endif /* !__TBB_SKIP_DEPENDENCY_SIGNATURE_VERIFICATION */
         // Prevent Windows from displaying silly message boxes if it fails to load library
         // (e.g. because of MS runtime problems - one of those crazy manifest related ones)
@@ -764,6 +805,8 @@ namespace r1 {
             }
         } else
             DYNAMIC_LINK_WARNING( dl_lib_not_found, path, dlerror() );
+        free(absolute_path);
+        absolute_path = NULL;
 #endif /* __TBB_DYNAMIC_LOAD_ENABLED */
         return library_handle;
     }
diff --git a/src/tbb/dynamic_link.h b/src/tbb/dynamic_link.h
@@ -1,5 +1,6 @@
 /*
     Copyright (c) 2005-2025 Intel Corporation
+    Copyright (c) 2026 UXL Foundation Contributors
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -132,8 +133,7 @@ enum dynamic_link_error_t : int {
     // System call returned error status
     dl_sys_fail,                // char const * func, dlerr_t err
 
-    // Internal intermediate buffer is too small, consider setting PATH_MAX
-    // macro to a larger value
+    // Internal intermediate buffer is too small
     dl_buff_too_small,          // none
 
     // An error during library unload
diff --git a/src/tbb/tools_api/ittnotify_static.c b/src/tbb/tools_api/ittnotify_static.c
@@ -20,9 +20,6 @@
 #include "ittnotify_config.h"
 
 #if ITT_PLATFORM==ITT_PLATFORM_WIN
-#if !defined(PATH_MAX)
-#define PATH_MAX 512
-#endif
 #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
 #include <limits.h>
 #include <dlfcn.h>
diff --git a/test/common/utils_concurrency_limit.h b/test/common/utils_concurrency_limit.h
diff --git a/test/tbb/test_dynamic_link.cpp b/test/tbb/test_dynamic_link.cpp
